3 * Copyright (c) 2004-2007 Atheros Communications Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation;
11 * Software distributed under the License is distributed on an "AS
12 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
13 * implied. See the License for the specific language governing
14 * rights and limitations under the License.
20 #include "ar6000_drv.h"
22 static A_UINT8 bcast_mac
[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
23 static A_UINT8 null_mac
[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
24 extern USER_RSSI_THOLD rssi_map
[12];
25 extern unsigned int wmitimeout
;
26 extern A_WAITQUEUE_HEAD arEvent
;
27 extern int tspecCompliance
;
32 ar6000_ioctl_get_roam_tbl(struct net_device
*dev
, struct ifreq
*rq
)
34 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
36 if (ar
->arWmiReady
== FALSE
) {
40 if(wmi_get_roam_tbl_cmd(ar
->arWmi
) != A_OK
) {
48 ar6000_ioctl_get_roam_data(struct net_device
*dev
, struct ifreq
*rq
)
50 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
52 if (ar
->arWmiReady
== FALSE
) {
57 /* currently assume only roam times are required */
58 if(wmi_get_roam_data_cmd(ar
->arWmi
, ROAM_DATA_TIME
) != A_OK
) {
67 ar6000_ioctl_set_roam_ctrl(struct net_device
*dev
, char *userdata
)
69 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
70 WMI_SET_ROAM_CTRL_CMD cmd
;
71 A_UINT8 size
= sizeof(cmd
);
73 if (ar
->arWmiReady
== FALSE
) {
78 if (copy_from_user(&cmd
, userdata
, size
)) {
82 if (cmd
.roamCtrlType
== WMI_SET_HOST_BIAS
) {
83 if (cmd
.info
.bssBiasInfo
.numBss
> 1) {
84 size
+= (cmd
.info
.bssBiasInfo
.numBss
- 1) * sizeof(WMI_BSS_BIAS
);
88 if (copy_from_user(&cmd
, userdata
, size
)) {
92 if(wmi_set_roam_ctrl_cmd(ar
->arWmi
, &cmd
, size
) != A_OK
) {
100 ar6000_ioctl_set_powersave_timers(struct net_device
*dev
, char *userdata
)
102 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
103 WMI_POWERSAVE_TIMERS_POLICY_CMD cmd
;
104 A_UINT8 size
= sizeof(cmd
);
106 if (ar
->arWmiReady
== FALSE
) {
110 if (copy_from_user(&cmd
, userdata
, size
)) {
114 if (copy_from_user(&cmd
, userdata
, size
)) {
118 if(wmi_set_powersave_timers_cmd(ar
->arWmi
, &cmd
, size
) != A_OK
) {
126 ar6000_ioctl_set_wmm(struct net_device
*dev
, struct ifreq
*rq
)
128 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
132 if ((dev
->flags
& IFF_UP
) != IFF_UP
) {
135 if (ar
->arWmiReady
== FALSE
) {
139 if (copy_from_user(&cmd
, (char *)((unsigned int*)rq
->ifr_data
+ 1),
145 if (cmd
.status
== WMI_WMM_ENABLED
) {
146 ar
->arWmmEnabled
= TRUE
;
148 ar
->arWmmEnabled
= FALSE
;
151 ret
= wmi_set_wmm_cmd(ar
->arWmi
, cmd
.status
);
167 ar6000_ioctl_set_txop(struct net_device
*dev
, struct ifreq
*rq
)
169 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
170 WMI_SET_WMM_TXOP_CMD cmd
;
173 if ((dev
->flags
& IFF_UP
) != IFF_UP
) {
176 if (ar
->arWmiReady
== FALSE
) {
180 if (copy_from_user(&cmd
, (char *)((unsigned int*)rq
->ifr_data
+ 1),
186 ret
= wmi_set_wmm_txop(ar
->arWmi
, cmd
.txopEnable
);
202 ar6000_ioctl_get_rd(struct net_device
*dev
, struct ifreq
*rq
)
204 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
207 if ((dev
->flags
& IFF_UP
) != IFF_UP
|| ar
->arWmiReady
== FALSE
) {
211 if(copy_to_user((char *)((unsigned int*)rq
->ifr_data
+ 1),
212 &ar
->arRegCode
, sizeof(ar
->arRegCode
)))
219 /* Get power mode command */
221 ar6000_ioctl_get_power_mode(struct net_device
*dev
, struct ifreq
*rq
)
223 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
224 WMI_POWER_MODE_CMD power_mode
;
227 if (ar
->arWmiReady
== FALSE
) {
231 power_mode
.powerMode
= wmi_get_power_mode_cmd(ar
->arWmi
);
232 if (copy_to_user(rq
->ifr_data
, &power_mode
, sizeof(WMI_POWER_MODE_CMD
))) {
241 ar6000_ioctl_set_channelParams(struct net_device
*dev
, struct ifreq
*rq
)
243 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
244 WMI_CHANNEL_PARAMS_CMD cmd
, *cmdp
;
247 if (ar
->arWmiReady
== FALSE
) {
252 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
256 if (cmd
.numChannels
> 1) {
257 cmdp
= A_MALLOC(130);
258 if (copy_from_user(cmdp
, rq
->ifr_data
,
260 ((cmd
.numChannels
- 1) * sizeof(A_UINT16
))))
269 if ((ar
->arPhyCapability
== WMI_11G_CAPABILITY
) &&
270 ((cmdp
->phyMode
== WMI_11A_MODE
) || (cmdp
->phyMode
== WMI_11AG_MODE
)))
276 (wmi_set_channelParams_cmd(ar
->arWmi
, cmdp
->scanParam
, cmdp
->phyMode
,
277 cmdp
->numChannels
, cmdp
->channelList
)
283 if (cmd
.numChannels
> 1) {
291 ar6000_ioctl_set_snr_threshold(struct net_device
*dev
, struct ifreq
*rq
)
294 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
295 WMI_SNR_THRESHOLD_PARAMS_CMD cmd
;
298 if (ar
->arWmiReady
== FALSE
) {
302 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
306 if( wmi_set_snr_threshold_params(ar
->arWmi
, &cmd
) != A_OK
) {
314 ar6000_ioctl_set_rssi_threshold(struct net_device
*dev
, struct ifreq
*rq
)
316 #define SWAP_THOLD(thold1, thold2) do { \
317 USER_RSSI_THOLD tmpThold; \
318 tmpThold.tag = thold1.tag; \
319 tmpThold.rssi = thold1.rssi; \
320 thold1.tag = thold2.tag; \
321 thold1.rssi = thold2.rssi; \
322 thold2.tag = tmpThold.tag; \
323 thold2.rssi = tmpThold.rssi; \
326 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
327 WMI_RSSI_THRESHOLD_PARAMS_CMD cmd
;
328 USER_RSSI_PARAMS rssiParams
;
333 if (ar
->arWmiReady
== FALSE
) {
337 if (copy_from_user((char *)&rssiParams
, (char *)((unsigned int *)rq
->ifr_data
+ 1), sizeof(USER_RSSI_PARAMS
))) {
340 cmd
.weight
= rssiParams
.weight
;
341 cmd
.pollTime
= rssiParams
.pollTime
;
343 A_MEMCPY(rssi_map
, &rssiParams
.tholds
, sizeof(rssi_map
));
345 * only 6 elements, so use bubble sorting, in ascending order
347 for (i
= 5; i
> 0; i
--) {
348 for (j
= 0; j
< i
; j
++) { /* above tholds */
349 if (rssi_map
[j
+1].rssi
< rssi_map
[j
].rssi
) {
350 SWAP_THOLD(rssi_map
[j
+1], rssi_map
[j
]);
351 } else if (rssi_map
[j
+1].rssi
== rssi_map
[j
].rssi
) {
356 for (i
= 11; i
> 6; i
--) {
357 for (j
= 6; j
< i
; j
++) { /* below tholds */
358 if (rssi_map
[j
+1].rssi
< rssi_map
[j
].rssi
) {
359 SWAP_THOLD(rssi_map
[j
+1], rssi_map
[j
]);
360 } else if (rssi_map
[j
+1].rssi
== rssi_map
[j
].rssi
) {
367 for (i
= 0; i
< 12; i
++) {
368 AR_DEBUG2_PRINTF("thold[%d].tag: %d, thold[%d].rssi: %d \n",
369 i
, rssi_map
[i
].tag
, i
, rssi_map
[i
].rssi
);
372 cmd
.thresholdAbove1_Val
= rssi_map
[0].rssi
;
373 cmd
.thresholdAbove2_Val
= rssi_map
[1].rssi
;
374 cmd
.thresholdAbove3_Val
= rssi_map
[2].rssi
;
375 cmd
.thresholdAbove4_Val
= rssi_map
[3].rssi
;
376 cmd
.thresholdAbove5_Val
= rssi_map
[4].rssi
;
377 cmd
.thresholdAbove6_Val
= rssi_map
[5].rssi
;
378 cmd
.thresholdBelow1_Val
= rssi_map
[6].rssi
;
379 cmd
.thresholdBelow2_Val
= rssi_map
[7].rssi
;
380 cmd
.thresholdBelow3_Val
= rssi_map
[8].rssi
;
381 cmd
.thresholdBelow4_Val
= rssi_map
[9].rssi
;
382 cmd
.thresholdBelow5_Val
= rssi_map
[10].rssi
;
383 cmd
.thresholdBelow6_Val
= rssi_map
[11].rssi
;
385 if( wmi_set_rssi_threshold_params(ar
->arWmi
, &cmd
) != A_OK
) {
393 ar6000_ioctl_set_lq_threshold(struct net_device
*dev
, struct ifreq
*rq
)
396 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
397 WMI_LQ_THRESHOLD_PARAMS_CMD cmd
;
400 if (ar
->arWmiReady
== FALSE
) {
404 if (copy_from_user(&cmd
, (char *)((unsigned int *)rq
->ifr_data
+ 1), sizeof(cmd
))) {
408 if( wmi_set_lq_threshold_params(ar
->arWmi
, &cmd
) != A_OK
) {
417 ar6000_ioctl_set_probedSsid(struct net_device
*dev
, struct ifreq
*rq
)
419 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
420 WMI_PROBED_SSID_CMD cmd
;
423 if (ar
->arWmiReady
== FALSE
) {
427 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
431 if (wmi_probedSsid_cmd(ar
->arWmi
, cmd
.entryIndex
, cmd
.flag
, cmd
.ssidLength
,
441 ar6000_ioctl_set_badAp(struct net_device
*dev
, struct ifreq
*rq
)
443 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
444 WMI_ADD_BAD_AP_CMD cmd
;
447 if (ar
->arWmiReady
== FALSE
) {
452 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
456 if (cmd
.badApIndex
> WMI_MAX_BAD_AP_INDEX
) {
460 if (A_MEMCMP(cmd
.bssid
, null_mac
, AR6000_ETH_ADDR_LEN
) == 0) {
462 * This is a delete badAP.
464 if (wmi_deleteBadAp_cmd(ar
->arWmi
, cmd
.badApIndex
) != A_OK
) {
468 if (wmi_addBadAp_cmd(ar
->arWmi
, cmd
.badApIndex
, cmd
.bssid
) != A_OK
) {
477 ar6000_ioctl_create_qos(struct net_device
*dev
, struct ifreq
*rq
)
479 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
480 WMI_CREATE_PSTREAM_CMD cmd
;
483 if (ar
->arWmiReady
== FALSE
) {
488 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
492 ret
= wmi_verify_tspec_params(&cmd
, tspecCompliance
);
494 ret
= wmi_create_pstream_cmd(ar
->arWmi
, &cmd
);
510 ar6000_ioctl_delete_qos(struct net_device
*dev
, struct ifreq
*rq
)
512 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
513 WMI_DELETE_PSTREAM_CMD cmd
;
516 if (ar
->arWmiReady
== FALSE
) {
520 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
524 ret
= wmi_delete_pstream_cmd(ar
->arWmi
, cmd
.trafficClass
, cmd
.tsid
);
540 ar6000_ioctl_get_qos_queue(struct net_device
*dev
, struct ifreq
*rq
)
542 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
543 struct ar6000_queuereq qreq
;
546 if (ar
->arWmiReady
== FALSE
) {
550 if( copy_from_user(&qreq
, rq
->ifr_data
,
551 sizeof(struct ar6000_queuereq
)))
554 qreq
.activeTsids
= wmi_get_mapped_qos_queue(ar
->arWmi
, qreq
.trafficClass
);
556 if (copy_to_user(rq
->ifr_data
, &qreq
,
557 sizeof(struct ar6000_queuereq
)))
565 #ifdef CONFIG_HOST_TCMD_SUPPORT
567 ar6000_ioctl_tcmd_get_rx_report(struct net_device
*dev
,
568 struct ifreq
*rq
, A_UINT8
*data
, A_UINT32 len
)
570 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
574 if (ar
->arWmiReady
== FALSE
) {
578 if (down_interruptible(&ar
->arSem
)) {
581 ar
->tcmdRxReport
= 0;
582 if (wmi_test_cmd(ar
->arWmi
, data
, len
) != A_OK
) {
587 wait_event_interruptible_timeout(arEvent
, ar
->tcmdRxReport
!= 0, wmitimeout
* HZ
);
589 if (signal_pending(current
)) {
593 buf
[0] = ar
->tcmdRxTotalPkt
;
594 buf
[1] = ar
->tcmdRxRssi
;
595 if (!ret
&& copy_to_user(rq
->ifr_data
, buf
, sizeof(buf
))) {
605 ar6000_tcmd_rx_report_event(void *devt
, A_UINT8
* results
, int len
)
607 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)devt
;
608 TCMD_CONT_RX
* rx_rep
= (TCMD_CONT_RX
*)results
;
610 ar
->tcmdRxTotalPkt
= rx_rep
->u
.report
.totalPkt
;
611 ar
->tcmdRxRssi
= rx_rep
->u
.report
.rssiInDBm
;
612 ar
->tcmdRxReport
= 1;
616 #endif /* CONFIG_HOST_TCMD_SUPPORT*/
619 ar6000_ioctl_set_error_report_bitmask(struct net_device
*dev
, struct ifreq
*rq
)
621 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
622 WMI_TARGET_ERROR_REPORT_BITMASK cmd
;
625 if (ar
->arWmiReady
== FALSE
) {
629 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
633 ret
= wmi_set_error_report_bitmask(ar
->arWmi
, cmd
.bitmask
);
635 return (ret
==0 ? ret
: -EINVAL
);
639 ar6000_clear_target_stats(struct net_device
*dev
)
641 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
642 TARGET_STATS
*pStats
= &ar
->arTargetStats
;
645 if (ar
->arWmiReady
== FALSE
) {
648 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
649 A_MEMZERO(pStats
, sizeof(TARGET_STATS
));
650 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
655 ar6000_ioctl_get_target_stats(struct net_device
*dev
, struct ifreq
*rq
)
657 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
658 TARGET_STATS_CMD cmd
;
659 TARGET_STATS
*pStats
= &ar
->arTargetStats
;
662 if (ar
->arWmiReady
== FALSE
) {
665 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
668 if (down_interruptible(&ar
->arSem
)) {
672 ar
->statsUpdatePending
= TRUE
;
674 if(wmi_get_stats_cmd(ar
->arWmi
) != A_OK
) {
679 wait_event_interruptible_timeout(arEvent
, ar
->statsUpdatePending
== FALSE
, wmitimeout
* HZ
);
681 if (signal_pending(current
)) {
685 if (!ret
&& copy_to_user(rq
->ifr_data
, pStats
, sizeof(*pStats
))) {
689 if (cmd
.clearStats
== 1) {
690 ret
= ar6000_clear_target_stats(dev
);
699 ar6000_ioctl_set_access_params(struct net_device
*dev
, struct ifreq
*rq
)
701 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
702 WMI_SET_ACCESS_PARAMS_CMD cmd
;
705 if (ar
->arWmiReady
== FALSE
) {
709 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
713 if (wmi_set_access_params_cmd(ar
->arWmi
, cmd
.txop
, cmd
.eCWmin
, cmd
.eCWmax
,
725 ar6000_ioctl_set_disconnect_timeout(struct net_device
*dev
, struct ifreq
*rq
)
727 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
728 WMI_DISC_TIMEOUT_CMD cmd
;
731 if (ar
->arWmiReady
== FALSE
) {
735 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
739 if (wmi_disctimeout_cmd(ar
->arWmi
, cmd
.disconnectTimeout
) == A_OK
)
750 ar6000_xioctl_set_voice_pkt_size(struct net_device
*dev
, char * userdata
)
752 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
753 WMI_SET_VOICE_PKT_SIZE_CMD cmd
;
756 if (ar
->arWmiReady
== FALSE
) {
760 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
764 if (wmi_set_voice_pkt_size_cmd(ar
->arWmi
, cmd
.voicePktSize
) == A_OK
)
776 ar6000_xioctl_set_max_sp_len(struct net_device
*dev
, char * userdata
)
778 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
779 WMI_SET_MAX_SP_LEN_CMD cmd
;
782 if (ar
->arWmiReady
== FALSE
) {
786 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
790 if (wmi_set_max_sp_len_cmd(ar
->arWmi
, cmd
.maxSPLen
) == A_OK
)
802 ar6000_xioctl_set_bt_status_cmd(struct net_device
*dev
, char * userdata
)
804 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
805 WMI_SET_BT_STATUS_CMD cmd
;
808 if (ar
->arWmiReady
== FALSE
) {
812 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
816 if (wmi_set_bt_status_cmd(ar
->arWmi
, cmd
.streamType
, cmd
.status
) == A_OK
)
827 ar6000_xioctl_set_bt_params_cmd(struct net_device
*dev
, char * userdata
)
829 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
830 WMI_SET_BT_PARAMS_CMD cmd
;
833 if (ar
->arWmiReady
== FALSE
) {
837 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
841 if (wmi_set_bt_params_cmd(ar
->arWmi
, &cmd
) == A_OK
)
851 #ifdef CONFIG_HOST_GPIO_SUPPORT
852 struct ar6000_gpio_intr_wait_cmd_s gpio_intr_results
;
853 /* gpio_reg_results and gpio_data_available are protected by arSem */
854 static struct ar6000_gpio_register_cmd_s gpio_reg_results
;
855 static A_BOOL gpio_data_available
; /* Requested GPIO data available */
856 static A_BOOL gpio_intr_available
; /* GPIO interrupt info available */
857 static A_BOOL gpio_ack_received
; /* GPIO ack was received */
859 /* Host-side initialization for General Purpose I/O support */
860 void ar6000_gpio_init(void)
862 gpio_intr_available
= FALSE
;
863 gpio_data_available
= FALSE
;
864 gpio_ack_received
= FALSE
;
868 * Called when a GPIO interrupt is received from the Target.
869 * intr_values shows which GPIO pins have interrupted.
870 * input_values shows a recent value of GPIO pins.
873 ar6000_gpio_intr_rx(A_UINT32 intr_mask
, A_UINT32 input_values
)
875 gpio_intr_results
.intr_mask
= intr_mask
;
876 gpio_intr_results
.input_values
= input_values
;
877 *((volatile A_BOOL
*)&gpio_intr_available
) = TRUE
;
882 * This is called when a response is received from the Target
883 * for a previous or ar6000_gpio_input_get or ar6000_gpio_register_get
887 ar6000_gpio_data_rx(A_UINT32 reg_id
, A_UINT32 value
)
889 gpio_reg_results
.gpioreg_id
= reg_id
;
890 gpio_reg_results
.value
= value
;
891 *((volatile A_BOOL
*)&gpio_data_available
) = TRUE
;
896 * This is called when an acknowledgement is received from the Target
897 * for a previous or ar6000_gpio_output_set or ar6000_gpio_register_set
901 ar6000_gpio_ack_rx(void)
903 gpio_ack_received
= TRUE
;
908 ar6000_gpio_output_set(struct net_device
*dev
,
911 A_UINT32 enable_mask
,
912 A_UINT32 disable_mask
)
914 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
916 gpio_ack_received
= FALSE
;
917 return wmi_gpio_output_set(ar
->arWmi
,
918 set_mask
, clear_mask
, enable_mask
, disable_mask
);
922 ar6000_gpio_input_get(struct net_device
*dev
)
924 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
926 *((volatile A_BOOL
*)&gpio_data_available
) = FALSE
;
927 return wmi_gpio_input_get(ar
->arWmi
);
931 ar6000_gpio_register_set(struct net_device
*dev
,
935 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
937 gpio_ack_received
= FALSE
;
938 return wmi_gpio_register_set(ar
->arWmi
, gpioreg_id
, value
);
942 ar6000_gpio_register_get(struct net_device
*dev
,
945 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
947 *((volatile A_BOOL
*)&gpio_data_available
) = FALSE
;
948 return wmi_gpio_register_get(ar
->arWmi
, gpioreg_id
);
952 ar6000_gpio_intr_ack(struct net_device
*dev
,
955 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
957 gpio_intr_available
= FALSE
;
958 return wmi_gpio_intr_ack(ar
->arWmi
, ack_mask
);
960 #endif /* CONFIG_HOST_GPIO_SUPPORT */
962 int ar6000_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
964 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
965 HIF_DEVICE
*hifDevice
= ar
->arHifDevice
;
966 int ret
, param
, param2
;
967 unsigned int address
= 0;
968 unsigned int length
= 0;
969 unsigned char *buffer
;
971 A_UINT32 connectCtrlFlags
;
974 static WMI_SCAN_PARAMS_CMD scParams
= {0, 0, 0, 0, 0,
975 WMI_SHORTSCANRATIO_DEFAULT
,
976 DEFAULT_SCAN_CTRL_FLAGS
,
978 WMI_SET_AKMP_PARAMS_CMD akmpParams
;
979 WMI_SET_PMKID_LIST_CMD pmkidInfo
;
981 if (cmd
== AR6000_IOCTL_EXTENDED
)
984 * This allows for many more wireless ioctls than would otherwise
985 * be available. Applications embed the actual ioctl command in
986 * the first word of the parameter block, and use the command
987 * AR6000_IOCTL_EXTENDED_CMD on the ioctl call.
989 get_user(cmd
, (int *)rq
->ifr_data
);
990 userdata
= (char *)(((unsigned int *)rq
->ifr_data
)+1);
994 userdata
= (char *)rq
->ifr_data
;
997 if ((ar
->arWlanState
== WLAN_DISABLED
) &&
998 ((cmd
!= AR6000_XIOCTRL_WMI_SET_WLAN_STATE
) &&
999 (cmd
!= AR6000_XIOCTL_DIAG_READ
) &&
1000 (cmd
!= AR6000_XIOCTL_DIAG_WRITE
)))
1008 #ifdef CONFIG_HOST_TCMD_SUPPORT
1009 case AR6000_XIOCTL_TCMD_CONT_TX
:
1013 if (ar
->tcmdPm
== TCMD_PM_SLEEP
) {
1014 A_PRINTF("Can NOT send tx tcmd when target is asleep! \n");
1018 if(copy_from_user(&txCmd
, userdata
, sizeof(TCMD_CONT_TX
)))
1020 wmi_test_cmd(ar
->arWmi
,(A_UINT8
*)&txCmd
, sizeof(TCMD_CONT_TX
));
1023 case AR6000_XIOCTL_TCMD_CONT_RX
:
1027 if (ar
->tcmdPm
== TCMD_PM_SLEEP
) {
1028 A_PRINTF("Can NOT send rx tcmd when target is asleep! \n");
1031 if(copy_from_user(&rxCmd
, userdata
, sizeof(TCMD_CONT_RX
)))
1035 case TCMD_CONT_RX_PROMIS
:
1036 case TCMD_CONT_RX_FILTER
:
1037 case TCMD_CONT_RX_SETMAC
:
1038 wmi_test_cmd(ar
->arWmi
,(A_UINT8
*)&rxCmd
,
1039 sizeof(TCMD_CONT_RX
));
1041 case TCMD_CONT_RX_REPORT
:
1042 ar6000_ioctl_tcmd_get_rx_report(dev
, rq
,
1043 (A_UINT8
*)&rxCmd
, sizeof(TCMD_CONT_RX
));
1046 A_PRINTF("Unknown Cont Rx mode: %d\n",rxCmd
.act
);
1051 case AR6000_XIOCTL_TCMD_PM
:
1055 if(copy_from_user(&pmCmd
, userdata
, sizeof(TCMD_PM
)))
1057 ar
->tcmdPm
= pmCmd
.mode
;
1058 wmi_test_cmd(ar
->arWmi
, (A_UINT8
*)&pmCmd
, sizeof(TCMD_PM
));
1061 #endif /* CONFIG_HOST_TCMD_SUPPORT */
1063 case AR6000_XIOCTL_BMI_DONE
:
1066 ret
= ar6000_init(dev
);
1070 ret
= BMIDone(hifDevice
);
1074 case AR6000_XIOCTL_BMI_READ_MEMORY
:
1075 get_user(address
, (unsigned int *)userdata
);
1076 get_user(length
, (unsigned int *)userdata
+ 1);
1077 AR_DEBUG_PRINTF("Read Memory (address: 0x%x, length: %d)\n",
1079 if ((buffer
= (unsigned char *)A_MALLOC(length
)) != NULL
) {
1080 A_MEMZERO(buffer
, length
);
1081 ret
= BMIReadMemory(hifDevice
, address
, buffer
, length
);
1082 if (copy_to_user(rq
->ifr_data
, buffer
, length
)) {
1091 case AR6000_XIOCTL_BMI_WRITE_MEMORY
:
1092 get_user(address
, (unsigned int *)userdata
);
1093 get_user(length
, (unsigned int *)userdata
+ 1);
1094 AR_DEBUG_PRINTF("Write Memory (address: 0x%x, length: %d)\n",
1096 if ((buffer
= (unsigned char *)A_MALLOC(length
)) != NULL
) {
1097 A_MEMZERO(buffer
, length
);
1098 if (copy_from_user(buffer
, &userdata
[sizeof(address
) +
1099 sizeof(length
)], length
))
1103 ret
= BMIWriteMemory(hifDevice
, address
, buffer
, length
);
1111 case AR6000_XIOCTL_BMI_TEST
:
1112 AR_DEBUG_PRINTF("No longer supported\n");
1116 case AR6000_XIOCTL_BMI_EXECUTE
:
1117 get_user(address
, (unsigned int *)userdata
);
1118 get_user(param
, (unsigned int *)userdata
+ 1);
1119 AR_DEBUG_PRINTF("Execute (address: 0x%x, param: %d)\n",
1121 ret
= BMIExecute(hifDevice
, address
, ¶m
);
1122 put_user(param
, (unsigned int *)rq
->ifr_data
); /* return value */
1125 case AR6000_XIOCTL_BMI_SET_APP_START
:
1126 get_user(address
, (unsigned int *)userdata
);
1127 AR_DEBUG_PRINTF("Set App Start (address: 0x%x)\n", address
);
1128 ret
= BMISetAppStart(hifDevice
, address
);
1131 case AR6000_XIOCTL_BMI_READ_SOC_REGISTER
:
1132 get_user(address
, (unsigned int *)userdata
);
1133 ret
= BMIReadSOCRegister(hifDevice
, address
, ¶m
);
1134 put_user(param
, (unsigned int *)rq
->ifr_data
); /* return value */
1137 case AR6000_XIOCTL_BMI_WRITE_SOC_REGISTER
:
1138 get_user(address
, (unsigned int *)userdata
);
1139 get_user(param
, (unsigned int *)userdata
+ 1);
1140 ret
= BMIWriteSOCRegister(hifDevice
, address
, param
);
1143 #ifdef HTC_RAW_INTERFACE
1144 case AR6000_XIOCTL_HTC_RAW_OPEN
:
1146 if (!arRawIfEnabled(ar
)) {
1147 /* make sure block size is set in case the target was reset since last
1148 * BMI phase (i.e. flashup downloads) */
1149 ret
= ar6000_SetHTCBlockSize(ar
);
1150 if (A_FAILED(ret
)) {
1153 /* Terminate the BMI phase */
1154 ret
= BMIDone(hifDevice
);
1156 ret
= ar6000_htc_raw_open(ar
);
1161 case AR6000_XIOCTL_HTC_RAW_CLOSE
:
1162 if (arRawIfEnabled(ar
)) {
1163 ret
= ar6000_htc_raw_close(ar
);
1164 arRawIfEnabled(ar
) = FALSE
;
1170 case AR6000_XIOCTL_HTC_RAW_READ
:
1171 if (arRawIfEnabled(ar
)) {
1172 unsigned int streamID
;
1173 get_user(streamID
, (unsigned int *)userdata
);
1174 get_user(length
, (unsigned int *)userdata
+ 1);
1175 buffer
= rq
->ifr_data
+ sizeof(length
);
1176 ret
= ar6000_htc_raw_read(ar
, (HTC_RAW_STREAM_ID
)streamID
,
1178 put_user(ret
, (unsigned int *)rq
->ifr_data
);
1184 case AR6000_XIOCTL_HTC_RAW_WRITE
:
1185 if (arRawIfEnabled(ar
)) {
1186 unsigned int streamID
;
1187 get_user(streamID
, (unsigned int *)userdata
);
1188 get_user(length
, (unsigned int *)userdata
+ 1);
1189 buffer
= userdata
+ sizeof(streamID
) + sizeof(length
);
1190 ret
= ar6000_htc_raw_write(ar
, (HTC_RAW_STREAM_ID
)streamID
,
1192 put_user(ret
, (unsigned int *)rq
->ifr_data
);
1197 #endif /* HTC_RAW_INTERFACE */
1199 case AR6000_IOCTL_WMI_GETREV
:
1201 if (copy_to_user(rq
->ifr_data
, &ar
->arVersion
,
1202 sizeof(ar
->arVersion
)))
1208 case AR6000_IOCTL_WMI_SETPWR
:
1210 WMI_POWER_MODE_CMD pwrModeCmd
;
1212 if (ar
->arWmiReady
== FALSE
) {
1214 } else if (copy_from_user(&pwrModeCmd
, userdata
,
1215 sizeof(pwrModeCmd
)))
1219 if (wmi_powermode_cmd(ar
->arWmi
, pwrModeCmd
.powerMode
)
1227 case AR6000_IOCTL_WMI_SET_IBSS_PM_CAPS
:
1229 WMI_IBSS_PM_CAPS_CMD ibssPmCaps
;
1231 if (ar
->arWmiReady
== FALSE
) {
1233 } else if (copy_from_user(&ibssPmCaps
, userdata
,
1234 sizeof(ibssPmCaps
)))
1238 if (wmi_ibsspmcaps_cmd(ar
->arWmi
, ibssPmCaps
.power_saving
, ibssPmCaps
.ttl
,
1239 ibssPmCaps
.atim_windows
, ibssPmCaps
.timeout_value
) != A_OK
)
1243 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1244 ar
->arIbssPsEnable
= ibssPmCaps
.power_saving
;
1245 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1249 case AR6000_IOCTL_WMI_SET_PMPARAMS
:
1251 WMI_POWER_PARAMS_CMD pmParams
;
1253 if (ar
->arWmiReady
== FALSE
) {
1255 } else if (copy_from_user(&pmParams
, userdata
,
1260 if (wmi_pmparams_cmd(ar
->arWmi
, pmParams
.idle_period
,
1261 pmParams
.pspoll_number
,
1262 pmParams
.dtim_policy
) != A_OK
)
1269 case AR6000_IOCTL_WMI_SETSCAN
:
1271 if (ar
->arWmiReady
== FALSE
) {
1273 } else if (copy_from_user(&scParams
, userdata
,
1278 if (CAN_SCAN_IN_CONNECT(scParams
.scanCtrlFlags
)) {
1279 ar
->arSkipScan
= FALSE
;
1281 ar
->arSkipScan
= TRUE
;
1284 if (wmi_scanparams_cmd(ar
->arWmi
, scParams
.fg_start_period
,
1285 scParams
.fg_end_period
,
1287 scParams
.minact_chdwell_time
,
1288 scParams
.maxact_chdwell_time
,
1289 scParams
.pas_chdwell_time
,
1290 scParams
.shortScanRatio
,
1291 scParams
.scanCtrlFlags
,
1292 scParams
.max_dfsch_act_time
) != A_OK
)
1299 case AR6000_IOCTL_WMI_SETLISTENINT
:
1301 WMI_LISTEN_INT_CMD listenCmd
;
1303 if (ar
->arWmiReady
== FALSE
) {
1305 } else if (copy_from_user(&listenCmd
, userdata
,
1310 if (wmi_listeninterval_cmd(ar
->arWmi
, listenCmd
.listenInterval
, listenCmd
.numBeacons
) != A_OK
) {
1313 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1314 ar
->arListenInterval
= param
;
1315 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1321 case AR6000_IOCTL_WMI_SET_BMISS_TIME
:
1323 WMI_BMISS_TIME_CMD bmissCmd
;
1325 if (ar
->arWmiReady
== FALSE
) {
1327 } else if (copy_from_user(&bmissCmd
, userdata
,
1332 if (wmi_bmisstime_cmd(ar
->arWmi
, bmissCmd
.bmissTime
, bmissCmd
.numBeacons
) != A_OK
) {
1338 case AR6000_IOCTL_WMI_SETBSSFILTER
:
1340 if (ar
->arWmiReady
== FALSE
) {
1344 get_user(param
, (unsigned char *)userdata
);
1345 get_user(param2
, (unsigned int *)(userdata
+ 1));
1346 printk("SETBSSFILTER: filter 0x%x, mask: 0x%x\n", param
, param2
);
1347 if (wmi_bssfilter_cmd(ar
->arWmi
, param
, param2
) != A_OK
) {
1353 case AR6000_IOCTL_WMI_SET_SNRTHRESHOLD
:
1355 ret
= ar6000_ioctl_set_snr_threshold(dev
, rq
);
1358 case AR6000_XIOCTL_WMI_SET_RSSITHRESHOLD
:
1360 ret
= ar6000_ioctl_set_rssi_threshold(dev
, rq
);
1363 case AR6000_XIOCTL_WMI_CLR_RSSISNR
:
1365 if (ar
->arWmiReady
== FALSE
) {
1368 ret
= wmi_clr_rssi_snr(ar
->arWmi
);
1371 case AR6000_XIOCTL_WMI_SET_LQTHRESHOLD
:
1373 ret
= ar6000_ioctl_set_lq_threshold(dev
, rq
);
1376 case AR6000_XIOCTL_WMI_SET_LPREAMBLE
:
1378 WMI_SET_LPREAMBLE_CMD setLpreambleCmd
;
1380 if (ar
->arWmiReady
== FALSE
) {
1382 } else if (copy_from_user(&setLpreambleCmd
, userdata
,
1383 sizeof(setLpreambleCmd
)))
1387 if (wmi_set_lpreamble_cmd(ar
->arWmi
, setLpreambleCmd
.status
)
1396 case AR6000_XIOCTL_WMI_SET_RTS
:
1398 WMI_SET_RTS_CMD rtsCmd
;
1400 if (ar
->arWmiReady
== FALSE
) {
1402 } else if (copy_from_user(&rtsCmd
, userdata
,
1407 if (wmi_set_rts_cmd(ar
->arWmi
, rtsCmd
.threshold
)
1416 case AR6000_XIOCTL_WMI_SET_WMM
:
1418 ret
= ar6000_ioctl_set_wmm(dev
, rq
);
1421 case AR6000_XIOCTL_WMI_SET_TXOP
:
1423 ret
= ar6000_ioctl_set_txop(dev
, rq
);
1426 case AR6000_XIOCTL_WMI_GET_RD
:
1428 ret
= ar6000_ioctl_get_rd(dev
, rq
);
1431 case AR6000_IOCTL_WMI_SET_CHANNELPARAMS
:
1433 ret
= ar6000_ioctl_set_channelParams(dev
, rq
);
1436 case AR6000_IOCTL_WMI_SET_PROBEDSSID
:
1438 ret
= ar6000_ioctl_set_probedSsid(dev
, rq
);
1441 case AR6000_IOCTL_WMI_SET_BADAP
:
1443 ret
= ar6000_ioctl_set_badAp(dev
, rq
);
1446 case AR6000_IOCTL_WMI_CREATE_QOS
:
1448 ret
= ar6000_ioctl_create_qos(dev
, rq
);
1451 case AR6000_IOCTL_WMI_DELETE_QOS
:
1453 ret
= ar6000_ioctl_delete_qos(dev
, rq
);
1456 case AR6000_IOCTL_WMI_GET_QOS_QUEUE
:
1458 ret
= ar6000_ioctl_get_qos_queue(dev
, rq
);
1461 case AR6000_IOCTL_WMI_GET_TARGET_STATS
:
1463 ret
= ar6000_ioctl_get_target_stats(dev
, rq
);
1466 case AR6000_IOCTL_WMI_SET_ERROR_REPORT_BITMASK
:
1468 ret
= ar6000_ioctl_set_error_report_bitmask(dev
, rq
);
1471 case AR6000_IOCTL_WMI_SET_ASSOC_INFO
:
1473 WMI_SET_ASSOC_INFO_CMD cmd
;
1474 A_UINT8 assocInfo
[WMI_MAX_ASSOC_INFO_LEN
];
1476 if (ar
->arWmiReady
== FALSE
) {
1479 get_user(cmd
.ieType
, userdata
);
1480 if (cmd
.ieType
>= WMI_MAX_ASSOC_INFO_TYPE
) {
1483 get_user(cmd
.bufferSize
, userdata
+ 1);
1484 if (cmd
.bufferSize
> WMI_MAX_ASSOC_INFO_LEN
) {
1488 if (copy_from_user(assocInfo
, userdata
+ 2,
1493 if (wmi_associnfo_cmd(ar
->arWmi
, cmd
.ieType
,
1504 case AR6000_IOCTL_WMI_SET_ACCESS_PARAMS
:
1506 ret
= ar6000_ioctl_set_access_params(dev
, rq
);
1509 case AR6000_IOCTL_WMI_SET_DISC_TIMEOUT
:
1511 ret
= ar6000_ioctl_set_disconnect_timeout(dev
, rq
);
1514 case AR6000_XIOCTL_FORCE_TARGET_RESET
:
1516 if (ar
->arHtcTarget
)
1518 // HTCForceReset(htcTarget);
1522 AR_DEBUG_PRINTF("ar6000_ioctl cannot attempt reset.\n");
1526 case AR6000_XIOCTL_TARGET_INFO
:
1527 case AR6000_XIOCTL_CHECK_TARGET_READY
: /* backwards compatibility */
1529 /* If we made it to here, then the Target exists and is ready. */
1531 if (cmd
== AR6000_XIOCTL_TARGET_INFO
) {
1532 if (copy_to_user((A_UINT32
*)rq
->ifr_data
, &ar
->arVersion
.target_ver
,
1533 sizeof(ar
->arVersion
.target_ver
)))
1537 if (copy_to_user(((A_UINT32
*)rq
->ifr_data
)+1, &ar
->arTargetType
,
1538 sizeof(ar
->arTargetType
)))
1545 case AR6000_XIOCTL_WMI_SET_HB_CHALLENGE_RESP_PARAMS
:
1547 WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD hbparam
;
1549 if (copy_from_user(&hbparam
, userdata
, sizeof(hbparam
)))
1553 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1554 /* Start a cyclic timer with the parameters provided. */
1555 if (hbparam
.frequency
) {
1556 ar
->arHBChallengeResp
.frequency
= hbparam
.frequency
;
1558 if (hbparam
.threshold
) {
1559 ar
->arHBChallengeResp
.missThres
= hbparam
.threshold
;
1562 /* Delete the pending timer and start a new one */
1563 if (timer_pending(&ar
->arHBChallengeResp
.timer
)) {
1564 A_UNTIMEOUT(&ar
->arHBChallengeResp
.timer
);
1566 A_TIMEOUT_MS(&ar
->arHBChallengeResp
.timer
, ar
->arHBChallengeResp
.frequency
* 1000, 0);
1567 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1571 case AR6000_XIOCTL_WMI_GET_HB_CHALLENGE_RESP
:
1575 if (copy_from_user(&cookie
, userdata
, sizeof(cookie
))) {
1579 /* Send the challenge on the control channel */
1580 if (wmi_get_challenge_resp_cmd(ar
->arWmi
, cookie
, APP_HB_CHALLENGE
) != A_OK
) {
1586 case AR6000_XIOCTL_USER_SETKEYS
:
1589 ar
->user_savedkeys_stat
= USER_SAVEDKEYS_STAT_RUN
;
1591 if (copy_from_user(&ar
->user_key_ctrl
, userdata
,
1592 sizeof(ar
->user_key_ctrl
)))
1597 A_PRINTF("ar6000 USER set key %x\n", ar
->user_key_ctrl
);
1600 #endif /* USER_KEYS */
1602 #ifdef CONFIG_HOST_GPIO_SUPPORT
1603 case AR6000_XIOCTL_GPIO_OUTPUT_SET
:
1605 struct ar6000_gpio_output_set_cmd_s gpio_output_set_cmd
;
1607 if (ar
->arWmiReady
== FALSE
) {
1610 if (down_interruptible(&ar
->arSem
)) {
1611 return -ERESTARTSYS
;
1614 if (copy_from_user(&gpio_output_set_cmd
, userdata
,
1615 sizeof(gpio_output_set_cmd
)))
1619 ret
= ar6000_gpio_output_set(dev
,
1620 gpio_output_set_cmd
.set_mask
,
1621 gpio_output_set_cmd
.clear_mask
,
1622 gpio_output_set_cmd
.enable_mask
,
1623 gpio_output_set_cmd
.disable_mask
);
1631 case AR6000_XIOCTL_GPIO_INPUT_GET
:
1633 if (ar
->arWmiReady
== FALSE
) {
1636 if (down_interruptible(&ar
->arSem
)) {
1637 return -ERESTARTSYS
;
1640 ret
= ar6000_gpio_input_get(dev
);
1646 /* Wait for Target to respond. */
1647 wait_event_interruptible(arEvent
, gpio_data_available
);
1648 if (signal_pending(current
)) {
1651 A_ASSERT(gpio_reg_results
.gpioreg_id
== GPIO_ID_NONE
);
1653 if (copy_to_user(userdata
, &gpio_reg_results
.value
,
1654 sizeof(gpio_reg_results
.value
)))
1662 case AR6000_XIOCTL_GPIO_REGISTER_SET
:
1664 struct ar6000_gpio_register_cmd_s gpio_register_cmd
;
1666 if (ar
->arWmiReady
== FALSE
) {
1669 if (down_interruptible(&ar
->arSem
)) {
1670 return -ERESTARTSYS
;
1673 if (copy_from_user(&gpio_register_cmd
, userdata
,
1674 sizeof(gpio_register_cmd
)))
1678 ret
= ar6000_gpio_register_set(dev
,
1679 gpio_register_cmd
.gpioreg_id
,
1680 gpio_register_cmd
.value
);
1685 /* Wait for acknowledgement from Target */
1686 wait_event_interruptible(arEvent
, gpio_ack_received
);
1687 if (signal_pending(current
)) {
1694 case AR6000_XIOCTL_GPIO_REGISTER_GET
:
1696 struct ar6000_gpio_register_cmd_s gpio_register_cmd
;
1698 if (ar
->arWmiReady
== FALSE
) {
1701 if (down_interruptible(&ar
->arSem
)) {
1702 return -ERESTARTSYS
;
1705 if (copy_from_user(&gpio_register_cmd
, userdata
,
1706 sizeof(gpio_register_cmd
)))
1710 ret
= ar6000_gpio_register_get(dev
, gpio_register_cmd
.gpioreg_id
);
1716 /* Wait for Target to respond. */
1717 wait_event_interruptible(arEvent
, gpio_data_available
);
1718 if (signal_pending(current
)) {
1721 A_ASSERT(gpio_register_cmd
.gpioreg_id
== gpio_reg_results
.gpioreg_id
);
1722 if (copy_to_user(userdata
, &gpio_reg_results
,
1723 sizeof(gpio_reg_results
)))
1732 case AR6000_XIOCTL_GPIO_INTR_ACK
:
1734 struct ar6000_gpio_intr_ack_cmd_s gpio_intr_ack_cmd
;
1736 if (ar
->arWmiReady
== FALSE
) {
1739 if (down_interruptible(&ar
->arSem
)) {
1740 return -ERESTARTSYS
;
1743 if (copy_from_user(&gpio_intr_ack_cmd
, userdata
,
1744 sizeof(gpio_intr_ack_cmd
)))
1748 ret
= ar6000_gpio_intr_ack(dev
, gpio_intr_ack_cmd
.ack_mask
);
1756 case AR6000_XIOCTL_GPIO_INTR_WAIT
:
1758 /* Wait for Target to report an interrupt. */
1761 wait_event_interruptible(arEvent
, gpio_intr_available
);
1765 if (signal_pending(current
)) {
1768 if (copy_to_user(userdata
, &gpio_intr_results
,
1769 sizeof(gpio_intr_results
)))
1776 #endif /* CONFIG_HOST_GPIO_SUPPORT */
1778 case AR6000_XIOCTL_DBGLOG_CFG_MODULE
:
1780 struct ar6000_dbglog_module_config_s config
;
1782 if (copy_from_user(&config
, userdata
, sizeof(config
))) {
1786 /* Send the challenge on the control channel */
1787 if (wmi_config_debug_module_cmd(ar
->arWmi
, config
.mmask
,
1788 config
.tsr
, config
.rep
,
1789 config
.size
, config
.valid
) != A_OK
)
1796 case AR6000_XIOCTL_DBGLOG_GET_DEBUG_LOGS
:
1798 /* Send the challenge on the control channel */
1799 if (ar6000_dbglog_get_debug_logs(ar
) != A_OK
)
1806 case AR6000_XIOCTL_SET_ADHOC_BSSID
:
1808 WMI_SET_ADHOC_BSSID_CMD adhocBssid
;
1810 if (ar
->arWmiReady
== FALSE
) {
1812 } else if (copy_from_user(&adhocBssid
, userdata
,
1813 sizeof(adhocBssid
)))
1816 } else if (A_MEMCMP(adhocBssid
.bssid
, bcast_mac
,
1817 AR6000_ETH_ADDR_LEN
) == 0)
1822 A_MEMCPY(ar
->arReqBssid
, adhocBssid
.bssid
, sizeof(ar
->arReqBssid
));
1827 case AR6000_XIOCTL_SET_OPT_MODE
:
1829 WMI_SET_OPT_MODE_CMD optModeCmd
;
1830 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
1832 if (ar
->arWmiReady
== FALSE
) {
1834 } else if (copy_from_user(&optModeCmd
, userdata
,
1835 sizeof(optModeCmd
)))
1838 } else if (ar
->arConnected
&& optModeCmd
.optMode
== SPECIAL_ON
) {
1841 } else if (wmi_set_opt_mode_cmd(ar
->arWmi
, optModeCmd
.optMode
)
1849 case AR6000_XIOCTL_OPT_SEND_FRAME
:
1851 WMI_OPT_TX_FRAME_CMD optTxFrmCmd
;
1852 A_UINT8 data
[MAX_OPT_DATA_LEN
];
1854 if (ar
->arWmiReady
== FALSE
) {
1856 } else if (copy_from_user(&optTxFrmCmd
, userdata
,
1857 sizeof(optTxFrmCmd
)))
1860 } else if (copy_from_user(data
,
1861 userdata
+sizeof(WMI_OPT_TX_FRAME_CMD
)-1,
1862 optTxFrmCmd
.optIEDataLen
))
1866 ret
= wmi_opt_tx_frame_cmd(ar
->arWmi
,
1867 optTxFrmCmd
.frmType
,
1868 optTxFrmCmd
.dstAddr
,
1870 optTxFrmCmd
.optIEDataLen
,
1876 case AR6000_XIOCTL_WMI_SETRETRYLIMITS
:
1878 WMI_SET_RETRY_LIMITS_CMD setRetryParams
;
1880 if (ar
->arWmiReady
== FALSE
) {
1882 } else if (copy_from_user(&setRetryParams
, userdata
,
1883 sizeof(setRetryParams
)))
1887 if (wmi_set_retry_limits_cmd(ar
->arWmi
, setRetryParams
.frameType
,
1888 setRetryParams
.trafficClass
,
1889 setRetryParams
.maxRetries
,
1890 setRetryParams
.enableNotify
) != A_OK
)
1894 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1895 ar
->arMaxRetries
= setRetryParams
.maxRetries
;
1896 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1901 case AR6000_XIOCTL_SET_ADHOC_BEACON_INTVAL
:
1903 WMI_BEACON_INT_CMD bIntvlCmd
;
1905 if (ar
->arWmiReady
== FALSE
) {
1907 } else if (copy_from_user(&bIntvlCmd
, userdata
,
1911 } else if (wmi_set_adhoc_bconIntvl_cmd(ar
->arWmi
, bIntvlCmd
.beaconInterval
)
1918 case IEEE80211_IOCTL_SETAUTHALG
:
1920 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
1921 struct ieee80211req_authalg req
;
1923 if (ar
->arWmiReady
== FALSE
) {
1925 } else if (copy_from_user(&req
, userdata
,
1926 sizeof(struct ieee80211req_authalg
)))
1929 } else if (req
.auth_alg
== AUTH_ALG_OPEN_SYSTEM
) {
1930 ar
->arDot11AuthMode
= OPEN_AUTH
;
1931 ar
->arPairwiseCrypto
= NONE_CRYPT
;
1932 ar
->arGroupCrypto
= NONE_CRYPT
;
1933 } else if (req
.auth_alg
== AUTH_ALG_LEAP
) {
1934 ar
->arDot11AuthMode
= LEAP_AUTH
;
1941 case AR6000_XIOCTL_SET_VOICE_PKT_SIZE
:
1942 ret
= ar6000_xioctl_set_voice_pkt_size(dev
, userdata
);
1945 case AR6000_XIOCTL_SET_MAX_SP
:
1946 ret
= ar6000_xioctl_set_max_sp_len(dev
, userdata
);
1949 case AR6000_XIOCTL_WMI_GET_ROAM_TBL
:
1950 ret
= ar6000_ioctl_get_roam_tbl(dev
, rq
);
1952 case AR6000_XIOCTL_WMI_SET_ROAM_CTRL
:
1953 ret
= ar6000_ioctl_set_roam_ctrl(dev
, userdata
);
1955 case AR6000_XIOCTRL_WMI_SET_POWERSAVE_TIMERS
:
1956 ret
= ar6000_ioctl_set_powersave_timers(dev
, userdata
);
1958 case AR6000_XIOCTRL_WMI_GET_POWER_MODE
:
1959 ret
= ar6000_ioctl_get_power_mode(dev
, rq
);
1961 case AR6000_XIOCTRL_WMI_SET_WLAN_STATE
:
1962 get_user(ar
->arWlanState
, (unsigned int *)userdata
);
1963 if (ar
->arWmiReady
== FALSE
) {
1968 if (ar
->arWlanState
== WLAN_ENABLED
) {
1969 /* Enable foreground scanning */
1970 if (wmi_scanparams_cmd(ar
->arWmi
, scParams
.fg_start_period
,
1971 scParams
.fg_end_period
,
1973 scParams
.minact_chdwell_time
,
1974 scParams
.maxact_chdwell_time
,
1975 scParams
.pas_chdwell_time
,
1976 scParams
.shortScanRatio
,
1977 scParams
.scanCtrlFlags
,
1978 scParams
.max_dfsch_act_time
) != A_OK
)
1982 if (ar
->arSsidLen
) {
1983 ar
->arConnectPending
= TRUE
;
1984 if (wmi_connect_cmd(ar
->arWmi
, ar
->arNetworkType
,
1985 ar
->arDot11AuthMode
, ar
->arAuthMode
,
1986 ar
->arPairwiseCrypto
,
1987 ar
->arPairwiseCryptoLen
,
1988 ar
->arGroupCrypto
, ar
->arGroupCryptoLen
,
1989 ar
->arSsidLen
, ar
->arSsid
,
1990 ar
->arReqBssid
, ar
->arChannelHint
,
1991 ar
->arConnectCtrlFlags
) != A_OK
)
1994 ar
->arConnectPending
= FALSE
;
1998 /* Disconnect from the AP and disable foreground scanning */
1999 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
2000 if (ar
->arConnected
== TRUE
|| ar
->arConnectPending
== TRUE
) {
2001 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
2002 wmi_disconnect_cmd(ar
->arWmi
);
2004 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
2007 if (wmi_scanparams_cmd(ar
->arWmi
, 0xFFFF, 0, 0, 0, 0, 0, 0, 0xFF, 0) != A_OK
)
2013 case AR6000_XIOCTL_WMI_GET_ROAM_DATA
:
2014 ret
= ar6000_ioctl_get_roam_data(dev
, rq
);
2016 case AR6000_XIOCTL_WMI_SET_BT_STATUS
:
2017 ret
= ar6000_xioctl_set_bt_status_cmd(dev
, userdata
);
2019 case AR6000_XIOCTL_WMI_SET_BT_PARAMS
:
2020 ret
= ar6000_xioctl_set_bt_params_cmd(dev
, userdata
);
2022 case AR6000_XIOCTL_WMI_STARTSCAN
:
2024 WMI_START_SCAN_CMD setStartScanCmd
;
2026 if (ar
->arWmiReady
== FALSE
) {
2028 } else if (copy_from_user(&setStartScanCmd
, userdata
,
2029 sizeof(setStartScanCmd
)))
2033 if (wmi_startscan_cmd(ar
->arWmi
, setStartScanCmd
.scanType
,
2034 setStartScanCmd
.forceFgScan
,
2035 setStartScanCmd
.isLegacy
,
2036 setStartScanCmd
.homeDwellTime
,
2037 setStartScanCmd
.forceScanInterval
) != A_OK
)
2044 case AR6000_XIOCTL_WMI_SETFIXRATES
:
2046 WMI_FIX_RATES_CMD setFixRatesCmd
;
2047 A_STATUS returnStatus
;
2049 if (ar
->arWmiReady
== FALSE
) {
2051 } else if (copy_from_user(&setFixRatesCmd
, userdata
,
2052 sizeof(setFixRatesCmd
)))
2056 returnStatus
= wmi_set_fixrates_cmd(ar
->arWmi
, setFixRatesCmd
.fixRateMask
);
2057 if (returnStatus
== A_EINVAL
)
2061 else if(returnStatus
!= A_OK
) {
2068 case AR6000_XIOCTL_WMI_GETFIXRATES
:
2070 WMI_FIX_RATES_CMD getFixRatesCmd
;
2071 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
2074 if (ar
->arWmiReady
== FALSE
) {
2078 if (down_interruptible(&ar
->arSem
)) {
2079 return -ERESTARTSYS
;
2081 /* Used copy_from_user/copy_to_user to access user space data */
2082 if (copy_from_user(&getFixRatesCmd
, userdata
, sizeof(getFixRatesCmd
))) {
2085 ar
->arRateMask
= 0xFFFF;
2087 if (wmi_get_ratemask_cmd(ar
->arWmi
) != A_OK
) {
2092 wait_event_interruptible_timeout(arEvent
, ar
->arRateMask
!= 0xFFFF, wmitimeout
* HZ
);
2094 if (signal_pending(current
)) {
2099 getFixRatesCmd
.fixRateMask
= ar
->arRateMask
;
2102 if(copy_to_user(userdata
, &getFixRatesCmd
, sizeof(getFixRatesCmd
))) {
2110 case AR6000_XIOCTL_WMI_SET_AUTHMODE
:
2112 WMI_SET_AUTH_MODE_CMD setAuthMode
;
2114 if (ar
->arWmiReady
== FALSE
) {
2116 } else if (copy_from_user(&setAuthMode
, userdata
,
2117 sizeof(setAuthMode
)))
2121 if (wmi_set_authmode_cmd(ar
->arWmi
, setAuthMode
.mode
) != A_OK
)
2128 case AR6000_XIOCTL_WMI_SET_REASSOCMODE
:
2130 WMI_SET_REASSOC_MODE_CMD setReassocMode
;
2132 if (ar
->arWmiReady
== FALSE
) {
2134 } else if (copy_from_user(&setReassocMode
, userdata
,
2135 sizeof(setReassocMode
)))
2139 if (wmi_set_reassocmode_cmd(ar
->arWmi
, setReassocMode
.mode
) != A_OK
)
2146 case AR6000_XIOCTL_DIAG_READ
:
2148 A_UINT32 addr
, data
;
2149 get_user(addr
, (unsigned int *)userdata
);
2150 if (ar6000_ReadRegDiag(ar
->arHifDevice
, &addr
, &data
) != A_OK
) {
2153 put_user(data
, (unsigned int *)userdata
+ 1);
2156 case AR6000_XIOCTL_DIAG_WRITE
:
2158 A_UINT32 addr
, data
;
2159 get_user(addr
, (unsigned int *)userdata
);
2160 get_user(data
, (unsigned int *)userdata
+ 1);
2161 if (ar6000_WriteRegDiag(ar
->arHifDevice
, &addr
, &data
) != A_OK
) {
2166 case AR6000_XIOCTL_WMI_SET_KEEPALIVE
:
2168 WMI_SET_KEEPALIVE_CMD setKeepAlive
;
2169 if (ar
->arWmiReady
== FALSE
) {
2171 } else if (copy_from_user(&setKeepAlive
, userdata
,
2172 sizeof(setKeepAlive
))){
2175 if (wmi_set_keepalive_cmd(ar
->arWmi
, setKeepAlive
.keepaliveInterval
) != A_OK
) {
2181 case AR6000_XIOCTL_WMI_GET_KEEPALIVE
:
2183 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
2184 WMI_GET_KEEPALIVE_CMD getKeepAlive
;
2186 if (ar
->arWmiReady
== FALSE
) {
2189 if (down_interruptible(&ar
->arSem
)) {
2190 return -ERESTARTSYS
;
2192 if (copy_from_user(&getKeepAlive
, userdata
,sizeof(getKeepAlive
))) {
2195 getKeepAlive
.keepaliveInterval
= wmi_get_keepalive_cmd(ar
->arWmi
);
2196 ar
->arKeepaliveConfigured
= 0xFF;
2197 if (wmi_get_keepalive_configured(ar
->arWmi
) != A_OK
){
2201 wait_event_interruptible_timeout(arEvent
, ar
->arKeepaliveConfigured
!= 0xFF, wmitimeout
* HZ
);
2202 if (signal_pending(current
)) {
2207 getKeepAlive
.configured
= ar
->arKeepaliveConfigured
;
2209 if (copy_to_user(userdata
, &getKeepAlive
, sizeof(getKeepAlive
))) {
2216 case AR6000_XIOCTL_WMI_SET_APPIE
:
2218 WMI_SET_APPIE_CMD appIEcmd
;
2219 A_UINT8 appIeInfo
[IEEE80211_APPIE_FRAME_MAX_LEN
];
2220 A_UINT32 fType
,ieLen
;
2222 if (ar
->arWmiReady
== FALSE
) {
2225 get_user(fType
, (A_UINT32
*)userdata
);
2226 appIEcmd
.mgmtFrmType
= fType
;
2227 if (appIEcmd
.mgmtFrmType
>= IEEE80211_APPIE_NUM_OF_FRAME
) {
2230 get_user(ieLen
, (A_UINT32
*)(userdata
+ 4));
2231 appIEcmd
.ieLen
= ieLen
;
2232 if (appIEcmd
.ieLen
> IEEE80211_APPIE_FRAME_MAX_LEN
) {
2236 if (copy_from_user(appIeInfo
, userdata
+ 8, appIEcmd
.ieLen
)) {
2239 if (wmi_set_appie_cmd(ar
->arWmi
, appIEcmd
.mgmtFrmType
,
2240 appIEcmd
.ieLen
, appIeInfo
) != A_OK
)
2248 case AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER
:
2250 WMI_BSS_FILTER_CMD cmd
;
2251 A_UINT32 filterType
;
2253 if (copy_from_user(&filterType
, userdata
, sizeof(A_UINT32
)))
2257 if (filterType
& (IEEE80211_FILTER_TYPE_BEACON
|
2258 IEEE80211_FILTER_TYPE_PROBE_RESP
))
2260 cmd
.bssFilter
= ALL_BSS_FILTER
;
2262 cmd
.bssFilter
= NONE_BSS_FILTER
;
2264 if (wmi_bssfilter_cmd(ar
->arWmi
, cmd
.bssFilter
, 0) != A_OK
) {
2268 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
2269 ar
->arMgmtFilter
= filterType
;
2270 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
2273 case AR6000_XIOCTL_WMI_SET_WSC_STATUS
:
2275 A_UINT32 wsc_status
;
2277 if (copy_from_user(&wsc_status
, userdata
, sizeof(A_UINT32
)))
2281 if (wmi_set_wsc_status_cmd(ar
->arWmi
, wsc_status
) != A_OK
) {
2286 case AR6000_XIOCTL_BMI_ROMPATCH_INSTALL
:
2291 A_UINT32 do_activate
;
2292 A_UINT32 rompatch_id
;
2294 get_user(ROM_addr
, (A_UINT32
*)userdata
);
2295 get_user(RAM_addr
, (A_UINT32
*)userdata
+ 1);
2296 get_user(nbytes
, (A_UINT32
*)userdata
+ 2);
2297 get_user(do_activate
, (A_UINT32
*)userdata
+ 3);
2298 AR_DEBUG_PRINTF("Install rompatch from ROM: 0x%x to RAM: 0x%x length: %d\n",
2299 ROM_addr
, RAM_addr
, nbytes
);
2300 ret
= BMIrompatchInstall(hifDevice
, ROM_addr
, RAM_addr
,
2301 nbytes
, do_activate
, &rompatch_id
);
2303 put_user(rompatch_id
, (unsigned int *)rq
->ifr_data
); /* return value */
2308 case AR6000_XIOCTL_BMI_ROMPATCH_UNINSTALL
:
2310 A_UINT32 rompatch_id
;
2312 get_user(rompatch_id
, (A_UINT32
*)userdata
);
2313 AR_DEBUG_PRINTF("UNinstall rompatch_id %d\n", rompatch_id
);
2314 ret
= BMIrompatchUninstall(hifDevice
, rompatch_id
);
2318 case AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE
:
2319 case AR6000_XIOCTL_BMI_ROMPATCH_DEACTIVATE
:
2321 A_UINT32 rompatch_count
;
2323 get_user(rompatch_count
, (A_UINT32
*)userdata
);
2324 AR_DEBUG_PRINTF("Change rompatch activation count=%d\n", rompatch_count
);
2325 length
= sizeof(A_UINT32
) * rompatch_count
;
2326 if ((buffer
= (unsigned char *)A_MALLOC(length
)) != NULL
) {
2327 A_MEMZERO(buffer
, length
);
2328 if (copy_from_user(buffer
, &userdata
[sizeof(rompatch_count
)], length
))
2332 if (cmd
== AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE
) {
2333 ret
= BMIrompatchActivate(hifDevice
, rompatch_count
, (A_UINT32
*)buffer
);
2335 ret
= BMIrompatchDeactivate(hifDevice
, rompatch_count
, (A_UINT32
*)buffer
);
2346 case AR6000_XIOCTL_WMI_SET_HOST_SLEEP_MODE
:
2348 WMI_SET_HOST_SLEEP_MODE_CMD setHostSleepMode
;
2350 if (ar
->arWmiReady
== FALSE
) {
2352 } else if (copy_from_user(&setHostSleepMode
, userdata
,
2353 sizeof(setHostSleepMode
)))
2357 if (wmi_set_host_sleep_mode_cmd(ar
->arWmi
,
2358 &setHostSleepMode
) != A_OK
)
2365 case AR6000_XIOCTL_WMI_SET_WOW_MODE
:
2367 WMI_SET_WOW_MODE_CMD setWowMode
;
2369 if (ar
->arWmiReady
== FALSE
) {
2371 } else if (copy_from_user(&setWowMode
, userdata
,
2372 sizeof(setWowMode
)))
2376 if (wmi_set_wow_mode_cmd(ar
->arWmi
,
2377 &setWowMode
) != A_OK
)
2384 case AR6000_XIOCTL_WMI_GET_WOW_LIST
:
2386 WMI_GET_WOW_LIST_CMD getWowList
;
2388 if (ar
->arWmiReady
== FALSE
) {
2390 } else if (copy_from_user(&getWowList
, userdata
,
2391 sizeof(getWowList
)))
2395 if (wmi_get_wow_list_cmd(ar
->arWmi
,
2396 &getWowList
) != A_OK
)
2403 case AR6000_XIOCTL_WMI_ADD_WOW_PATTERN
:
2405 #define WOW_PATTERN_SIZE 64
2406 #define WOW_MASK_SIZE 64
2408 WMI_ADD_WOW_PATTERN_CMD cmd
;
2409 A_UINT8 mask_data
[WOW_PATTERN_SIZE
]={0};
2410 A_UINT8 pattern_data
[WOW_PATTERN_SIZE
]={0};
2412 if (ar
->arWmiReady
== FALSE
) {
2416 if(copy_from_user(&cmd
, userdata
,
2417 sizeof(WMI_ADD_WOW_PATTERN_CMD
)))
2419 if (copy_from_user(pattern_data
,
2425 if (copy_from_user(mask_data
,
2426 (userdata
+ 3 + cmd
.filter_size
),
2431 if (wmi_add_wow_pattern_cmd(ar
->arWmi
,
2432 &cmd
, pattern_data
, mask_data
, cmd
.filter_size
) != A_OK
){
2437 #undef WOW_PATTERN_SIZE
2438 #undef WOW_MASK_SIZE
2441 case AR6000_XIOCTL_WMI_DEL_WOW_PATTERN
:
2443 WMI_DEL_WOW_PATTERN_CMD delWowPattern
;
2445 if (ar
->arWmiReady
== FALSE
) {
2447 } else if (copy_from_user(&delWowPattern
, userdata
,
2448 sizeof(delWowPattern
)))
2452 if (wmi_del_wow_pattern_cmd(ar
->arWmi
,
2453 &delWowPattern
) != A_OK
)
2460 case AR6000_XIOCTL_DUMP_HTC_CREDIT_STATE
:
2461 if (ar
->arHtcTarget
!= NULL
) {
2462 HTCDumpCreditStates(ar
->arHtcTarget
);
2465 case AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE
:
2466 if (ar
->arHtcTarget
!= NULL
) {
2467 struct ar6000_traffic_activity_change data
;
2469 if (copy_from_user(&data
, userdata
, sizeof(data
)))
2473 /* note, this is used for testing (mbox ping testing), indicate activity
2474 * change using the stream ID as the traffic class */
2475 ar6000_indicate_tx_activity(ar
,
2476 (A_UINT8
)data
.StreamID
,
2477 data
.Active
? TRUE
: FALSE
);
2480 case AR6000_XIOCTL_WMI_SET_CONNECT_CTRL_FLAGS
:
2481 if (ar
->arWmiReady
== FALSE
) {
2483 } else if (copy_from_user(&connectCtrlFlags
, userdata
,
2484 sizeof(connectCtrlFlags
)))
2488 ar
->arConnectCtrlFlags
= connectCtrlFlags
;
2491 case AR6000_XIOCTL_WMI_SET_AKMP_PARAMS
:
2492 if (ar
->arWmiReady
== FALSE
) {
2494 } else if (copy_from_user(&akmpParams
, userdata
,
2495 sizeof(WMI_SET_AKMP_PARAMS_CMD
)))
2499 if (wmi_set_akmp_params_cmd(ar
->arWmi
, &akmpParams
) != A_OK
) {
2504 case AR6000_XIOCTL_WMI_SET_PMKID_LIST
:
2505 if (ar
->arWmiReady
== FALSE
) {
2508 if (copy_from_user(&pmkidInfo
.numPMKID
, userdata
,
2509 sizeof(pmkidInfo
.numPMKID
)))
2514 if (copy_from_user(&pmkidInfo
.pmkidList
,
2515 userdata
+ sizeof(pmkidInfo
.numPMKID
),
2516 pmkidInfo
.numPMKID
* sizeof(WMI_PMKID
)))
2521 if (wmi_set_pmkid_list_cmd(ar
->arWmi
, &pmkidInfo
) != A_OK
) {
2526 case AR6000_XIOCTL_WMI_GET_PMKID_LIST
:
2527 if (ar
->arWmiReady
== FALSE
) {
2530 if (wmi_get_pmkid_list_cmd(ar
->arWmi
) != A_OK
) {