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) {