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
;
31 ar6000_ioctl_get_roam_tbl(struct net_device
*dev
, struct ifreq
*rq
)
33 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
35 if (ar
->arWmiReady
== FALSE
) {
39 if(wmi_get_roam_tbl_cmd(ar
->arWmi
) != A_OK
) {
47 ar6000_ioctl_get_roam_data(struct net_device
*dev
, struct ifreq
*rq
)
49 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
51 if (ar
->arWmiReady
== FALSE
) {
56 /* currently assume only roam times are required */
57 if(wmi_get_roam_data_cmd(ar
->arWmi
, ROAM_DATA_TIME
) != A_OK
) {
66 ar6000_ioctl_set_roam_ctrl(struct net_device
*dev
, char *userdata
)
68 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
69 WMI_SET_ROAM_CTRL_CMD cmd
;
70 A_UINT8 size
= sizeof(cmd
);
72 if (ar
->arWmiReady
== FALSE
) {
77 if (copy_from_user(&cmd
, userdata
, size
)) {
81 if (cmd
.roamCtrlType
== WMI_SET_HOST_BIAS
) {
82 if (cmd
.info
.bssBiasInfo
.numBss
> 1) {
83 size
+= (cmd
.info
.bssBiasInfo
.numBss
- 1) * sizeof(WMI_BSS_BIAS
);
87 if (copy_from_user(&cmd
, userdata
, size
)) {
91 if(wmi_set_roam_ctrl_cmd(ar
->arWmi
, &cmd
, size
) != A_OK
) {
99 ar6000_ioctl_set_powersave_timers(struct net_device
*dev
, char *userdata
)
101 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
102 WMI_POWERSAVE_TIMERS_POLICY_CMD cmd
;
103 A_UINT8 size
= sizeof(cmd
);
105 if (ar
->arWmiReady
== FALSE
) {
109 if (copy_from_user(&cmd
, userdata
, size
)) {
113 if (copy_from_user(&cmd
, userdata
, size
)) {
117 if(wmi_set_powersave_timers_cmd(ar
->arWmi
, &cmd
, size
) != A_OK
) {
125 ar6000_ioctl_set_wmm(struct net_device
*dev
, struct ifreq
*rq
)
127 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
131 if ((dev
->flags
& IFF_UP
) != IFF_UP
) {
134 if (ar
->arWmiReady
== FALSE
) {
138 if (copy_from_user(&cmd
, (char *)((unsigned int*)rq
->ifr_data
+ 1),
144 if (cmd
.status
== WMI_WMM_ENABLED
) {
145 ar
->arWmmEnabled
= TRUE
;
147 ar
->arWmmEnabled
= FALSE
;
150 ret
= wmi_set_wmm_cmd(ar
->arWmi
, cmd
.status
);
166 ar6000_ioctl_set_txop(struct net_device
*dev
, struct ifreq
*rq
)
168 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
169 WMI_SET_WMM_TXOP_CMD cmd
;
172 if ((dev
->flags
& IFF_UP
) != IFF_UP
) {
175 if (ar
->arWmiReady
== FALSE
) {
179 if (copy_from_user(&cmd
, (char *)((unsigned int*)rq
->ifr_data
+ 1),
185 ret
= wmi_set_wmm_txop(ar
->arWmi
, cmd
.txopEnable
);
201 ar6000_ioctl_get_rd(struct net_device
*dev
, struct ifreq
*rq
)
203 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
206 if ((dev
->flags
& IFF_UP
) != IFF_UP
|| ar
->arWmiReady
== FALSE
) {
210 if(copy_to_user((char *)((unsigned int*)rq
->ifr_data
+ 1),
211 &ar
->arRegCode
, sizeof(ar
->arRegCode
)))
218 /* Get power mode command */
220 ar6000_ioctl_get_power_mode(struct net_device
*dev
, struct ifreq
*rq
)
222 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
223 WMI_POWER_MODE_CMD power_mode
;
226 if (ar
->arWmiReady
== FALSE
) {
230 power_mode
.powerMode
= wmi_get_power_mode_cmd(ar
->arWmi
);
231 if (copy_to_user(rq
->ifr_data
, &power_mode
, sizeof(WMI_POWER_MODE_CMD
))) {
240 ar6000_ioctl_set_channelParams(struct net_device
*dev
, struct ifreq
*rq
)
242 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
243 WMI_CHANNEL_PARAMS_CMD cmd
, *cmdp
;
246 if (ar
->arWmiReady
== FALSE
) {
251 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
255 if (cmd
.numChannels
> 1) {
256 cmdp
= A_MALLOC(130);
257 if (copy_from_user(cmdp
, rq
->ifr_data
,
259 ((cmd
.numChannels
- 1) * sizeof(A_UINT16
))))
268 if ((ar
->arPhyCapability
== WMI_11G_CAPABILITY
) &&
269 ((cmdp
->phyMode
== WMI_11A_MODE
) || (cmdp
->phyMode
== WMI_11AG_MODE
)))
275 (wmi_set_channelParams_cmd(ar
->arWmi
, cmdp
->scanParam
, cmdp
->phyMode
,
276 cmdp
->numChannels
, cmdp
->channelList
)
282 if (cmd
.numChannels
> 1) {
290 ar6000_ioctl_set_snr_threshold(struct net_device
*dev
, struct ifreq
*rq
)
293 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
294 WMI_SNR_THRESHOLD_PARAMS_CMD cmd
;
297 if (ar
->arWmiReady
== FALSE
) {
301 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
305 if( wmi_set_snr_threshold_params(ar
->arWmi
, &cmd
) != A_OK
) {
313 ar6000_ioctl_set_rssi_threshold(struct net_device
*dev
, struct ifreq
*rq
)
315 #define SWAP_THOLD(thold1, thold2) do { \
316 USER_RSSI_THOLD tmpThold; \
317 tmpThold.tag = thold1.tag; \
318 tmpThold.rssi = thold1.rssi; \
319 thold1.tag = thold2.tag; \
320 thold1.rssi = thold2.rssi; \
321 thold2.tag = tmpThold.tag; \
322 thold2.rssi = tmpThold.rssi; \
325 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
326 WMI_RSSI_THRESHOLD_PARAMS_CMD cmd
;
327 USER_RSSI_PARAMS rssiParams
;
332 if (ar
->arWmiReady
== FALSE
) {
336 if (copy_from_user((char *)&rssiParams
, (char *)((unsigned int *)rq
->ifr_data
+ 1), sizeof(USER_RSSI_PARAMS
))) {
339 cmd
.weight
= rssiParams
.weight
;
340 cmd
.pollTime
= rssiParams
.pollTime
;
342 A_MEMCPY(rssi_map
, &rssiParams
.tholds
, sizeof(rssi_map
));
344 * only 6 elements, so use bubble sorting, in ascending order
346 for (i
= 5; i
> 0; i
--) {
347 for (j
= 0; j
< i
; j
++) { /* above tholds */
348 if (rssi_map
[j
+1].rssi
< rssi_map
[j
].rssi
) {
349 SWAP_THOLD(rssi_map
[j
+1], rssi_map
[j
]);
350 } else if (rssi_map
[j
+1].rssi
== rssi_map
[j
].rssi
) {
355 for (i
= 11; i
> 6; i
--) {
356 for (j
= 6; j
< i
; j
++) { /* below tholds */
357 if (rssi_map
[j
+1].rssi
< rssi_map
[j
].rssi
) {
358 SWAP_THOLD(rssi_map
[j
+1], rssi_map
[j
]);
359 } else if (rssi_map
[j
+1].rssi
== rssi_map
[j
].rssi
) {
366 for (i
= 0; i
< 12; i
++) {
367 AR_DEBUG2_PRINTF("thold[%d].tag: %d, thold[%d].rssi: %d \n",
368 i
, rssi_map
[i
].tag
, i
, rssi_map
[i
].rssi
);
371 cmd
.thresholdAbove1_Val
= rssi_map
[0].rssi
;
372 cmd
.thresholdAbove2_Val
= rssi_map
[1].rssi
;
373 cmd
.thresholdAbove3_Val
= rssi_map
[2].rssi
;
374 cmd
.thresholdAbove4_Val
= rssi_map
[3].rssi
;
375 cmd
.thresholdAbove5_Val
= rssi_map
[4].rssi
;
376 cmd
.thresholdAbove6_Val
= rssi_map
[5].rssi
;
377 cmd
.thresholdBelow1_Val
= rssi_map
[6].rssi
;
378 cmd
.thresholdBelow2_Val
= rssi_map
[7].rssi
;
379 cmd
.thresholdBelow3_Val
= rssi_map
[8].rssi
;
380 cmd
.thresholdBelow4_Val
= rssi_map
[9].rssi
;
381 cmd
.thresholdBelow5_Val
= rssi_map
[10].rssi
;
382 cmd
.thresholdBelow6_Val
= rssi_map
[11].rssi
;
384 if( wmi_set_rssi_threshold_params(ar
->arWmi
, &cmd
) != A_OK
) {
392 ar6000_ioctl_set_lq_threshold(struct net_device
*dev
, struct ifreq
*rq
)
395 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
396 WMI_LQ_THRESHOLD_PARAMS_CMD cmd
;
399 if (ar
->arWmiReady
== FALSE
) {
403 if (copy_from_user(&cmd
, (char *)((unsigned int *)rq
->ifr_data
+ 1), sizeof(cmd
))) {
407 if( wmi_set_lq_threshold_params(ar
->arWmi
, &cmd
) != A_OK
) {
416 ar6000_ioctl_set_probedSsid(struct net_device
*dev
, struct ifreq
*rq
)
418 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
419 WMI_PROBED_SSID_CMD cmd
;
422 if (ar
->arWmiReady
== FALSE
) {
426 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
430 if (wmi_probedSsid_cmd(ar
->arWmi
, cmd
.entryIndex
, cmd
.flag
, cmd
.ssidLength
,
440 ar6000_ioctl_set_badAp(struct net_device
*dev
, struct ifreq
*rq
)
442 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
443 WMI_ADD_BAD_AP_CMD cmd
;
446 if (ar
->arWmiReady
== FALSE
) {
451 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
455 if (cmd
.badApIndex
> WMI_MAX_BAD_AP_INDEX
) {
459 if (A_MEMCMP(cmd
.bssid
, null_mac
, AR6000_ETH_ADDR_LEN
) == 0) {
461 * This is a delete badAP.
463 if (wmi_deleteBadAp_cmd(ar
->arWmi
, cmd
.badApIndex
) != A_OK
) {
467 if (wmi_addBadAp_cmd(ar
->arWmi
, cmd
.badApIndex
, cmd
.bssid
) != A_OK
) {
476 ar6000_ioctl_create_qos(struct net_device
*dev
, struct ifreq
*rq
)
478 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
479 WMI_CREATE_PSTREAM_CMD cmd
;
482 if (ar
->arWmiReady
== FALSE
) {
487 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
491 ret
= wmi_verify_tspec_params(&cmd
, tspecCompliance
);
493 ret
= wmi_create_pstream_cmd(ar
->arWmi
, &cmd
);
509 ar6000_ioctl_delete_qos(struct net_device
*dev
, struct ifreq
*rq
)
511 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
512 WMI_DELETE_PSTREAM_CMD cmd
;
515 if (ar
->arWmiReady
== FALSE
) {
519 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
523 ret
= wmi_delete_pstream_cmd(ar
->arWmi
, cmd
.trafficClass
, cmd
.tsid
);
539 ar6000_ioctl_get_qos_queue(struct net_device
*dev
, struct ifreq
*rq
)
541 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
542 struct ar6000_queuereq qreq
;
545 if (ar
->arWmiReady
== FALSE
) {
549 if( copy_from_user(&qreq
, rq
->ifr_data
,
550 sizeof(struct ar6000_queuereq
)))
553 qreq
.activeTsids
= wmi_get_mapped_qos_queue(ar
->arWmi
, qreq
.trafficClass
);
555 if (copy_to_user(rq
->ifr_data
, &qreq
,
556 sizeof(struct ar6000_queuereq
)))
564 #ifdef CONFIG_HOST_TCMD_SUPPORT
566 ar6000_ioctl_tcmd_get_rx_report(struct net_device
*dev
,
567 struct ifreq
*rq
, A_UINT8
*data
, A_UINT32 len
)
569 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
573 if (ar
->arWmiReady
== FALSE
) {
577 if (down_interruptible(&ar
->arSem
)) {
580 ar
->tcmdRxReport
= 0;
581 if (wmi_test_cmd(ar
->arWmi
, data
, len
) != A_OK
) {
586 wait_event_interruptible_timeout(arEvent
, ar
->tcmdRxReport
!= 0, wmitimeout
* HZ
);
588 if (signal_pending(current
)) {
592 buf
[0] = ar
->tcmdRxTotalPkt
;
593 buf
[1] = ar
->tcmdRxRssi
;
594 if (!ret
&& copy_to_user(rq
->ifr_data
, buf
, sizeof(buf
))) {
604 ar6000_tcmd_rx_report_event(void *devt
, A_UINT8
* results
, int len
)
606 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)devt
;
607 TCMD_CONT_RX
* rx_rep
= (TCMD_CONT_RX
*)results
;
609 ar
->tcmdRxTotalPkt
= rx_rep
->u
.report
.totalPkt
;
610 ar
->tcmdRxRssi
= rx_rep
->u
.report
.rssiInDBm
;
611 ar
->tcmdRxReport
= 1;
615 #endif /* CONFIG_HOST_TCMD_SUPPORT*/
618 ar6000_ioctl_set_error_report_bitmask(struct net_device
*dev
, struct ifreq
*rq
)
620 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
621 WMI_TARGET_ERROR_REPORT_BITMASK cmd
;
624 if (ar
->arWmiReady
== FALSE
) {
628 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
632 ret
= wmi_set_error_report_bitmask(ar
->arWmi
, cmd
.bitmask
);
634 return (ret
==0 ? ret
: -EINVAL
);
638 ar6000_clear_target_stats(struct net_device
*dev
)
640 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
641 TARGET_STATS
*pStats
= &ar
->arTargetStats
;
644 if (ar
->arWmiReady
== FALSE
) {
647 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
648 A_MEMZERO(pStats
, sizeof(TARGET_STATS
));
649 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
654 ar6000_ioctl_get_target_stats(struct net_device
*dev
, struct ifreq
*rq
)
656 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
657 TARGET_STATS_CMD cmd
;
658 TARGET_STATS
*pStats
= &ar
->arTargetStats
;
661 if (ar
->arWmiReady
== FALSE
) {
664 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
667 if (down_interruptible(&ar
->arSem
)) {
671 ar
->statsUpdatePending
= TRUE
;
673 if(wmi_get_stats_cmd(ar
->arWmi
) != A_OK
) {
678 wait_event_interruptible_timeout(arEvent
, ar
->statsUpdatePending
== FALSE
, wmitimeout
* HZ
);
680 if (signal_pending(current
)) {
684 if (!ret
&& copy_to_user(rq
->ifr_data
, pStats
, sizeof(*pStats
))) {
688 if (cmd
.clearStats
== 1) {
689 ret
= ar6000_clear_target_stats(dev
);
698 ar6000_ioctl_set_access_params(struct net_device
*dev
, struct ifreq
*rq
)
700 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
701 WMI_SET_ACCESS_PARAMS_CMD cmd
;
704 if (ar
->arWmiReady
== FALSE
) {
708 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
712 if (wmi_set_access_params_cmd(ar
->arWmi
, cmd
.txop
, cmd
.eCWmin
, cmd
.eCWmax
,
724 ar6000_ioctl_set_disconnect_timeout(struct net_device
*dev
, struct ifreq
*rq
)
726 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
727 WMI_DISC_TIMEOUT_CMD cmd
;
730 if (ar
->arWmiReady
== FALSE
) {
734 if (copy_from_user(&cmd
, rq
->ifr_data
, sizeof(cmd
))) {
738 if (wmi_disctimeout_cmd(ar
->arWmi
, cmd
.disconnectTimeout
) == A_OK
)
749 ar6000_xioctl_set_voice_pkt_size(struct net_device
*dev
, char * userdata
)
751 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
752 WMI_SET_VOICE_PKT_SIZE_CMD cmd
;
755 if (ar
->arWmiReady
== FALSE
) {
759 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
763 if (wmi_set_voice_pkt_size_cmd(ar
->arWmi
, cmd
.voicePktSize
) == A_OK
)
775 ar6000_xioctl_set_max_sp_len(struct net_device
*dev
, char * userdata
)
777 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
778 WMI_SET_MAX_SP_LEN_CMD cmd
;
781 if (ar
->arWmiReady
== FALSE
) {
785 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
789 if (wmi_set_max_sp_len_cmd(ar
->arWmi
, cmd
.maxSPLen
) == A_OK
)
801 ar6000_xioctl_set_bt_status_cmd(struct net_device
*dev
, char * userdata
)
803 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
804 WMI_SET_BT_STATUS_CMD cmd
;
807 if (ar
->arWmiReady
== FALSE
) {
811 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
815 if (wmi_set_bt_status_cmd(ar
->arWmi
, cmd
.streamType
, cmd
.status
) == A_OK
)
826 ar6000_xioctl_set_bt_params_cmd(struct net_device
*dev
, char * userdata
)
828 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
829 WMI_SET_BT_PARAMS_CMD cmd
;
832 if (ar
->arWmiReady
== FALSE
) {
836 if (copy_from_user(&cmd
, userdata
, sizeof(cmd
))) {
840 if (wmi_set_bt_params_cmd(ar
->arWmi
, &cmd
) == A_OK
)
850 #ifdef CONFIG_HOST_GPIO_SUPPORT
851 struct ar6000_gpio_intr_wait_cmd_s gpio_intr_results
;
852 /* gpio_reg_results and gpio_data_available are protected by arSem */
853 static struct ar6000_gpio_register_cmd_s gpio_reg_results
;
854 static A_BOOL gpio_data_available
; /* Requested GPIO data available */
855 static A_BOOL gpio_intr_available
; /* GPIO interrupt info available */
856 static A_BOOL gpio_ack_received
; /* GPIO ack was received */
858 /* Host-side initialization for General Purpose I/O support */
859 void ar6000_gpio_init(void)
861 gpio_intr_available
= FALSE
;
862 gpio_data_available
= FALSE
;
863 gpio_ack_received
= FALSE
;
867 * Called when a GPIO interrupt is received from the Target.
868 * intr_values shows which GPIO pins have interrupted.
869 * input_values shows a recent value of GPIO pins.
872 ar6000_gpio_intr_rx(A_UINT32 intr_mask
, A_UINT32 input_values
)
874 gpio_intr_results
.intr_mask
= intr_mask
;
875 gpio_intr_results
.input_values
= input_values
;
876 *((volatile A_BOOL
*)&gpio_intr_available
) = TRUE
;
881 * This is called when a response is received from the Target
882 * for a previous or ar6000_gpio_input_get or ar6000_gpio_register_get
886 ar6000_gpio_data_rx(A_UINT32 reg_id
, A_UINT32 value
)
888 gpio_reg_results
.gpioreg_id
= reg_id
;
889 gpio_reg_results
.value
= value
;
890 *((volatile A_BOOL
*)&gpio_data_available
) = TRUE
;
895 * This is called when an acknowledgement is received from the Target
896 * for a previous or ar6000_gpio_output_set or ar6000_gpio_register_set
900 ar6000_gpio_ack_rx(void)
902 gpio_ack_received
= TRUE
;
907 ar6000_gpio_output_set(struct net_device
*dev
,
910 A_UINT32 enable_mask
,
911 A_UINT32 disable_mask
)
913 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
915 gpio_ack_received
= FALSE
;
916 return wmi_gpio_output_set(ar
->arWmi
,
917 set_mask
, clear_mask
, enable_mask
, disable_mask
);
921 ar6000_gpio_input_get(struct net_device
*dev
)
923 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
925 *((volatile A_BOOL
*)&gpio_data_available
) = FALSE
;
926 return wmi_gpio_input_get(ar
->arWmi
);
930 ar6000_gpio_register_set(struct net_device
*dev
,
934 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
936 gpio_ack_received
= FALSE
;
937 return wmi_gpio_register_set(ar
->arWmi
, gpioreg_id
, value
);
941 ar6000_gpio_register_get(struct net_device
*dev
,
944 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
946 *((volatile A_BOOL
*)&gpio_data_available
) = FALSE
;
947 return wmi_gpio_register_get(ar
->arWmi
, gpioreg_id
);
951 ar6000_gpio_intr_ack(struct net_device
*dev
,
954 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
956 gpio_intr_available
= FALSE
;
957 return wmi_gpio_intr_ack(ar
->arWmi
, ack_mask
);
959 #endif /* CONFIG_HOST_GPIO_SUPPORT */
961 int ar6000_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
963 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
964 HIF_DEVICE
*hifDevice
= ar
->arHifDevice
;
965 int ret
, param
, param2
;
966 unsigned int address
= 0;
967 unsigned int length
= 0;
968 unsigned char *buffer
;
970 A_UINT32 connectCtrlFlags
;
973 static WMI_SCAN_PARAMS_CMD scParams
= {0, 0, 0, 0, 0,
974 WMI_SHORTSCANRATIO_DEFAULT
,
975 DEFAULT_SCAN_CTRL_FLAGS
,
977 WMI_SET_AKMP_PARAMS_CMD akmpParams
;
978 WMI_SET_PMKID_LIST_CMD pmkidInfo
;
980 if (cmd
== AR6000_IOCTL_EXTENDED
)
983 * This allows for many more wireless ioctls than would otherwise
984 * be available. Applications embed the actual ioctl command in
985 * the first word of the parameter block, and use the command
986 * AR6000_IOCTL_EXTENDED_CMD on the ioctl call.
988 get_user(cmd
, (int *)rq
->ifr_data
);
989 userdata
= (char *)(((unsigned int *)rq
->ifr_data
)+1);
993 userdata
= (char *)rq
->ifr_data
;
996 if ((ar
->arWlanState
== WLAN_DISABLED
) &&
997 ((cmd
!= AR6000_XIOCTRL_WMI_SET_WLAN_STATE
) &&
998 (cmd
!= AR6000_XIOCTL_DIAG_READ
) &&
999 (cmd
!= AR6000_XIOCTL_DIAG_WRITE
)))
1007 #ifdef CONFIG_HOST_TCMD_SUPPORT
1008 case AR6000_XIOCTL_TCMD_CONT_TX
:
1012 if (ar
->tcmdPm
== TCMD_PM_SLEEP
) {
1013 A_PRINTF("Can NOT send tx tcmd when target is asleep! \n");
1017 if(copy_from_user(&txCmd
, userdata
, sizeof(TCMD_CONT_TX
)))
1019 wmi_test_cmd(ar
->arWmi
,(A_UINT8
*)&txCmd
, sizeof(TCMD_CONT_TX
));
1022 case AR6000_XIOCTL_TCMD_CONT_RX
:
1026 if (ar
->tcmdPm
== TCMD_PM_SLEEP
) {
1027 A_PRINTF("Can NOT send rx tcmd when target is asleep! \n");
1030 if(copy_from_user(&rxCmd
, userdata
, sizeof(TCMD_CONT_RX
)))
1034 case TCMD_CONT_RX_PROMIS
:
1035 case TCMD_CONT_RX_FILTER
:
1036 case TCMD_CONT_RX_SETMAC
:
1037 wmi_test_cmd(ar
->arWmi
,(A_UINT8
*)&rxCmd
,
1038 sizeof(TCMD_CONT_RX
));
1040 case TCMD_CONT_RX_REPORT
:
1041 ar6000_ioctl_tcmd_get_rx_report(dev
, rq
,
1042 (A_UINT8
*)&rxCmd
, sizeof(TCMD_CONT_RX
));
1045 A_PRINTF("Unknown Cont Rx mode: %d\n",rxCmd
.act
);
1050 case AR6000_XIOCTL_TCMD_PM
:
1054 if(copy_from_user(&pmCmd
, userdata
, sizeof(TCMD_PM
)))
1056 ar
->tcmdPm
= pmCmd
.mode
;
1057 wmi_test_cmd(ar
->arWmi
, (A_UINT8
*)&pmCmd
, sizeof(TCMD_PM
));
1060 #endif /* CONFIG_HOST_TCMD_SUPPORT */
1062 case AR6000_XIOCTL_BMI_DONE
:
1063 ret
= BMIDone(hifDevice
);
1066 case AR6000_XIOCTL_BMI_READ_MEMORY
:
1067 get_user(address
, (unsigned int *)userdata
);
1068 get_user(length
, (unsigned int *)userdata
+ 1);
1069 AR_DEBUG_PRINTF("Read Memory (address: 0x%x, length: %d)\n",
1071 if ((buffer
= (unsigned char *)A_MALLOC(length
)) != NULL
) {
1072 A_MEMZERO(buffer
, length
);
1073 ret
= BMIReadMemory(hifDevice
, address
, buffer
, length
);
1074 if (copy_to_user(rq
->ifr_data
, buffer
, length
)) {
1083 case AR6000_XIOCTL_BMI_WRITE_MEMORY
:
1084 get_user(address
, (unsigned int *)userdata
);
1085 get_user(length
, (unsigned int *)userdata
+ 1);
1086 AR_DEBUG_PRINTF("Write Memory (address: 0x%x, length: %d)\n",
1088 if ((buffer
= (unsigned char *)A_MALLOC(length
)) != NULL
) {
1089 A_MEMZERO(buffer
, length
);
1090 if (copy_from_user(buffer
, &userdata
[sizeof(address
) +
1091 sizeof(length
)], length
))
1095 ret
= BMIWriteMemory(hifDevice
, address
, buffer
, length
);
1103 case AR6000_XIOCTL_BMI_TEST
:
1104 AR_DEBUG_PRINTF("No longer supported\n");
1108 case AR6000_XIOCTL_BMI_EXECUTE
:
1109 get_user(address
, (unsigned int *)userdata
);
1110 get_user(param
, (unsigned int *)userdata
+ 1);
1111 AR_DEBUG_PRINTF("Execute (address: 0x%x, param: %d)\n",
1113 ret
= BMIExecute(hifDevice
, address
, ¶m
);
1114 put_user(param
, (unsigned int *)rq
->ifr_data
); /* return value */
1117 case AR6000_XIOCTL_BMI_SET_APP_START
:
1118 get_user(address
, (unsigned int *)userdata
);
1119 AR_DEBUG_PRINTF("Set App Start (address: 0x%x)\n", address
);
1120 ret
= BMISetAppStart(hifDevice
, address
);
1123 case AR6000_XIOCTL_BMI_READ_SOC_REGISTER
:
1124 get_user(address
, (unsigned int *)userdata
);
1125 ret
= BMIReadSOCRegister(hifDevice
, address
, ¶m
);
1126 put_user(param
, (unsigned int *)rq
->ifr_data
); /* return value */
1129 case AR6000_XIOCTL_BMI_WRITE_SOC_REGISTER
:
1130 get_user(address
, (unsigned int *)userdata
);
1131 get_user(param
, (unsigned int *)userdata
+ 1);
1132 ret
= BMIWriteSOCRegister(hifDevice
, address
, param
);
1135 #ifdef HTC_RAW_INTERFACE
1136 case AR6000_XIOCTL_HTC_RAW_OPEN
:
1138 if (!arRawIfEnabled(ar
)) {
1139 /* make sure block size is set in case the target was reset since last
1140 * BMI phase (i.e. flashup downloads) */
1141 ret
= ar6000_SetHTCBlockSize(ar
);
1142 if (A_FAILED(ret
)) {
1145 /* Terminate the BMI phase */
1146 ret
= BMIDone(hifDevice
);
1148 ret
= ar6000_htc_raw_open(ar
);
1153 case AR6000_XIOCTL_HTC_RAW_CLOSE
:
1154 if (arRawIfEnabled(ar
)) {
1155 ret
= ar6000_htc_raw_close(ar
);
1156 arRawIfEnabled(ar
) = FALSE
;
1162 case AR6000_XIOCTL_HTC_RAW_READ
:
1163 if (arRawIfEnabled(ar
)) {
1164 unsigned int streamID
;
1165 get_user(streamID
, (unsigned int *)userdata
);
1166 get_user(length
, (unsigned int *)userdata
+ 1);
1167 buffer
= rq
->ifr_data
+ sizeof(length
);
1168 ret
= ar6000_htc_raw_read(ar
, (HTC_RAW_STREAM_ID
)streamID
,
1170 put_user(ret
, (unsigned int *)rq
->ifr_data
);
1176 case AR6000_XIOCTL_HTC_RAW_WRITE
:
1177 if (arRawIfEnabled(ar
)) {
1178 unsigned int streamID
;
1179 get_user(streamID
, (unsigned int *)userdata
);
1180 get_user(length
, (unsigned int *)userdata
+ 1);
1181 buffer
= userdata
+ sizeof(streamID
) + sizeof(length
);
1182 ret
= ar6000_htc_raw_write(ar
, (HTC_RAW_STREAM_ID
)streamID
,
1184 put_user(ret
, (unsigned int *)rq
->ifr_data
);
1189 #endif /* HTC_RAW_INTERFACE */
1191 case AR6000_IOCTL_WMI_GETREV
:
1193 if (copy_to_user(rq
->ifr_data
, &ar
->arVersion
,
1194 sizeof(ar
->arVersion
)))
1200 case AR6000_IOCTL_WMI_SETPWR
:
1202 WMI_POWER_MODE_CMD pwrModeCmd
;
1204 if (ar
->arWmiReady
== FALSE
) {
1206 } else if (copy_from_user(&pwrModeCmd
, userdata
,
1207 sizeof(pwrModeCmd
)))
1211 if (wmi_powermode_cmd(ar
->arWmi
, pwrModeCmd
.powerMode
)
1219 case AR6000_IOCTL_WMI_SET_IBSS_PM_CAPS
:
1221 WMI_IBSS_PM_CAPS_CMD ibssPmCaps
;
1223 if (ar
->arWmiReady
== FALSE
) {
1225 } else if (copy_from_user(&ibssPmCaps
, userdata
,
1226 sizeof(ibssPmCaps
)))
1230 if (wmi_ibsspmcaps_cmd(ar
->arWmi
, ibssPmCaps
.power_saving
, ibssPmCaps
.ttl
,
1231 ibssPmCaps
.atim_windows
, ibssPmCaps
.timeout_value
) != A_OK
)
1235 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1236 ar
->arIbssPsEnable
= ibssPmCaps
.power_saving
;
1237 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1241 case AR6000_IOCTL_WMI_SET_PMPARAMS
:
1243 WMI_POWER_PARAMS_CMD pmParams
;
1245 if (ar
->arWmiReady
== FALSE
) {
1247 } else if (copy_from_user(&pmParams
, userdata
,
1252 if (wmi_pmparams_cmd(ar
->arWmi
, pmParams
.idle_period
,
1253 pmParams
.pspoll_number
,
1254 pmParams
.dtim_policy
) != A_OK
)
1261 case AR6000_IOCTL_WMI_SETSCAN
:
1263 if (ar
->arWmiReady
== FALSE
) {
1265 } else if (copy_from_user(&scParams
, userdata
,
1270 if (CAN_SCAN_IN_CONNECT(scParams
.scanCtrlFlags
)) {
1271 ar
->arSkipScan
= FALSE
;
1273 ar
->arSkipScan
= TRUE
;
1276 if (wmi_scanparams_cmd(ar
->arWmi
, scParams
.fg_start_period
,
1277 scParams
.fg_end_period
,
1279 scParams
.minact_chdwell_time
,
1280 scParams
.maxact_chdwell_time
,
1281 scParams
.pas_chdwell_time
,
1282 scParams
.shortScanRatio
,
1283 scParams
.scanCtrlFlags
,
1284 scParams
.max_dfsch_act_time
) != A_OK
)
1291 case AR6000_IOCTL_WMI_SETLISTENINT
:
1293 WMI_LISTEN_INT_CMD listenCmd
;
1295 if (ar
->arWmiReady
== FALSE
) {
1297 } else if (copy_from_user(&listenCmd
, userdata
,
1302 if (wmi_listeninterval_cmd(ar
->arWmi
, listenCmd
.listenInterval
, listenCmd
.numBeacons
) != A_OK
) {
1305 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1306 ar
->arListenInterval
= param
;
1307 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1313 case AR6000_IOCTL_WMI_SET_BMISS_TIME
:
1315 WMI_BMISS_TIME_CMD bmissCmd
;
1317 if (ar
->arWmiReady
== FALSE
) {
1319 } else if (copy_from_user(&bmissCmd
, userdata
,
1324 if (wmi_bmisstime_cmd(ar
->arWmi
, bmissCmd
.bmissTime
, bmissCmd
.numBeacons
) != A_OK
) {
1330 case AR6000_IOCTL_WMI_SETBSSFILTER
:
1332 if (ar
->arWmiReady
== FALSE
) {
1336 get_user(param
, (unsigned char *)userdata
);
1337 get_user(param2
, (unsigned int *)(userdata
+ 1));
1338 printk("SETBSSFILTER: filter 0x%x, mask: 0x%x\n", param
, param2
);
1339 if (wmi_bssfilter_cmd(ar
->arWmi
, param
, param2
) != A_OK
) {
1345 case AR6000_IOCTL_WMI_SET_SNRTHRESHOLD
:
1347 ret
= ar6000_ioctl_set_snr_threshold(dev
, rq
);
1350 case AR6000_XIOCTL_WMI_SET_RSSITHRESHOLD
:
1352 ret
= ar6000_ioctl_set_rssi_threshold(dev
, rq
);
1355 case AR6000_XIOCTL_WMI_CLR_RSSISNR
:
1357 if (ar
->arWmiReady
== FALSE
) {
1360 ret
= wmi_clr_rssi_snr(ar
->arWmi
);
1363 case AR6000_XIOCTL_WMI_SET_LQTHRESHOLD
:
1365 ret
= ar6000_ioctl_set_lq_threshold(dev
, rq
);
1368 case AR6000_XIOCTL_WMI_SET_LPREAMBLE
:
1370 WMI_SET_LPREAMBLE_CMD setLpreambleCmd
;
1372 if (ar
->arWmiReady
== FALSE
) {
1374 } else if (copy_from_user(&setLpreambleCmd
, userdata
,
1375 sizeof(setLpreambleCmd
)))
1379 if (wmi_set_lpreamble_cmd(ar
->arWmi
, setLpreambleCmd
.status
)
1388 case AR6000_XIOCTL_WMI_SET_RTS
:
1390 WMI_SET_RTS_CMD rtsCmd
;
1392 if (ar
->arWmiReady
== FALSE
) {
1394 } else if (copy_from_user(&rtsCmd
, userdata
,
1399 if (wmi_set_rts_cmd(ar
->arWmi
, rtsCmd
.threshold
)
1408 case AR6000_XIOCTL_WMI_SET_WMM
:
1410 ret
= ar6000_ioctl_set_wmm(dev
, rq
);
1413 case AR6000_XIOCTL_WMI_SET_TXOP
:
1415 ret
= ar6000_ioctl_set_txop(dev
, rq
);
1418 case AR6000_XIOCTL_WMI_GET_RD
:
1420 ret
= ar6000_ioctl_get_rd(dev
, rq
);
1423 case AR6000_IOCTL_WMI_SET_CHANNELPARAMS
:
1425 ret
= ar6000_ioctl_set_channelParams(dev
, rq
);
1428 case AR6000_IOCTL_WMI_SET_PROBEDSSID
:
1430 ret
= ar6000_ioctl_set_probedSsid(dev
, rq
);
1433 case AR6000_IOCTL_WMI_SET_BADAP
:
1435 ret
= ar6000_ioctl_set_badAp(dev
, rq
);
1438 case AR6000_IOCTL_WMI_CREATE_QOS
:
1440 ret
= ar6000_ioctl_create_qos(dev
, rq
);
1443 case AR6000_IOCTL_WMI_DELETE_QOS
:
1445 ret
= ar6000_ioctl_delete_qos(dev
, rq
);
1448 case AR6000_IOCTL_WMI_GET_QOS_QUEUE
:
1450 ret
= ar6000_ioctl_get_qos_queue(dev
, rq
);
1453 case AR6000_IOCTL_WMI_GET_TARGET_STATS
:
1455 ret
= ar6000_ioctl_get_target_stats(dev
, rq
);
1458 case AR6000_IOCTL_WMI_SET_ERROR_REPORT_BITMASK
:
1460 ret
= ar6000_ioctl_set_error_report_bitmask(dev
, rq
);
1463 case AR6000_IOCTL_WMI_SET_ASSOC_INFO
:
1465 WMI_SET_ASSOC_INFO_CMD cmd
;
1466 A_UINT8 assocInfo
[WMI_MAX_ASSOC_INFO_LEN
];
1468 if (ar
->arWmiReady
== FALSE
) {
1471 get_user(cmd
.ieType
, userdata
);
1472 if (cmd
.ieType
>= WMI_MAX_ASSOC_INFO_TYPE
) {
1475 get_user(cmd
.bufferSize
, userdata
+ 1);
1476 if (cmd
.bufferSize
> WMI_MAX_ASSOC_INFO_LEN
) {
1480 if (copy_from_user(assocInfo
, userdata
+ 2,
1485 if (wmi_associnfo_cmd(ar
->arWmi
, cmd
.ieType
,
1496 case AR6000_IOCTL_WMI_SET_ACCESS_PARAMS
:
1498 ret
= ar6000_ioctl_set_access_params(dev
, rq
);
1501 case AR6000_IOCTL_WMI_SET_DISC_TIMEOUT
:
1503 ret
= ar6000_ioctl_set_disconnect_timeout(dev
, rq
);
1506 case AR6000_XIOCTL_FORCE_TARGET_RESET
:
1508 if (ar
->arHtcTarget
)
1510 // HTCForceReset(htcTarget);
1514 AR_DEBUG_PRINTF("ar6000_ioctl cannot attempt reset.\n");
1518 case AR6000_XIOCTL_TARGET_INFO
:
1519 case AR6000_XIOCTL_CHECK_TARGET_READY
: /* backwards compatibility */
1521 /* If we made it to here, then the Target exists and is ready. */
1523 if (cmd
== AR6000_XIOCTL_TARGET_INFO
) {
1524 if (copy_to_user((A_UINT32
*)rq
->ifr_data
, &ar
->arVersion
.target_ver
,
1525 sizeof(ar
->arVersion
.target_ver
)))
1529 if (copy_to_user(((A_UINT32
*)rq
->ifr_data
)+1, &ar
->arTargetType
,
1530 sizeof(ar
->arTargetType
)))
1537 case AR6000_XIOCTL_WMI_SET_HB_CHALLENGE_RESP_PARAMS
:
1539 WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD hbparam
;
1541 if (copy_from_user(&hbparam
, userdata
, sizeof(hbparam
)))
1545 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1546 /* Start a cyclic timer with the parameters provided. */
1547 if (hbparam
.frequency
) {
1548 ar
->arHBChallengeResp
.frequency
= hbparam
.frequency
;
1550 if (hbparam
.threshold
) {
1551 ar
->arHBChallengeResp
.missThres
= hbparam
.threshold
;
1554 /* Delete the pending timer and start a new one */
1555 if (timer_pending(&ar
->arHBChallengeResp
.timer
)) {
1556 A_UNTIMEOUT(&ar
->arHBChallengeResp
.timer
);
1558 A_TIMEOUT_MS(&ar
->arHBChallengeResp
.timer
, ar
->arHBChallengeResp
.frequency
* 1000, 0);
1559 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1563 case AR6000_XIOCTL_WMI_GET_HB_CHALLENGE_RESP
:
1567 if (copy_from_user(&cookie
, userdata
, sizeof(cookie
))) {
1571 /* Send the challenge on the control channel */
1572 if (wmi_get_challenge_resp_cmd(ar
->arWmi
, cookie
, APP_HB_CHALLENGE
) != A_OK
) {
1578 case AR6000_XIOCTL_USER_SETKEYS
:
1581 ar
->user_savedkeys_stat
= USER_SAVEDKEYS_STAT_RUN
;
1583 if (copy_from_user(&ar
->user_key_ctrl
, userdata
,
1584 sizeof(ar
->user_key_ctrl
)))
1589 A_PRINTF("ar6000 USER set key %x\n", ar
->user_key_ctrl
);
1592 #endif /* USER_KEYS */
1594 #ifdef CONFIG_HOST_GPIO_SUPPORT
1595 case AR6000_XIOCTL_GPIO_OUTPUT_SET
:
1597 struct ar6000_gpio_output_set_cmd_s gpio_output_set_cmd
;
1599 if (ar
->arWmiReady
== FALSE
) {
1602 if (down_interruptible(&ar
->arSem
)) {
1603 return -ERESTARTSYS
;
1606 if (copy_from_user(&gpio_output_set_cmd
, userdata
,
1607 sizeof(gpio_output_set_cmd
)))
1611 ret
= ar6000_gpio_output_set(dev
,
1612 gpio_output_set_cmd
.set_mask
,
1613 gpio_output_set_cmd
.clear_mask
,
1614 gpio_output_set_cmd
.enable_mask
,
1615 gpio_output_set_cmd
.disable_mask
);
1623 case AR6000_XIOCTL_GPIO_INPUT_GET
:
1625 if (ar
->arWmiReady
== FALSE
) {
1628 if (down_interruptible(&ar
->arSem
)) {
1629 return -ERESTARTSYS
;
1632 ret
= ar6000_gpio_input_get(dev
);
1638 /* Wait for Target to respond. */
1639 wait_event_interruptible(arEvent
, gpio_data_available
);
1640 if (signal_pending(current
)) {
1643 A_ASSERT(gpio_reg_results
.gpioreg_id
== GPIO_ID_NONE
);
1645 if (copy_to_user(userdata
, &gpio_reg_results
.value
,
1646 sizeof(gpio_reg_results
.value
)))
1654 case AR6000_XIOCTL_GPIO_REGISTER_SET
:
1656 struct ar6000_gpio_register_cmd_s gpio_register_cmd
;
1658 if (ar
->arWmiReady
== FALSE
) {
1661 if (down_interruptible(&ar
->arSem
)) {
1662 return -ERESTARTSYS
;
1665 if (copy_from_user(&gpio_register_cmd
, userdata
,
1666 sizeof(gpio_register_cmd
)))
1670 ret
= ar6000_gpio_register_set(dev
,
1671 gpio_register_cmd
.gpioreg_id
,
1672 gpio_register_cmd
.value
);
1677 /* Wait for acknowledgement from Target */
1678 wait_event_interruptible(arEvent
, gpio_ack_received
);
1679 if (signal_pending(current
)) {
1686 case AR6000_XIOCTL_GPIO_REGISTER_GET
:
1688 struct ar6000_gpio_register_cmd_s gpio_register_cmd
;
1690 if (ar
->arWmiReady
== FALSE
) {
1693 if (down_interruptible(&ar
->arSem
)) {
1694 return -ERESTARTSYS
;
1697 if (copy_from_user(&gpio_register_cmd
, userdata
,
1698 sizeof(gpio_register_cmd
)))
1702 ret
= ar6000_gpio_register_get(dev
, gpio_register_cmd
.gpioreg_id
);
1708 /* Wait for Target to respond. */
1709 wait_event_interruptible(arEvent
, gpio_data_available
);
1710 if (signal_pending(current
)) {
1713 A_ASSERT(gpio_register_cmd
.gpioreg_id
== gpio_reg_results
.gpioreg_id
);
1714 if (copy_to_user(userdata
, &gpio_reg_results
,
1715 sizeof(gpio_reg_results
)))
1724 case AR6000_XIOCTL_GPIO_INTR_ACK
:
1726 struct ar6000_gpio_intr_ack_cmd_s gpio_intr_ack_cmd
;
1728 if (ar
->arWmiReady
== FALSE
) {
1731 if (down_interruptible(&ar
->arSem
)) {
1732 return -ERESTARTSYS
;
1735 if (copy_from_user(&gpio_intr_ack_cmd
, userdata
,
1736 sizeof(gpio_intr_ack_cmd
)))
1740 ret
= ar6000_gpio_intr_ack(dev
, gpio_intr_ack_cmd
.ack_mask
);
1748 case AR6000_XIOCTL_GPIO_INTR_WAIT
:
1750 /* Wait for Target to report an interrupt. */
1753 wait_event_interruptible(arEvent
, gpio_intr_available
);
1757 if (signal_pending(current
)) {
1760 if (copy_to_user(userdata
, &gpio_intr_results
,
1761 sizeof(gpio_intr_results
)))
1768 #endif /* CONFIG_HOST_GPIO_SUPPORT */
1770 case AR6000_XIOCTL_DBGLOG_CFG_MODULE
:
1772 struct ar6000_dbglog_module_config_s config
;
1774 if (copy_from_user(&config
, userdata
, sizeof(config
))) {
1778 /* Send the challenge on the control channel */
1779 if (wmi_config_debug_module_cmd(ar
->arWmi
, config
.mmask
,
1780 config
.tsr
, config
.rep
,
1781 config
.size
, config
.valid
) != A_OK
)
1788 case AR6000_XIOCTL_DBGLOG_GET_DEBUG_LOGS
:
1790 /* Send the challenge on the control channel */
1791 if (ar6000_dbglog_get_debug_logs(ar
) != A_OK
)
1798 case AR6000_XIOCTL_SET_ADHOC_BSSID
:
1800 WMI_SET_ADHOC_BSSID_CMD adhocBssid
;
1802 if (ar
->arWmiReady
== FALSE
) {
1804 } else if (copy_from_user(&adhocBssid
, userdata
,
1805 sizeof(adhocBssid
)))
1808 } else if (A_MEMCMP(adhocBssid
.bssid
, bcast_mac
,
1809 AR6000_ETH_ADDR_LEN
) == 0)
1814 A_MEMCPY(ar
->arReqBssid
, adhocBssid
.bssid
, sizeof(ar
->arReqBssid
));
1819 case AR6000_XIOCTL_SET_OPT_MODE
:
1821 WMI_SET_OPT_MODE_CMD optModeCmd
;
1822 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
1824 if (ar
->arWmiReady
== FALSE
) {
1826 } else if (copy_from_user(&optModeCmd
, userdata
,
1827 sizeof(optModeCmd
)))
1830 } else if (ar
->arConnected
&& optModeCmd
.optMode
== SPECIAL_ON
) {
1833 } else if (wmi_set_opt_mode_cmd(ar
->arWmi
, optModeCmd
.optMode
)
1841 case AR6000_XIOCTL_OPT_SEND_FRAME
:
1843 WMI_OPT_TX_FRAME_CMD optTxFrmCmd
;
1844 A_UINT8 data
[MAX_OPT_DATA_LEN
];
1846 if (ar
->arWmiReady
== FALSE
) {
1848 } else if (copy_from_user(&optTxFrmCmd
, userdata
,
1849 sizeof(optTxFrmCmd
)))
1852 } else if (copy_from_user(data
,
1853 userdata
+sizeof(WMI_OPT_TX_FRAME_CMD
)-1,
1854 optTxFrmCmd
.optIEDataLen
))
1858 ret
= wmi_opt_tx_frame_cmd(ar
->arWmi
,
1859 optTxFrmCmd
.frmType
,
1860 optTxFrmCmd
.dstAddr
,
1862 optTxFrmCmd
.optIEDataLen
,
1868 case AR6000_XIOCTL_WMI_SETRETRYLIMITS
:
1870 WMI_SET_RETRY_LIMITS_CMD setRetryParams
;
1872 if (ar
->arWmiReady
== FALSE
) {
1874 } else if (copy_from_user(&setRetryParams
, userdata
,
1875 sizeof(setRetryParams
)))
1879 if (wmi_set_retry_limits_cmd(ar
->arWmi
, setRetryParams
.frameType
,
1880 setRetryParams
.trafficClass
,
1881 setRetryParams
.maxRetries
,
1882 setRetryParams
.enableNotify
) != A_OK
)
1886 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1887 ar
->arMaxRetries
= setRetryParams
.maxRetries
;
1888 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1893 case AR6000_XIOCTL_SET_ADHOC_BEACON_INTVAL
:
1895 WMI_BEACON_INT_CMD bIntvlCmd
;
1897 if (ar
->arWmiReady
== FALSE
) {
1899 } else if (copy_from_user(&bIntvlCmd
, userdata
,
1903 } else if (wmi_set_adhoc_bconIntvl_cmd(ar
->arWmi
, bIntvlCmd
.beaconInterval
)
1910 case IEEE80211_IOCTL_SETAUTHALG
:
1912 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
1913 struct ieee80211req_authalg req
;
1915 if (ar
->arWmiReady
== FALSE
) {
1917 } else if (copy_from_user(&req
, userdata
,
1918 sizeof(struct ieee80211req_authalg
)))
1921 } else if (req
.auth_alg
== AUTH_ALG_OPEN_SYSTEM
) {
1922 ar
->arDot11AuthMode
= OPEN_AUTH
;
1923 ar
->arPairwiseCrypto
= NONE_CRYPT
;
1924 ar
->arGroupCrypto
= NONE_CRYPT
;
1925 } else if (req
.auth_alg
== AUTH_ALG_LEAP
) {
1926 ar
->arDot11AuthMode
= LEAP_AUTH
;
1933 case AR6000_XIOCTL_SET_VOICE_PKT_SIZE
:
1934 ret
= ar6000_xioctl_set_voice_pkt_size(dev
, userdata
);
1937 case AR6000_XIOCTL_SET_MAX_SP
:
1938 ret
= ar6000_xioctl_set_max_sp_len(dev
, userdata
);
1941 case AR6000_XIOCTL_WMI_GET_ROAM_TBL
:
1942 ret
= ar6000_ioctl_get_roam_tbl(dev
, rq
);
1944 case AR6000_XIOCTL_WMI_SET_ROAM_CTRL
:
1945 ret
= ar6000_ioctl_set_roam_ctrl(dev
, userdata
);
1947 case AR6000_XIOCTRL_WMI_SET_POWERSAVE_TIMERS
:
1948 ret
= ar6000_ioctl_set_powersave_timers(dev
, userdata
);
1950 case AR6000_XIOCTRL_WMI_GET_POWER_MODE
:
1951 ret
= ar6000_ioctl_get_power_mode(dev
, rq
);
1953 case AR6000_XIOCTRL_WMI_SET_WLAN_STATE
:
1954 get_user(ar
->arWlanState
, (unsigned int *)userdata
);
1955 if (ar
->arWmiReady
== FALSE
) {
1960 if (ar
->arWlanState
== WLAN_ENABLED
) {
1961 /* Enable foreground scanning */
1962 if (wmi_scanparams_cmd(ar
->arWmi
, scParams
.fg_start_period
,
1963 scParams
.fg_end_period
,
1965 scParams
.minact_chdwell_time
,
1966 scParams
.maxact_chdwell_time
,
1967 scParams
.pas_chdwell_time
,
1968 scParams
.shortScanRatio
,
1969 scParams
.scanCtrlFlags
,
1970 scParams
.max_dfsch_act_time
) != A_OK
)
1974 if (ar
->arSsidLen
) {
1975 ar
->arConnectPending
= TRUE
;
1976 if (wmi_connect_cmd(ar
->arWmi
, ar
->arNetworkType
,
1977 ar
->arDot11AuthMode
, ar
->arAuthMode
,
1978 ar
->arPairwiseCrypto
,
1979 ar
->arPairwiseCryptoLen
,
1980 ar
->arGroupCrypto
, ar
->arGroupCryptoLen
,
1981 ar
->arSsidLen
, ar
->arSsid
,
1982 ar
->arReqBssid
, ar
->arChannelHint
,
1983 ar
->arConnectCtrlFlags
) != A_OK
)
1986 ar
->arConnectPending
= FALSE
;
1990 /* Disconnect from the AP and disable foreground scanning */
1991 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
1992 if (ar
->arConnected
== TRUE
|| ar
->arConnectPending
== TRUE
) {
1993 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1994 wmi_disconnect_cmd(ar
->arWmi
);
1996 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
1999 if (wmi_scanparams_cmd(ar
->arWmi
, 0xFFFF, 0, 0, 0, 0, 0, 0, 0xFF, 0) != A_OK
)
2005 case AR6000_XIOCTL_WMI_GET_ROAM_DATA
:
2006 ret
= ar6000_ioctl_get_roam_data(dev
, rq
);
2008 case AR6000_XIOCTL_WMI_SET_BT_STATUS
:
2009 ret
= ar6000_xioctl_set_bt_status_cmd(dev
, userdata
);
2011 case AR6000_XIOCTL_WMI_SET_BT_PARAMS
:
2012 ret
= ar6000_xioctl_set_bt_params_cmd(dev
, userdata
);
2014 case AR6000_XIOCTL_WMI_STARTSCAN
:
2016 WMI_START_SCAN_CMD setStartScanCmd
;
2018 if (ar
->arWmiReady
== FALSE
) {
2020 } else if (copy_from_user(&setStartScanCmd
, userdata
,
2021 sizeof(setStartScanCmd
)))
2025 if (wmi_startscan_cmd(ar
->arWmi
, setStartScanCmd
.scanType
,
2026 setStartScanCmd
.forceFgScan
,
2027 setStartScanCmd
.isLegacy
,
2028 setStartScanCmd
.homeDwellTime
,
2029 setStartScanCmd
.forceScanInterval
) != A_OK
)
2036 case AR6000_XIOCTL_WMI_SETFIXRATES
:
2038 WMI_FIX_RATES_CMD setFixRatesCmd
;
2039 A_STATUS returnStatus
;
2041 if (ar
->arWmiReady
== FALSE
) {
2043 } else if (copy_from_user(&setFixRatesCmd
, userdata
,
2044 sizeof(setFixRatesCmd
)))
2048 returnStatus
= wmi_set_fixrates_cmd(ar
->arWmi
, setFixRatesCmd
.fixRateMask
);
2049 if (returnStatus
== A_EINVAL
)
2053 else if(returnStatus
!= A_OK
) {
2060 case AR6000_XIOCTL_WMI_GETFIXRATES
:
2062 WMI_FIX_RATES_CMD getFixRatesCmd
;
2063 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
2066 if (ar
->arWmiReady
== FALSE
) {
2070 if (down_interruptible(&ar
->arSem
)) {
2071 return -ERESTARTSYS
;
2073 /* Used copy_from_user/copy_to_user to access user space data */
2074 if (copy_from_user(&getFixRatesCmd
, userdata
, sizeof(getFixRatesCmd
))) {
2077 ar
->arRateMask
= 0xFFFF;
2079 if (wmi_get_ratemask_cmd(ar
->arWmi
) != A_OK
) {
2084 wait_event_interruptible_timeout(arEvent
, ar
->arRateMask
!= 0xFFFF, wmitimeout
* HZ
);
2086 if (signal_pending(current
)) {
2091 getFixRatesCmd
.fixRateMask
= ar
->arRateMask
;
2094 if(copy_to_user(userdata
, &getFixRatesCmd
, sizeof(getFixRatesCmd
))) {
2102 case AR6000_XIOCTL_WMI_SET_AUTHMODE
:
2104 WMI_SET_AUTH_MODE_CMD setAuthMode
;
2106 if (ar
->arWmiReady
== FALSE
) {
2108 } else if (copy_from_user(&setAuthMode
, userdata
,
2109 sizeof(setAuthMode
)))
2113 if (wmi_set_authmode_cmd(ar
->arWmi
, setAuthMode
.mode
) != A_OK
)
2120 case AR6000_XIOCTL_WMI_SET_REASSOCMODE
:
2122 WMI_SET_REASSOC_MODE_CMD setReassocMode
;
2124 if (ar
->arWmiReady
== FALSE
) {
2126 } else if (copy_from_user(&setReassocMode
, userdata
,
2127 sizeof(setReassocMode
)))
2131 if (wmi_set_reassocmode_cmd(ar
->arWmi
, setReassocMode
.mode
) != A_OK
)
2138 case AR6000_XIOCTL_DIAG_READ
:
2140 A_UINT32 addr
, data
;
2141 get_user(addr
, (unsigned int *)userdata
);
2142 if (ar6000_ReadRegDiag(ar
->arHifDevice
, &addr
, &data
) != A_OK
) {
2145 put_user(data
, (unsigned int *)userdata
+ 1);
2148 case AR6000_XIOCTL_DIAG_WRITE
:
2150 A_UINT32 addr
, data
;
2151 get_user(addr
, (unsigned int *)userdata
);
2152 get_user(data
, (unsigned int *)userdata
+ 1);
2153 if (ar6000_WriteRegDiag(ar
->arHifDevice
, &addr
, &data
) != A_OK
) {
2158 case AR6000_XIOCTL_WMI_SET_KEEPALIVE
:
2160 WMI_SET_KEEPALIVE_CMD setKeepAlive
;
2161 if (ar
->arWmiReady
== FALSE
) {
2163 } else if (copy_from_user(&setKeepAlive
, userdata
,
2164 sizeof(setKeepAlive
))){
2167 if (wmi_set_keepalive_cmd(ar
->arWmi
, setKeepAlive
.keepaliveInterval
) != A_OK
) {
2173 case AR6000_XIOCTL_WMI_GET_KEEPALIVE
:
2175 AR_SOFTC_T
*ar
= (AR_SOFTC_T
*)netdev_priv(dev
);
2176 WMI_GET_KEEPALIVE_CMD getKeepAlive
;
2178 if (ar
->arWmiReady
== FALSE
) {
2181 if (down_interruptible(&ar
->arSem
)) {
2182 return -ERESTARTSYS
;
2184 if (copy_from_user(&getKeepAlive
, userdata
,sizeof(getKeepAlive
))) {
2187 getKeepAlive
.keepaliveInterval
= wmi_get_keepalive_cmd(ar
->arWmi
);
2188 ar
->arKeepaliveConfigured
= 0xFF;
2189 if (wmi_get_keepalive_configured(ar
->arWmi
) != A_OK
){
2193 wait_event_interruptible_timeout(arEvent
, ar
->arKeepaliveConfigured
!= 0xFF, wmitimeout
* HZ
);
2194 if (signal_pending(current
)) {
2199 getKeepAlive
.configured
= ar
->arKeepaliveConfigured
;
2201 if (copy_to_user(userdata
, &getKeepAlive
, sizeof(getKeepAlive
))) {
2208 case AR6000_XIOCTL_WMI_SET_APPIE
:
2210 WMI_SET_APPIE_CMD appIEcmd
;
2211 A_UINT8 appIeInfo
[IEEE80211_APPIE_FRAME_MAX_LEN
];
2212 A_UINT32 fType
,ieLen
;
2214 if (ar
->arWmiReady
== FALSE
) {
2217 get_user(fType
, (A_UINT32
*)userdata
);
2218 appIEcmd
.mgmtFrmType
= fType
;
2219 if (appIEcmd
.mgmtFrmType
>= IEEE80211_APPIE_NUM_OF_FRAME
) {
2222 get_user(ieLen
, (A_UINT32
*)(userdata
+ 4));
2223 appIEcmd
.ieLen
= ieLen
;
2224 if (appIEcmd
.ieLen
> IEEE80211_APPIE_FRAME_MAX_LEN
) {
2228 if (copy_from_user(appIeInfo
, userdata
+ 8, appIEcmd
.ieLen
)) {
2231 if (wmi_set_appie_cmd(ar
->arWmi
, appIEcmd
.mgmtFrmType
,
2232 appIEcmd
.ieLen
, appIeInfo
) != A_OK
)
2240 case AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER
:
2242 WMI_BSS_FILTER_CMD cmd
;
2243 A_UINT32 filterType
;
2245 if (copy_from_user(&filterType
, userdata
, sizeof(A_UINT32
)))
2249 if (filterType
& (IEEE80211_FILTER_TYPE_BEACON
|
2250 IEEE80211_FILTER_TYPE_PROBE_RESP
))
2252 cmd
.bssFilter
= ALL_BSS_FILTER
;
2254 cmd
.bssFilter
= NONE_BSS_FILTER
;
2256 if (wmi_bssfilter_cmd(ar
->arWmi
, cmd
.bssFilter
, 0) != A_OK
) {
2260 AR6000_SPIN_LOCK(&ar
->arLock
, 0);
2261 ar
->arMgmtFilter
= filterType
;
2262 AR6000_SPIN_UNLOCK(&ar
->arLock
, 0);
2265 case AR6000_XIOCTL_WMI_SET_WSC_STATUS
:
2267 A_UINT32 wsc_status
;
2269 if (copy_from_user(&wsc_status
, userdata
, sizeof(A_UINT32
)))
2273 if (wmi_set_wsc_status_cmd(ar
->arWmi
, wsc_status
) != A_OK
) {
2278 case AR6000_XIOCTL_BMI_ROMPATCH_INSTALL
:
2283 A_UINT32 do_activate
;
2284 A_UINT32 rompatch_id
;
2286 get_user(ROM_addr
, (A_UINT32
*)userdata
);
2287 get_user(RAM_addr
, (A_UINT32
*)userdata
+ 1);
2288 get_user(nbytes
, (A_UINT32
*)userdata
+ 2);
2289 get_user(do_activate
, (A_UINT32
*)userdata
+ 3);
2290 AR_DEBUG_PRINTF("Install rompatch from ROM: 0x%x to RAM: 0x%x length: %d\n",
2291 ROM_addr
, RAM_addr
, nbytes
);
2292 ret
= BMIrompatchInstall(hifDevice
, ROM_addr
, RAM_addr
,
2293 nbytes
, do_activate
, &rompatch_id
);
2295 put_user(rompatch_id
, (unsigned int *)rq
->ifr_data
); /* return value */
2300 case AR6000_XIOCTL_BMI_ROMPATCH_UNINSTALL
:
2302 A_UINT32 rompatch_id
;
2304 get_user(rompatch_id
, (A_UINT32
*)userdata
);
2305 AR_DEBUG_PRINTF("UNinstall rompatch_id %d\n", rompatch_id
);
2306 ret
= BMIrompatchUninstall(hifDevice
, rompatch_id
);
2310 case AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE
:
2311 case AR6000_XIOCTL_BMI_ROMPATCH_DEACTIVATE
:
2313 A_UINT32 rompatch_count
;
2315 get_user(rompatch_count
, (A_UINT32
*)userdata
);
2316 AR_DEBUG_PRINTF("Change rompatch activation count=%d\n", rompatch_count
);
2317 length
= sizeof(A_UINT32
) * rompatch_count
;
2318 if ((buffer
= (unsigned char *)A_MALLOC(length
)) != NULL
) {
2319 A_MEMZERO(buffer
, length
);
2320 if (copy_from_user(buffer
, &userdata
[sizeof(rompatch_count
)], length
))
2324 if (cmd
== AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE
) {
2325 ret
= BMIrompatchActivate(hifDevice
, rompatch_count
, (A_UINT32
*)buffer
);
2327 ret
= BMIrompatchDeactivate(hifDevice
, rompatch_count
, (A_UINT32
*)buffer
);
2338 case AR6000_XIOCTL_WMI_SET_HOST_SLEEP_MODE
:
2340 WMI_SET_HOST_SLEEP_MODE_CMD setHostSleepMode
;
2342 if (ar
->arWmiReady
== FALSE
) {
2344 } else if (copy_from_user(&setHostSleepMode
, userdata
,
2345 sizeof(setHostSleepMode
)))
2349 if (wmi_set_host_sleep_mode_cmd(ar
->arWmi
,
2350 &setHostSleepMode
) != A_OK
)
2357 case AR6000_XIOCTL_WMI_SET_WOW_MODE
:
2359 WMI_SET_WOW_MODE_CMD setWowMode
;
2361 if (ar
->arWmiReady
== FALSE
) {
2363 } else if (copy_from_user(&setWowMode
, userdata
,
2364 sizeof(setWowMode
)))
2368 if (wmi_set_wow_mode_cmd(ar
->arWmi
,
2369 &setWowMode
) != A_OK
)
2376 case AR6000_XIOCTL_WMI_GET_WOW_LIST
:
2378 WMI_GET_WOW_LIST_CMD getWowList
;
2380 if (ar
->arWmiReady
== FALSE
) {
2382 } else if (copy_from_user(&getWowList
, userdata
,
2383 sizeof(getWowList
)))
2387 if (wmi_get_wow_list_cmd(ar
->arWmi
,
2388 &getWowList
) != A_OK
)
2395 case AR6000_XIOCTL_WMI_ADD_WOW_PATTERN
:
2397 #define WOW_PATTERN_SIZE 64
2398 #define WOW_MASK_SIZE 64
2400 WMI_ADD_WOW_PATTERN_CMD cmd
;
2401 A_UINT8 mask_data
[WOW_PATTERN_SIZE
]={0};
2402 A_UINT8 pattern_data
[WOW_PATTERN_SIZE
]={0};
2404 if (ar
->arWmiReady
== FALSE
) {
2408 if(copy_from_user(&cmd
, userdata
,
2409 sizeof(WMI_ADD_WOW_PATTERN_CMD
)))
2411 if (copy_from_user(pattern_data
,
2417 if (copy_from_user(mask_data
,
2418 (userdata
+ 3 + cmd
.filter_size
),
2423 if (wmi_add_wow_pattern_cmd(ar
->arWmi
,
2424 &cmd
, pattern_data
, mask_data
, cmd
.filter_size
) != A_OK
){
2429 #undef WOW_PATTERN_SIZE
2430 #undef WOW_MASK_SIZE
2433 case AR6000_XIOCTL_WMI_DEL_WOW_PATTERN
:
2435 WMI_DEL_WOW_PATTERN_CMD delWowPattern
;
2437 if (ar
->arWmiReady
== FALSE
) {
2439 } else if (copy_from_user(&delWowPattern
, userdata
,
2440 sizeof(delWowPattern
)))
2444 if (wmi_del_wow_pattern_cmd(ar
->arWmi
,
2445 &delWowPattern
) != A_OK
)
2452 case AR6000_XIOCTL_DUMP_HTC_CREDIT_STATE
:
2453 if (ar
->arHtcTarget
!= NULL
) {
2454 HTCDumpCreditStates(ar
->arHtcTarget
);
2457 case AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE
:
2458 if (ar
->arHtcTarget
!= NULL
) {
2459 struct ar6000_traffic_activity_change data
;
2461 if (copy_from_user(&data
, userdata
, sizeof(data
)))
2465 /* note, this is used for testing (mbox ping testing), indicate activity
2466 * change using the stream ID as the traffic class */
2467 ar6000_indicate_tx_activity(ar
,
2468 (A_UINT8
)data
.StreamID
,
2469 data
.Active
? TRUE
: FALSE
);
2472 case AR6000_XIOCTL_WMI_SET_CONNECT_CTRL_FLAGS
:
2473 if (ar
->arWmiReady
== FALSE
) {
2475 } else if (copy_from_user(&connectCtrlFlags
, userdata
,
2476 sizeof(connectCtrlFlags
)))
2480 ar
->arConnectCtrlFlags
= connectCtrlFlags
;
2483 case AR6000_XIOCTL_WMI_SET_AKMP_PARAMS
:
2484 if (ar
->arWmiReady
== FALSE
) {
2486 } else if (copy_from_user(&akmpParams
, userdata
,
2487 sizeof(WMI_SET_AKMP_PARAMS_CMD
)))
2491 if (wmi_set_akmp_params_cmd(ar
->arWmi
, &akmpParams
) != A_OK
) {
2496 case AR6000_XIOCTL_WMI_SET_PMKID_LIST
:
2497 if (ar
->arWmiReady
== FALSE
) {
2500 if (copy_from_user(&pmkidInfo
.numPMKID
, userdata
,
2501 sizeof(pmkidInfo
.numPMKID
)))
2506 if (copy_from_user(&pmkidInfo
.pmkidList
,
2507 userdata
+ sizeof(pmkidInfo
.numPMKID
),
2508 pmkidInfo
.numPMKID
* sizeof(WMI_PMKID
)))
2513 if (wmi_set_pmkid_list_cmd(ar
->arWmi
, &pmkidInfo
) != A_OK
) {
2518 case AR6000_XIOCTL_WMI_GET_PMKID_LIST
:
2519 if (ar
->arWmiReady
== FALSE
) {
2522 if (wmi_get_pmkid_list_cmd(ar
->arWmi
) != A_OK
) {