1
//------------------------------------------------------------------------------
2
// Copyright (c) 2004-2010 Atheros Communications Inc.
3
// All rights reserved.
7
// Permission to use, copy, modify, and/or distribute this software for any
8
// purpose with or without fee is hereby granted, provided that the above
9
// copyright notice and this permission notice appear in all copies.
11
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
// Author(s): ="Atheros"
22
//------------------------------------------------------------------------------
24
#include "ar6000_drv.h"
25
#include "ieee80211_ioctl.h"
26
#include "ar6kap_common.h"
27
#include "targaddrs.h"
29
#include "wlan_config.h"
31
extern int enablerssicompensation;
33
extern unsigned int wmitimeout;
34
extern A_WAITQUEUE_HEAD arEvent;
35
extern int tspecCompliance;
41
ar6000_ioctl_get_roam_tbl(struct net_device *dev, struct ifreq *rq)
43
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
45
if (ar->arWmiReady == FALSE) {
49
if(wmi_get_roam_tbl_cmd(ar->arWmi) != A_OK) {
57
ar6000_ioctl_get_roam_data(struct net_device *dev, struct ifreq *rq)
59
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
61
if (ar->arWmiReady == FALSE) {
66
/* currently assume only roam times are required */
67
if(wmi_get_roam_data_cmd(ar->arWmi, ROAM_DATA_TIME) != A_OK) {
76
ar6000_ioctl_set_roam_ctrl(struct net_device *dev, char *userdata)
78
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
79
WMI_SET_ROAM_CTRL_CMD cmd;
80
A_UINT8 size = sizeof(cmd);
82
if (ar->arWmiReady == FALSE) {
87
if (copy_from_user(&cmd, userdata, size)) {
91
if (cmd.roamCtrlType == WMI_SET_HOST_BIAS) {
92
if (cmd.info.bssBiasInfo.numBss > 1) {
93
size += (cmd.info.bssBiasInfo.numBss - 1) * sizeof(WMI_BSS_BIAS);
97
if (copy_from_user(&cmd, userdata, size)) {
101
if(wmi_set_roam_ctrl_cmd(ar->arWmi, &cmd, size) != A_OK) {
109
ar6000_ioctl_set_powersave_timers(struct net_device *dev, char *userdata)
111
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
112
WMI_POWERSAVE_TIMERS_POLICY_CMD cmd;
113
A_UINT8 size = sizeof(cmd);
115
if (ar->arWmiReady == FALSE) {
119
if (copy_from_user(&cmd, userdata, size)) {
123
if (copy_from_user(&cmd, userdata, size)) {
127
if(wmi_set_powersave_timers_cmd(ar->arWmi, &cmd, size) != A_OK) {
135
ar6000_ioctl_set_qos_supp(struct net_device *dev, struct ifreq *rq)
137
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
138
WMI_SET_QOS_SUPP_CMD cmd;
141
if ((dev->flags & IFF_UP) != IFF_UP) {
144
if (ar->arWmiReady == FALSE) {
148
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
154
ret = wmi_set_qos_supp_cmd(ar->arWmi, cmd.status);
170
ar6000_ioctl_set_wmm(struct net_device *dev, struct ifreq *rq)
172
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
176
if ((dev->flags & IFF_UP) != IFF_UP) {
179
if (ar->arWmiReady == FALSE) {
183
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
189
if (cmd.status == WMI_WMM_ENABLED) {
190
ar->arWmmEnabled = TRUE;
192
ar->arWmmEnabled = FALSE;
195
ret = wmi_set_wmm_cmd(ar->arWmi, cmd.status);
211
ar6000_ioctl_set_txop(struct net_device *dev, struct ifreq *rq)
213
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
214
WMI_SET_WMM_TXOP_CMD cmd;
217
if ((dev->flags & IFF_UP) != IFF_UP) {
220
if (ar->arWmiReady == FALSE) {
224
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
230
ret = wmi_set_wmm_txop(ar->arWmi, cmd.txopEnable);
246
ar6000_ioctl_get_rd(struct net_device *dev, struct ifreq *rq)
248
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
251
if ((dev->flags & IFF_UP) != IFF_UP || ar->arWmiReady == FALSE) {
255
if(copy_to_user((char *)((unsigned int*)rq->ifr_data + 1),
256
&ar->arRegCode, sizeof(ar->arRegCode)))
263
ar6000_ioctl_set_country(struct net_device *dev, struct ifreq *rq)
265
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
266
WMI_AP_SET_COUNTRY_CMD cmd;
269
if ((dev->flags & IFF_UP) != IFF_UP) {
272
if (ar->arWmiReady == FALSE) {
276
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
282
ar->ap_profile_flag = 1; /* There is a change in profile */
284
ret = wmi_set_country(ar->arWmi, cmd.countryCode);
285
A_MEMCPY(ar->ap_country_code, cmd.countryCode, 3);
301
/* Get power mode command */
303
ar6000_ioctl_get_power_mode(struct net_device *dev, struct ifreq *rq)
305
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
306
WMI_POWER_MODE_CMD power_mode;
309
if (ar->arWmiReady == FALSE) {
313
power_mode.powerMode = wmi_get_power_mode_cmd(ar->arWmi);
314
if (copy_to_user(rq->ifr_data, &power_mode, sizeof(WMI_POWER_MODE_CMD))) {
323
ar6000_ioctl_set_channelParams(struct net_device *dev, struct ifreq *rq)
325
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
326
WMI_CHANNEL_PARAMS_CMD cmd, *cmdp;
329
if (ar->arWmiReady == FALSE) {
334
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
338
if( (ar->arNextMode == AP_NETWORK) && (cmd.numChannels || cmd.scanParam) ) {
339
A_PRINTF("ERROR: Only wmode is allowed in AP mode\n");
343
if (cmd.numChannels > 1) {
344
cmdp = A_MALLOC(130);
345
if (copy_from_user(cmdp, rq->ifr_data,
347
((cmd.numChannels - 1) * sizeof(A_UINT16))))
356
if ((ar->arPhyCapability == WMI_11G_CAPABILITY) &&
357
((cmdp->phyMode == WMI_11A_MODE) || (cmdp->phyMode == WMI_11AG_MODE)))
363
(wmi_set_channelParams_cmd(ar->arWmi, cmdp->scanParam, cmdp->phyMode,
364
cmdp->numChannels, cmdp->channelList)
370
if (cmd.numChannels > 1) {
374
ar->ap_wmode = cmdp->phyMode;
375
/* Set the profile change flag to allow a commit cmd */
376
ar->ap_profile_flag = 1;
383
ar6000_ioctl_set_snr_threshold(struct net_device *dev, struct ifreq *rq)
386
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
387
WMI_SNR_THRESHOLD_PARAMS_CMD cmd;
390
if (ar->arWmiReady == FALSE) {
394
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
398
if( wmi_set_snr_threshold_params(ar->arWmi, &cmd) != A_OK ) {
406
ar6000_ioctl_set_rssi_threshold(struct net_device *dev, struct ifreq *rq)
408
#define SWAP_THOLD(thold1, thold2) do { \
409
USER_RSSI_THOLD tmpThold; \
410
tmpThold.tag = thold1.tag; \
411
tmpThold.rssi = thold1.rssi; \
412
thold1.tag = thold2.tag; \
413
thold1.rssi = thold2.rssi; \
414
thold2.tag = tmpThold.tag; \
415
thold2.rssi = tmpThold.rssi; \
418
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
419
WMI_RSSI_THRESHOLD_PARAMS_CMD cmd;
420
USER_RSSI_PARAMS rssiParams;
424
if (ar->arWmiReady == FALSE) {
428
if (copy_from_user((char *)&rssiParams, (char *)((unsigned int *)rq->ifr_data + 1), sizeof(USER_RSSI_PARAMS))) {
431
cmd.weight = rssiParams.weight;
432
cmd.pollTime = rssiParams.pollTime;
434
A_MEMCPY(ar->rssi_map, &rssiParams.tholds, sizeof(ar->rssi_map));
436
* only 6 elements, so use bubble sorting, in ascending order
438
for (i = 5; i > 0; i--) {
439
for (j = 0; j < i; j++) { /* above tholds */
440
if (ar->rssi_map[j+1].rssi < ar->rssi_map[j].rssi) {
441
SWAP_THOLD(ar->rssi_map[j+1], ar->rssi_map[j]);
442
} else if (ar->rssi_map[j+1].rssi == ar->rssi_map[j].rssi) {
447
for (i = 11; i > 6; i--) {
448
for (j = 6; j < i; j++) { /* below tholds */
449
if (ar->rssi_map[j+1].rssi < ar->rssi_map[j].rssi) {
450
SWAP_THOLD(ar->rssi_map[j+1], ar->rssi_map[j]);
451
} else if (ar->rssi_map[j+1].rssi == ar->rssi_map[j].rssi) {
458
for (i = 0; i < 12; i++) {
459
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("thold[%d].tag: %d, thold[%d].rssi: %d \n",
460
i, ar->rssi_map[i].tag, i, ar->rssi_map[i].rssi));
464
if (enablerssicompensation) {
465
for (i = 0; i < 6; i++)
466
ar->rssi_map[i].rssi = rssi_compensation_reverse_calc(ar, ar->rssi_map[i].rssi, TRUE);
467
for (i = 6; i < 12; i++)
468
ar->rssi_map[i].rssi = rssi_compensation_reverse_calc(ar, ar->rssi_map[i].rssi, FALSE);
471
cmd.thresholdAbove1_Val = ar->rssi_map[0].rssi;
472
cmd.thresholdAbove2_Val = ar->rssi_map[1].rssi;
473
cmd.thresholdAbove3_Val = ar->rssi_map[2].rssi;
474
cmd.thresholdAbove4_Val = ar->rssi_map[3].rssi;
475
cmd.thresholdAbove5_Val = ar->rssi_map[4].rssi;
476
cmd.thresholdAbove6_Val = ar->rssi_map[5].rssi;
477
cmd.thresholdBelow1_Val = ar->rssi_map[6].rssi;
478
cmd.thresholdBelow2_Val = ar->rssi_map[7].rssi;
479
cmd.thresholdBelow3_Val = ar->rssi_map[8].rssi;
480
cmd.thresholdBelow4_Val = ar->rssi_map[9].rssi;
481
cmd.thresholdBelow5_Val = ar->rssi_map[10].rssi;
482
cmd.thresholdBelow6_Val = ar->rssi_map[11].rssi;
484
if( wmi_set_rssi_threshold_params(ar->arWmi, &cmd) != A_OK ) {
492
ar6000_ioctl_set_lq_threshold(struct net_device *dev, struct ifreq *rq)
495
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
496
WMI_LQ_THRESHOLD_PARAMS_CMD cmd;
499
if (ar->arWmiReady == FALSE) {
503
if (copy_from_user(&cmd, (char *)((unsigned int *)rq->ifr_data + 1), sizeof(cmd))) {
507
if( wmi_set_lq_threshold_params(ar->arWmi, &cmd) != A_OK ) {
516
ar6000_ioctl_set_probedSsid(struct net_device *dev, struct ifreq *rq)
518
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
519
WMI_PROBED_SSID_CMD cmd;
522
if (ar->arWmiReady == FALSE) {
526
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
530
if (wmi_probedSsid_cmd(ar->arWmi, cmd.entryIndex, cmd.flag, cmd.ssidLength,
540
ar6000_ioctl_set_badAp(struct net_device *dev, struct ifreq *rq)
542
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
543
WMI_ADD_BAD_AP_CMD cmd;
546
if (ar->arWmiReady == FALSE) {
551
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
555
if (cmd.badApIndex > WMI_MAX_BAD_AP_INDEX) {
559
if (A_MEMCMP(cmd.bssid, null_mac, AR6000_ETH_ADDR_LEN) == 0) {
561
* This is a delete badAP.
563
if (wmi_deleteBadAp_cmd(ar->arWmi, cmd.badApIndex) != A_OK) {
567
if (wmi_addBadAp_cmd(ar->arWmi, cmd.badApIndex, cmd.bssid) != A_OK) {
576
ar6000_ioctl_create_qos(struct net_device *dev, struct ifreq *rq)
578
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
579
WMI_CREATE_PSTREAM_CMD cmd;
582
if (ar->arWmiReady == FALSE) {
587
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
591
ret = wmi_verify_tspec_params(&cmd, tspecCompliance);
593
ret = wmi_create_pstream_cmd(ar->arWmi, &cmd);
609
ar6000_ioctl_delete_qos(struct net_device *dev, struct ifreq *rq)
611
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
612
WMI_DELETE_PSTREAM_CMD cmd;
615
if (ar->arWmiReady == FALSE) {
619
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
623
ret = wmi_delete_pstream_cmd(ar->arWmi, cmd.trafficClass, cmd.tsid);
639
ar6000_ioctl_get_qos_queue(struct net_device *dev, struct ifreq *rq)
641
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
642
struct ar6000_queuereq qreq;
645
if (ar->arWmiReady == FALSE) {
649
if( copy_from_user(&qreq, rq->ifr_data,
650
sizeof(struct ar6000_queuereq)))
653
qreq.activeTsids = wmi_get_mapped_qos_queue(ar->arWmi, qreq.trafficClass);
655
if (copy_to_user(rq->ifr_data, &qreq,
656
sizeof(struct ar6000_queuereq)))
664
#ifdef CONFIG_HOST_TCMD_SUPPORT
666
ar6000_ioctl_tcmd_get_rx_report(struct net_device *dev,
667
struct ifreq *rq, A_UINT8 *data, A_UINT32 len)
669
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
670
A_UINT32 buf[4+TCMD_MAX_RATES];
673
if (ar->bIsDestroyProgress) {
677
if (ar->arWmiReady == FALSE) {
681
if (down_interruptible(&ar->arSem)) {
685
if (ar->bIsDestroyProgress) {
690
ar->tcmdRxReport = 0;
691
if (wmi_test_cmd(ar->arWmi, data, len) != A_OK) {
696
wait_event_interruptible_timeout(arEvent, ar->tcmdRxReport != 0, wmitimeout * HZ);
698
if (signal_pending(current)) {
702
buf[0] = ar->tcmdRxTotalPkt;
703
buf[1] = ar->tcmdRxRssi;
704
buf[2] = ar->tcmdRxcrcErrPkt;
705
buf[3] = ar->tcmdRxsecErrPkt;
706
A_MEMCPY(((A_UCHAR *)buf)+(4*sizeof(A_UINT32)), ar->tcmdRateCnt, sizeof(ar->tcmdRateCnt));
707
A_MEMCPY(((A_UCHAR *)buf)+(4*sizeof(A_UINT32))+(TCMD_MAX_RATES *sizeof(A_UINT16)), ar->tcmdRateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
709
if (!ret && copy_to_user(rq->ifr_data, buf, sizeof(buf))) {
719
ar6000_tcmd_rx_report_event(void *devt, A_UINT8 * results, int len)
721
AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
722
TCMD_CONT_RX * rx_rep = (TCMD_CONT_RX *)results;
724
if (enablerssicompensation) {
725
rx_rep->u.report.rssiInDBm = rssi_compensation_calc_tcmd(tcmdRxFreq, rx_rep->u.report.rssiInDBm,rx_rep->u.report.totalPkt);
729
ar->tcmdRxTotalPkt = rx_rep->u.report.totalPkt;
730
ar->tcmdRxRssi = rx_rep->u.report.rssiInDBm;
731
ar->tcmdRxcrcErrPkt = rx_rep->u.report.crcErrPkt;
732
ar->tcmdRxsecErrPkt = rx_rep->u.report.secErrPkt;
733
ar->tcmdRxReport = 1;
734
A_MEMZERO(ar->tcmdRateCnt, sizeof(ar->tcmdRateCnt));
735
A_MEMZERO(ar->tcmdRateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
736
A_MEMCPY(ar->tcmdRateCnt, rx_rep->u.report.rateCnt, sizeof(ar->tcmdRateCnt));
737
A_MEMCPY(ar->tcmdRateCntShortGuard, rx_rep->u.report.rateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
741
#endif /* CONFIG_HOST_TCMD_SUPPORT*/
744
ar6000_ioctl_set_error_report_bitmask(struct net_device *dev, struct ifreq *rq)
746
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
747
WMI_TARGET_ERROR_REPORT_BITMASK cmd;
750
if (ar->arWmiReady == FALSE) {
754
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
758
ret = wmi_set_error_report_bitmask(ar->arWmi, cmd.bitmask);
760
return (ret==0 ? ret : -EINVAL);
764
ar6000_clear_target_stats(struct net_device *dev)
766
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
767
TARGET_STATS *pStats = &ar->arTargetStats;
770
if (ar->arWmiReady == FALSE) {
773
AR6000_SPIN_LOCK(&ar->arLock, 0);
774
A_MEMZERO(pStats, sizeof(TARGET_STATS));
775
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
780
ar6000_ioctl_get_target_stats(struct net_device *dev, struct ifreq *rq)
782
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
783
TARGET_STATS_CMD cmd;
784
TARGET_STATS *pStats = &ar->arTargetStats;
787
if (ar->bIsDestroyProgress) {
790
if (ar->arWmiReady == FALSE) {
793
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
796
if (down_interruptible(&ar->arSem)) {
799
if (ar->bIsDestroyProgress) {
804
ar->statsUpdatePending = TRUE;
806
if(wmi_get_stats_cmd(ar->arWmi) != A_OK) {
811
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
813
if (signal_pending(current)) {
817
if (!ret && copy_to_user(rq->ifr_data, pStats, sizeof(*pStats))) {
821
if (cmd.clearStats == 1) {
822
ret = ar6000_clear_target_stats(dev);
831
ar6000_ioctl_get_ap_stats(struct net_device *dev, struct ifreq *rq)
833
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
834
A_UINT32 action; /* Allocating only the desired space on the frame. Declaring is as a WMI_AP_MODE_STAT variable results in exceeding the compiler imposed limit on the maximum frame size */
835
WMI_AP_MODE_STAT *pStats = &ar->arAPStats;
838
if (ar->arWmiReady == FALSE) {
841
if (copy_from_user(&action, (char *)((unsigned int*)rq->ifr_data + 1),
846
if (action == AP_CLEAR_STATS) {
848
AR6000_SPIN_LOCK(&ar->arLock, 0);
849
for(i = 0; i < AP_MAX_NUM_STA; i++) {
850
pStats->sta[i].tx_bytes = 0;
851
pStats->sta[i].tx_pkts = 0;
852
pStats->sta[i].tx_error = 0;
853
pStats->sta[i].tx_discard = 0;
854
pStats->sta[i].rx_bytes = 0;
855
pStats->sta[i].rx_pkts = 0;
856
pStats->sta[i].rx_error = 0;
857
pStats->sta[i].rx_discard = 0;
859
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
863
if (down_interruptible(&ar->arSem)) {
867
ar->statsUpdatePending = TRUE;
869
if(wmi_get_stats_cmd(ar->arWmi) != A_OK) {
874
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
876
if (signal_pending(current)) {
880
if (!ret && copy_to_user(rq->ifr_data, pStats, sizeof(*pStats))) {
890
ar6000_ioctl_set_access_params(struct net_device *dev, struct ifreq *rq)
892
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
893
WMI_SET_ACCESS_PARAMS_CMD cmd;
896
if (ar->arWmiReady == FALSE) {
900
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
904
if (wmi_set_access_params_cmd(ar->arWmi, cmd.ac, cmd.txop, cmd.eCWmin, cmd.eCWmax,
916
ar6000_ioctl_set_disconnect_timeout(struct net_device *dev, struct ifreq *rq)
918
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
919
WMI_DISC_TIMEOUT_CMD cmd;
922
if (ar->arWmiReady == FALSE) {
926
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
930
if (wmi_disctimeout_cmd(ar->arWmi, cmd.disconnectTimeout) == A_OK)
941
ar6000_xioctl_set_voice_pkt_size(struct net_device *dev, char * userdata)
943
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
944
WMI_SET_VOICE_PKT_SIZE_CMD cmd;
947
if (ar->arWmiReady == FALSE) {
951
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
955
if (wmi_set_voice_pkt_size_cmd(ar->arWmi, cmd.voicePktSize) == A_OK)
967
ar6000_xioctl_set_max_sp_len(struct net_device *dev, char * userdata)
969
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
970
WMI_SET_MAX_SP_LEN_CMD cmd;
973
if (ar->arWmiReady == FALSE) {
977
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
981
if (wmi_set_max_sp_len_cmd(ar->arWmi, cmd.maxSPLen) == A_OK)
993
ar6000_xioctl_set_bt_status_cmd(struct net_device *dev, char * userdata)
995
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
996
WMI_SET_BT_STATUS_CMD cmd;
999
if (ar->arWmiReady == FALSE) {
1003
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1007
if (wmi_set_bt_status_cmd(ar->arWmi, cmd.streamType, cmd.status) == A_OK)
1018
ar6000_xioctl_set_bt_params_cmd(struct net_device *dev, char * userdata)
1020
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1021
WMI_SET_BT_PARAMS_CMD cmd;
1024
if (ar->arWmiReady == FALSE) {
1028
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1032
if (wmi_set_bt_params_cmd(ar->arWmi, &cmd) == A_OK)
1043
ar6000_xioctl_set_btcoex_fe_ant_cmd(struct net_device * dev, char * userdata)
1045
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1046
WMI_SET_BTCOEX_FE_ANT_CMD cmd;
1049
if (ar->arWmiReady == FALSE) {
1052
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1056
if (wmi_set_btcoex_fe_ant_cmd(ar->arWmi, &cmd) == A_OK)
1067
ar6000_xioctl_set_btcoex_colocated_bt_dev_cmd(struct net_device * dev, char * userdata)
1069
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1070
WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD cmd;
1073
if (ar->arWmiReady == FALSE) {
1077
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1081
if (wmi_set_btcoex_colocated_bt_dev_cmd(ar->arWmi, &cmd) == A_OK)
1092
ar6000_xioctl_set_btcoex_btinquiry_page_config_cmd(struct net_device * dev, char * userdata)
1094
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1095
WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD cmd;
1098
if (ar->arWmiReady == FALSE) {
1102
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1106
if (wmi_set_btcoex_btinquiry_page_config_cmd(ar->arWmi, &cmd) == A_OK)
1117
ar6000_xioctl_set_btcoex_sco_config_cmd(struct net_device * dev, char * userdata)
1119
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1120
WMI_SET_BTCOEX_SCO_CONFIG_CMD cmd;
1123
if (ar->arWmiReady == FALSE) {
1127
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1131
if (wmi_set_btcoex_sco_config_cmd(ar->arWmi, &cmd) == A_OK)
1142
ar6000_xioctl_set_btcoex_a2dp_config_cmd(struct net_device * dev,
1145
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1146
WMI_SET_BTCOEX_A2DP_CONFIG_CMD cmd;
1149
if (ar->arWmiReady == FALSE) {
1153
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1157
if (wmi_set_btcoex_a2dp_config_cmd(ar->arWmi, &cmd) == A_OK)
1168
ar6000_xioctl_set_btcoex_aclcoex_config_cmd(struct net_device * dev, char * userdata)
1170
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1171
WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD cmd;
1174
if (ar->arWmiReady == FALSE) {
1178
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1182
if (wmi_set_btcoex_aclcoex_config_cmd(ar->arWmi, &cmd) == A_OK)
1193
ar60000_xioctl_set_btcoex_debug_cmd(struct net_device * dev, char * userdata)
1195
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1196
WMI_SET_BTCOEX_DEBUG_CMD cmd;
1199
if (ar->arWmiReady == FALSE) {
1203
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1207
if (wmi_set_btcoex_debug_cmd(ar->arWmi, &cmd) == A_OK)
1218
ar6000_xioctl_set_btcoex_bt_operating_status_cmd(struct net_device * dev, char * userdata)
1220
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1221
WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD cmd;
1224
if (ar->arWmiReady == FALSE) {
1228
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1232
if (wmi_set_btcoex_bt_operating_status_cmd(ar->arWmi, &cmd) == A_OK)
1242
ar6000_xioctl_get_btcoex_config_cmd(struct net_device * dev, char * userdata,
1246
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1247
AR6000_BTCOEX_CONFIG btcoexConfig;
1248
WMI_BTCOEX_CONFIG_EVENT *pbtcoexConfigEv = &ar->arBtcoexConfig;
1252
if (ar->bIsDestroyProgress) {
1255
if (ar->arWmiReady == FALSE) {
1258
if (copy_from_user(&btcoexConfig.configCmd, userdata, sizeof(AR6000_BTCOEX_CONFIG))) {
1261
if (down_interruptible(&ar->arSem)) {
1262
return -ERESTARTSYS;
1265
if (wmi_get_btcoex_config_cmd(ar->arWmi, (WMI_GET_BTCOEX_CONFIG_CMD *)&btcoexConfig.configCmd) != A_OK)
1271
ar->statsUpdatePending = TRUE;
1273
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
1275
if (signal_pending(current)) {
1279
if (!ret && copy_to_user(btcoexConfig.configEvent, pbtcoexConfigEv, sizeof(WMI_BTCOEX_CONFIG_EVENT))) {
1287
ar6000_xioctl_get_btcoex_stats_cmd(struct net_device * dev, char * userdata, struct ifreq *rq)
1289
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1290
AR6000_BTCOEX_STATS btcoexStats;
1291
WMI_BTCOEX_STATS_EVENT *pbtcoexStats = &ar->arBtcoexStats;
1294
if (ar->bIsDestroyProgress) {
1297
if (ar->arWmiReady == FALSE) {
1301
if (down_interruptible(&ar->arSem)) {
1302
return -ERESTARTSYS;
1305
if (copy_from_user(&btcoexStats.statsEvent, userdata, sizeof(AR6000_BTCOEX_CONFIG))) {
1309
if (wmi_get_btcoex_stats_cmd(ar->arWmi) != A_OK)
1315
ar->statsUpdatePending = TRUE;
1317
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
1319
if (signal_pending(current)) {
1323
if (!ret && copy_to_user(btcoexStats.statsEvent, pbtcoexStats, sizeof(WMI_BTCOEX_STATS_EVENT))) {
1333
#ifdef CONFIG_HOST_GPIO_SUPPORT
1334
struct ar6000_gpio_intr_wait_cmd_s gpio_intr_results;
1335
/* gpio_reg_results and gpio_data_available are protected by arSem */
1336
static struct ar6000_gpio_register_cmd_s gpio_reg_results;
1337
static A_BOOL gpio_data_available; /* Requested GPIO data available */
1338
static A_BOOL gpio_intr_available; /* GPIO interrupt info available */
1339
static A_BOOL gpio_ack_received; /* GPIO ack was received */
1341
/* Host-side initialization for General Purpose I/O support */
1342
void ar6000_gpio_init(void)
1344
gpio_intr_available = FALSE;
1345
gpio_data_available = FALSE;
1346
gpio_ack_received = FALSE;
1350
* Called when a GPIO interrupt is received from the Target.
1351
* intr_values shows which GPIO pins have interrupted.
1352
* input_values shows a recent value of GPIO pins.
1355
ar6000_gpio_intr_rx(A_UINT32 intr_mask, A_UINT32 input_values)
1357
gpio_intr_results.intr_mask = intr_mask;
1358
gpio_intr_results.input_values = input_values;
1359
*((volatile A_BOOL *)&gpio_intr_available) = TRUE;
1364
* This is called when a response is received from the Target
1365
* for a previous or ar6000_gpio_input_get or ar6000_gpio_register_get
1369
ar6000_gpio_data_rx(A_UINT32 reg_id, A_UINT32 value)
1371
gpio_reg_results.gpioreg_id = reg_id;
1372
gpio_reg_results.value = value;
1373
*((volatile A_BOOL *)&gpio_data_available) = TRUE;
1378
* This is called when an acknowledgement is received from the Target
1379
* for a previous or ar6000_gpio_output_set or ar6000_gpio_register_set
1383
ar6000_gpio_ack_rx(void)
1385
gpio_ack_received = TRUE;
1390
ar6000_gpio_output_set(struct net_device *dev,
1392
A_UINT32 clear_mask,
1393
A_UINT32 enable_mask,
1394
A_UINT32 disable_mask)
1396
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1398
gpio_ack_received = FALSE;
1399
return wmi_gpio_output_set(ar->arWmi,
1400
set_mask, clear_mask, enable_mask, disable_mask);
1404
ar6000_gpio_input_get(struct net_device *dev)
1406
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1408
*((volatile A_BOOL *)&gpio_data_available) = FALSE;
1409
return wmi_gpio_input_get(ar->arWmi);
1413
ar6000_gpio_register_set(struct net_device *dev,
1414
A_UINT32 gpioreg_id,
1417
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1419
gpio_ack_received = FALSE;
1420
return wmi_gpio_register_set(ar->arWmi, gpioreg_id, value);
1424
ar6000_gpio_register_get(struct net_device *dev,
1425
A_UINT32 gpioreg_id)
1427
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1429
*((volatile A_BOOL *)&gpio_data_available) = FALSE;
1430
return wmi_gpio_register_get(ar->arWmi, gpioreg_id);
1434
ar6000_gpio_intr_ack(struct net_device *dev,
1437
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1439
gpio_intr_available = FALSE;
1440
return wmi_gpio_intr_ack(ar->arWmi, ack_mask);
1442
#endif /* CONFIG_HOST_GPIO_SUPPORT */
1444
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
1445
static struct prof_count_s prof_count_results;
1446
static A_BOOL prof_count_available; /* Requested GPIO data available */
1449
prof_count_get(struct net_device *dev)
1451
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1453
*((volatile A_BOOL *)&prof_count_available) = FALSE;
1454
return wmi_prof_count_get_cmd(ar->arWmi);
1458
* This is called when a response is received from the Target
1459
* for a previous prof_count_get call.
1462
prof_count_rx(A_UINT32 addr, A_UINT32 count)
1464
prof_count_results.addr = addr;
1465
prof_count_results.count = count;
1466
*((volatile A_BOOL *)&prof_count_available) = TRUE;
1469
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
1473
ar6000_create_acl_data_osbuf(struct net_device *dev, A_UINT8 *userdata, void **p_osbuf)
1476
A_UINT8 tmp_space[8];
1477
HCI_ACL_DATA_PKT *acl;
1478
A_UINT8 hdr_size, *datap=NULL;
1479
A_STATUS ret = A_OK;
1481
/* ACL is in data path. There is a need to create pool
1482
* mechanism for allocating and freeing NETBUFs - ToDo later.
1486
acl = (HCI_ACL_DATA_PKT *)tmp_space;
1487
hdr_size = sizeof(acl->hdl_and_flags) + sizeof(acl->data_len);
1490
if (a_copy_from_user(acl, userdata, hdr_size)) {
1495
osbuf = A_NETBUF_ALLOC(hdr_size + acl->data_len);
1496
if (osbuf == NULL) {
1500
A_NETBUF_PUT(osbuf, hdr_size + acl->data_len);
1501
datap = (A_UINT8 *)A_NETBUF_DATA(osbuf);
1503
/* Real copy to osbuf */
1504
acl = (HCI_ACL_DATA_PKT *)(datap);
1505
A_MEMCPY(acl, tmp_space, hdr_size);
1506
if (a_copy_from_user(acl->data, userdata + hdr_size, acl->data_len)) {
1515
A_NETBUF_FREE(osbuf);
1523
ar6000_ioctl_ap_setparam(AR_SOFTC_T *ar, int param, int value)
1528
case IEEE80211_PARAM_WPA:
1531
ar->arAuthMode = WPA_AUTH;
1534
ar->arAuthMode = WPA2_AUTH;
1537
ar->arAuthMode = WPA_AUTH | WPA2_AUTH;
1540
ar->arAuthMode = NONE_AUTH;
1544
case IEEE80211_PARAM_AUTHMODE:
1545
if(value == IEEE80211_AUTH_WPA_PSK) {
1546
if (WPA_AUTH == ar->arAuthMode) {
1547
ar->arAuthMode = WPA_PSK_AUTH;
1548
} else if (WPA2_AUTH == ar->arAuthMode) {
1549
ar->arAuthMode = WPA2_PSK_AUTH;
1550
} else if ((WPA_AUTH | WPA2_AUTH) == ar->arAuthMode) {
1551
ar->arAuthMode = WPA_PSK_AUTH | WPA2_PSK_AUTH;
1553
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Error - Setting PSK "\
1554
"mode when WPA param was set to %d\n",
1560
case IEEE80211_PARAM_UCASTCIPHER:
1561
ar->arPairwiseCrypto = 0;
1562
if(value & (1<<IEEE80211_CIPHER_AES_CCM)) {
1563
ar->arPairwiseCrypto |= AES_CRYPT;
1565
if(value & (1<<IEEE80211_CIPHER_TKIP)) {
1566
ar->arPairwiseCrypto |= TKIP_CRYPT;
1568
if(!ar->arPairwiseCrypto) {
1569
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
1570
("Error - Invalid cipher in WPA \n"));
1574
case IEEE80211_PARAM_PRIVACY:
1576
ar->arDot11AuthMode = OPEN_AUTH;
1577
ar->arAuthMode = NONE_AUTH;
1578
ar->arPairwiseCrypto = NONE_CRYPT;
1579
ar->arPairwiseCryptoLen = 0;
1580
ar->arGroupCrypto = NONE_CRYPT;
1581
ar->arGroupCryptoLen = 0;
1585
case IEEE80211_PARAM_WAPI:
1586
A_PRINTF("WAPI Policy: %d\n", value);
1587
ar->arDot11AuthMode = OPEN_AUTH;
1588
ar->arAuthMode = NONE_AUTH;
1590
ar->arPairwiseCrypto = WAPI_CRYPT;
1591
ar->arGroupCrypto = WAPI_CRYPT;
1593
ar->arPairwiseCrypto = NONE_CRYPT;
1594
ar->arGroupCrypto = NONE_CRYPT;
1603
ar6000_ioctl_setparam(AR_SOFTC_T *ar, int param, int value)
1605
A_BOOL profChanged = FALSE;
1608
if(ar->arNextMode == AP_NETWORK) {
1609
ar->ap_profile_flag = 1; /* There is a change in profile */
1611
case IEEE80211_PARAM_WPA:
1612
case IEEE80211_PARAM_AUTHMODE:
1613
case IEEE80211_PARAM_UCASTCIPHER:
1614
case IEEE80211_PARAM_PRIVACY:
1615
case IEEE80211_PARAM_WAPI:
1616
ret = ar6000_ioctl_ap_setparam(ar, param, value);
1622
case IEEE80211_PARAM_WPA:
1625
ar->arAuthMode = WPA_AUTH;
1629
ar->arAuthMode = WPA2_AUTH;
1633
ar->arAuthMode = NONE_AUTH;
1638
case IEEE80211_PARAM_AUTHMODE:
1640
case IEEE80211_AUTH_WPA_PSK:
1641
if (WPA_AUTH == ar->arAuthMode) {
1642
ar->arAuthMode = WPA_PSK_AUTH;
1644
} else if (WPA2_AUTH == ar->arAuthMode) {
1645
ar->arAuthMode = WPA2_PSK_AUTH;
1648
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Error - Setting PSK "\
1649
"mode when WPA param was set to %d\n",
1654
case IEEE80211_AUTH_WPA_CCKM:
1655
if (WPA2_AUTH == ar->arAuthMode) {
1656
ar->arAuthMode = WPA2_AUTH_CCKM;
1658
ar->arAuthMode = WPA_AUTH_CCKM;
1665
case IEEE80211_PARAM_UCASTCIPHER:
1667
case IEEE80211_CIPHER_AES_CCM:
1668
ar->arPairwiseCrypto = AES_CRYPT;
1671
case IEEE80211_CIPHER_TKIP:
1672
ar->arPairwiseCrypto = TKIP_CRYPT;
1675
case IEEE80211_CIPHER_WEP:
1676
ar->arPairwiseCrypto = WEP_CRYPT;
1679
case IEEE80211_CIPHER_NONE:
1680
ar->arPairwiseCrypto = NONE_CRYPT;
1685
case IEEE80211_PARAM_UCASTKEYLEN:
1686
if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(value)) {
1689
ar->arPairwiseCryptoLen = value;
1692
case IEEE80211_PARAM_MCASTCIPHER:
1694
case IEEE80211_CIPHER_AES_CCM:
1695
ar->arGroupCrypto = AES_CRYPT;
1698
case IEEE80211_CIPHER_TKIP:
1699
ar->arGroupCrypto = TKIP_CRYPT;
1702
case IEEE80211_CIPHER_WEP:
1703
ar->arGroupCrypto = WEP_CRYPT;
1706
case IEEE80211_CIPHER_NONE:
1707
ar->arGroupCrypto = NONE_CRYPT;
1712
case IEEE80211_PARAM_MCASTKEYLEN:
1713
if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(value)) {
1716
ar->arGroupCryptoLen = value;
1719
case IEEE80211_PARAM_COUNTERMEASURES:
1720
if (ar->arWmiReady == FALSE) {
1723
wmi_set_tkip_countermeasures_cmd(ar->arWmi, value);
1728
if ((ar->arNextMode != AP_NETWORK) && (profChanged == TRUE)) {
1730
* profile has changed. Erase ssid to signal change
1732
A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
1739
ar6000_ioctl_setkey(AR_SOFTC_T *ar, struct ieee80211req_key *ik)
1743
CRYPTO_TYPE keyType = NONE_CRYPT;
1746
ar->user_saved_keys.keyOk = FALSE;
1748
if ( (0 == memcmp(ik->ik_macaddr, null_mac, IEEE80211_ADDR_LEN)) ||
1749
(0 == memcmp(ik->ik_macaddr, bcast_mac, IEEE80211_ADDR_LEN)) ) {
1750
keyUsage = GROUP_USAGE;
1751
if(ar->arNextMode == AP_NETWORK) {
1752
A_MEMCPY(&ar->ap_mode_bkey, ik,
1753
sizeof(struct ieee80211req_key));
1755
if(ar->arPairwiseCrypto == WAPI_CRYPT) {
1756
return ap_set_wapi_key(ar, ik);
1761
A_MEMCPY(&ar->user_saved_keys.bcast_ik, ik,
1762
sizeof(struct ieee80211req_key));
1765
keyUsage = PAIRWISE_USAGE;
1767
A_MEMCPY(&ar->user_saved_keys.ucast_ik, ik,
1768
sizeof(struct ieee80211req_key));
1771
if(ar->arNextMode == AP_NETWORK) {
1772
if(ar->arPairwiseCrypto == WAPI_CRYPT) {
1773
return ap_set_wapi_key(ar, ik);
1779
switch (ik->ik_type) {
1780
case IEEE80211_CIPHER_WEP:
1781
keyType = WEP_CRYPT;
1783
case IEEE80211_CIPHER_TKIP:
1784
keyType = TKIP_CRYPT;
1786
case IEEE80211_CIPHER_AES_CCM:
1787
keyType = AES_CRYPT;
1793
ar->user_saved_keys.keyType = keyType;
1795
if (IEEE80211_CIPHER_CCKM_KRK != ik->ik_type) {
1796
if (NONE_CRYPT == keyType) {
1800
if ((WEP_CRYPT == keyType)&&(!ar->arConnected)) {
1801
int index = ik->ik_keyix;
1803
if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(ik->ik_keylen)) {
1807
A_MEMZERO(ar->arWepKeyList[index].arKey,
1808
sizeof(ar->arWepKeyList[index].arKey));
1809
A_MEMCPY(ar->arWepKeyList[index].arKey, ik->ik_keydata, ik->ik_keylen);
1810
ar->arWepKeyList[index].arKeyLen = ik->ik_keylen;
1812
if(ik->ik_flags & IEEE80211_KEY_DEFAULT){
1813
ar->arDefTxKeyIndex = index;
1819
if (((WPA_PSK_AUTH == ar->arAuthMode) || (WPA2_PSK_AUTH == ar->arAuthMode)) &&
1820
(GROUP_USAGE & keyUsage))
1822
A_UNTIMEOUT(&ar->disconnect_timer);
1825
status = wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, keyType, keyUsage,
1826
ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc,
1827
ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
1830
if (status != A_OK) {
1834
status = wmi_add_krk_cmd(ar->arWmi, ik->ik_keydata);
1838
ar->user_saved_keys.keyOk = TRUE;
1844
int ar6000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1846
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1847
HIF_DEVICE *hifDevice = ar->arHifDevice;
1849
unsigned int address = 0;
1850
unsigned int length = 0;
1851
unsigned char *buffer;
1853
A_UINT32 connectCtrlFlags;
1856
WMI_SET_AKMP_PARAMS_CMD akmpParams;
1857
WMI_SET_PMKID_LIST_CMD pmkidInfo;
1859
WMI_SET_HT_CAP_CMD htCap;
1860
WMI_SET_HT_OP_CMD htOp;
1863
* ioctl operations may have to wait for the Target, so we cannot hold rtnl.
1864
* Prevent the device from disappearing under us and release the lock during
1865
* the ioctl operation.
1870
if (cmd == AR6000_IOCTL_EXTENDED) {
1872
* This allows for many more wireless ioctls than would otherwise
1873
* be available. Applications embed the actual ioctl command in
1874
* the first word of the parameter block, and use the command
1875
* AR6000_IOCTL_EXTENDED_CMD on the ioctl call.
1877
if (get_user(cmd, (int *)rq->ifr_data)) {
1881
userdata = (char *)(((unsigned int *)rq->ifr_data)+1);
1882
if(is_xioctl_allowed(ar->arNextMode, cmd) != A_OK) {
1883
A_PRINTF("xioctl: cmd=%d not allowed in this mode\n",cmd);
1888
A_STATUS ret = is_iwioctl_allowed(ar->arNextMode, cmd);
1889
if(ret == A_ENOTSUP) {
1890
A_PRINTF("iwioctl: cmd=0x%x not allowed in this mode\n", cmd);
1893
} else if (ret == A_ERROR) {
1894
/* It is not our ioctl (out of range ioctl) */
1898
userdata = (char *)rq->ifr_data;
1901
if ((ar->arWlanState == WLAN_DISABLED) &&
1902
((cmd != AR6000_XIOCTRL_WMI_SET_WLAN_STATE) &&
1903
(cmd != AR6000_XIOCTL_GET_WLAN_SLEEP_STATE) &&
1904
(cmd != AR6000_XIOCTL_DIAG_READ) &&
1905
(cmd != AR6000_XIOCTL_DIAG_WRITE) &&
1906
(cmd != AR6000_XIOCTL_SET_BT_HW_POWER_STATE) &&
1907
(cmd != AR6000_XIOCTL_GET_BT_HW_POWER_STATE) &&
1908
(cmd != AR6000_XIOCTL_ADD_AP_INTERFACE) &&
1909
(cmd != AR6000_XIOCTL_REMOVE_AP_INTERFACE) &&
1910
(cmd != AR6000_IOCTL_WMI_GETREV)))
1919
case IEEE80211_IOCTL_SETPARAM:
1922
int *ptr = (int *)rq->ifr_ifru.ifru_newname;
1923
if (ar->arWmiReady == FALSE) {
1928
ret = ar6000_ioctl_setparam(ar,param,value);
1932
case IEEE80211_IOCTL_SETKEY:
1934
struct ieee80211req_key keydata;
1935
if (ar->arWmiReady == FALSE) {
1937
} else if (copy_from_user(&keydata, userdata,
1938
sizeof(struct ieee80211req_key))) {
1941
ar6000_ioctl_setkey(ar, &keydata);
1945
case IEEE80211_IOCTL_DELKEY:
1946
case IEEE80211_IOCTL_SETOPTIE:
1951
case IEEE80211_IOCTL_SETMLME:
1953
struct ieee80211req_mlme mlme;
1954
if (ar->arWmiReady == FALSE) {
1956
} else if (copy_from_user(&mlme, userdata,
1957
sizeof(struct ieee80211req_mlme))) {
1960
switch (mlme.im_op) {
1961
case IEEE80211_MLME_AUTHORIZE:
1962
A_PRINTF("setmlme AUTHORIZE %02X:%02X\n",
1963
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1965
case IEEE80211_MLME_UNAUTHORIZE:
1966
A_PRINTF("setmlme UNAUTHORIZE %02X:%02X\n",
1967
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1969
case IEEE80211_MLME_DEAUTH:
1970
A_PRINTF("setmlme DEAUTH %02X:%02X\n",
1971
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1972
//remove_sta(ar, mlme.im_macaddr);
1974
case IEEE80211_MLME_DISASSOC:
1975
A_PRINTF("setmlme DISASSOC %02X:%02X\n",
1976
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1977
//remove_sta(ar, mlme.im_macaddr);
1984
wmi_ap_set_mlme(ar->arWmi, mlme.im_op, mlme.im_macaddr,
1989
case IEEE80211_IOCTL_ADDPMKID:
1991
struct ieee80211req_addpmkid req;
1992
if (ar->arWmiReady == FALSE) {
1994
} else if (copy_from_user(&req, userdata, sizeof(struct ieee80211req_addpmkid))) {
1999
AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("Add pmkid for %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x en=%d\n",
2000
req.pi_bssid[0], req.pi_bssid[1], req.pi_bssid[2],
2001
req.pi_bssid[3], req.pi_bssid[4], req.pi_bssid[5],
2004
status = wmi_setPmkid_cmd(ar->arWmi, req.pi_bssid, req.pi_pmkid,
2007
if (status != A_OK) {
2014
#ifdef CONFIG_HOST_TCMD_SUPPORT
2015
case AR6000_XIOCTL_TCMD_CONT_TX:
2019
if ((ar->tcmdPm == TCMD_PM_SLEEP) ||
2020
(ar->tcmdPm == TCMD_PM_DEEPSLEEP))
2022
A_PRINTF("Can NOT send tx tcmd when target is asleep! \n");
2027
if(copy_from_user(&txCmd, userdata, sizeof(TCMD_CONT_TX))) {
2031
wmi_test_cmd(ar->arWmi,(A_UINT8 *)&txCmd, sizeof(TCMD_CONT_TX));
2035
case AR6000_XIOCTL_TCMD_CONT_RX:
2039
if ((ar->tcmdPm == TCMD_PM_SLEEP) ||
2040
(ar->tcmdPm == TCMD_PM_DEEPSLEEP))
2042
A_PRINTF("Can NOT send rx tcmd when target is asleep! \n");
2046
if(copy_from_user(&rxCmd, userdata, sizeof(TCMD_CONT_RX))) {
2053
case TCMD_CONT_RX_PROMIS:
2054
case TCMD_CONT_RX_FILTER:
2055
case TCMD_CONT_RX_SETMAC:
2056
case TCMD_CONT_RX_SET_ANT_SWITCH_TABLE:
2057
wmi_test_cmd(ar->arWmi,(A_UINT8 *)&rxCmd,
2058
sizeof(TCMD_CONT_RX));
2059
tcmdRxFreq = rxCmd.u.para.freq;
2061
case TCMD_CONT_RX_REPORT:
2062
ar6000_ioctl_tcmd_get_rx_report(dev, rq,
2063
(A_UINT8 *)&rxCmd, sizeof(TCMD_CONT_RX));
2066
A_PRINTF("Unknown Cont Rx mode: %d\n",rxCmd.act);
2072
case AR6000_XIOCTL_TCMD_PM:
2076
if(copy_from_user(&pmCmd, userdata, sizeof(TCMD_PM))) {
2080
ar->tcmdPm = pmCmd.mode;
2081
wmi_test_cmd(ar->arWmi, (A_UINT8*)&pmCmd, sizeof(TCMD_PM));
2084
#endif /* CONFIG_HOST_TCMD_SUPPORT */
2086
case AR6000_XIOCTL_BMI_DONE:
2089
rtnl_lock(); /* ar6000_init expects to be called holding rtnl lock */
2090
ret = ar6000_init(dev);
2095
ret = BMIDone(hifDevice);
2099
case AR6000_XIOCTL_BMI_READ_MEMORY:
2100
if (get_user(address, (unsigned int *)userdata) ||
2101
get_user(length, (unsigned int *)userdata + 1)) {
2106
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Read Memory (address: 0x%x, length: %d)\n",
2108
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2109
A_MEMZERO(buffer, length);
2110
ret = BMIReadMemory(hifDevice, address, buffer, length);
2111
if (copy_to_user(rq->ifr_data, buffer, length)) {
2120
case AR6000_XIOCTL_BMI_WRITE_MEMORY:
2121
if (get_user(address, (unsigned int *)userdata) ||
2122
get_user(length, (unsigned int *)userdata + 1)) {
2126
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Write Memory (address: 0x%x, length: %d)\n",
2128
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2129
A_MEMZERO(buffer, length);
2130
if (copy_from_user(buffer, &userdata[sizeof(address) +
2131
sizeof(length)], length))
2135
ret = BMIWriteMemory(hifDevice, address, buffer, length);
2143
case AR6000_XIOCTL_BMI_TEST:
2144
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("No longer supported\n"));
2148
case AR6000_XIOCTL_BMI_EXECUTE:
2149
if (get_user(address, (unsigned int *)userdata) ||
2150
get_user(param, (unsigned int *)userdata + 1)) {
2154
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Execute (address: 0x%x, param: %d)\n",
2156
ret = BMIExecute(hifDevice, address, (A_UINT32*)¶m);
2158
if (put_user(param, (unsigned int *)rq->ifr_data)) {
2164
case AR6000_XIOCTL_BMI_SET_APP_START:
2165
if (get_user(address, (unsigned int *)userdata)) {
2169
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Set App Start (address: 0x%x)\n", address));
2170
ret = BMISetAppStart(hifDevice, address);
2173
case AR6000_XIOCTL_BMI_READ_SOC_REGISTER:
2174
if (get_user(address, (unsigned int *)userdata)) {
2178
ret = BMIReadSOCRegister(hifDevice, address, (A_UINT32*)¶m);
2180
if (put_user(param, (unsigned int *)rq->ifr_data)) {
2186
case AR6000_XIOCTL_BMI_WRITE_SOC_REGISTER:
2187
if (get_user(address, (unsigned int *)userdata) ||
2188
get_user(param, (unsigned int *)userdata + 1)) {
2192
ret = BMIWriteSOCRegister(hifDevice, address, param);
2195
#ifdef HTC_RAW_INTERFACE
2196
case AR6000_XIOCTL_HTC_RAW_OPEN:
2198
if (!arRawIfEnabled(ar)) {
2199
/* make sure block size is set in case the target was reset since last
2200
* BMI phase (i.e. flashup downloads) */
2201
ret = ar6000_set_htc_params(ar->arHifDevice,
2203
0, /* use default yield */
2204
0 /* use default number of HTC ctrl buffers */
2206
if (A_FAILED(ret)) {
2209
/* Terminate the BMI phase */
2210
ret = BMIDone(hifDevice);
2212
ret = ar6000_htc_raw_open(ar);
2217
case AR6000_XIOCTL_HTC_RAW_CLOSE:
2218
if (arRawIfEnabled(ar)) {
2219
ret = ar6000_htc_raw_close(ar);
2220
arRawIfEnabled(ar) = FALSE;
2226
case AR6000_XIOCTL_HTC_RAW_READ:
2227
if (arRawIfEnabled(ar)) {
2228
unsigned int streamID;
2229
if (get_user(streamID, (unsigned int *)userdata) ||
2230
get_user(length, (unsigned int *)userdata + 1)) {
2234
buffer = (unsigned char*)rq->ifr_data + sizeof(length);
2235
ret = ar6000_htc_raw_read(ar, (HTC_RAW_STREAM_ID)streamID,
2236
(char*)buffer, length);
2237
if (put_user(ret, (unsigned int *)rq->ifr_data)) {
2246
case AR6000_XIOCTL_HTC_RAW_WRITE:
2247
if (arRawIfEnabled(ar)) {
2248
unsigned int streamID;
2249
if (get_user(streamID, (unsigned int *)userdata) ||
2250
get_user(length, (unsigned int *)userdata + 1)) {
2254
buffer = (unsigned char*)userdata + sizeof(streamID) + sizeof(length);
2255
ret = ar6000_htc_raw_write(ar, (HTC_RAW_STREAM_ID)streamID,
2256
(char*)buffer, length);
2257
if (put_user(ret, (unsigned int *)rq->ifr_data)) {
2265
#endif /* HTC_RAW_INTERFACE */
2267
case AR6000_XIOCTL_BMI_LZ_STREAM_START:
2268
if (get_user(address, (unsigned int *)userdata)) {
2272
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Start Compressed Stream (address: 0x%x)\n", address));
2273
ret = BMILZStreamStart(hifDevice, address);
2276
case AR6000_XIOCTL_BMI_LZ_DATA:
2277
if (get_user(length, (unsigned int *)userdata)) {
2281
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Send Compressed Data (length: %d)\n", length));
2282
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2283
A_MEMZERO(buffer, length);
2284
if (copy_from_user(buffer, &userdata[sizeof(length)], length))
2288
ret = BMILZData(hifDevice, buffer, length);
2296
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
2298
* Optional support for Target-side profiling.
2299
* Not needed in production.
2302
/* Configure Target-side profiling */
2303
case AR6000_XIOCTL_PROF_CFG:
2307
if (get_user(period, (unsigned int *)userdata) ||
2308
get_user(nbins, (unsigned int *)userdata + 1)) {
2313
if (wmi_prof_cfg_cmd(ar->arWmi, period, nbins) != A_OK) {
2320
/* Start a profiling bucket/bin at the specified address */
2321
case AR6000_XIOCTL_PROF_ADDR_SET:
2324
if (get_user(addr, (unsigned int *)userdata)) {
2329
if (wmi_prof_addr_set_cmd(ar->arWmi, addr) != A_OK) {
2336
/* START Target-side profiling */
2337
case AR6000_XIOCTL_PROF_START:
2338
wmi_prof_start_cmd(ar->arWmi);
2341
/* STOP Target-side profiling */
2342
case AR6000_XIOCTL_PROF_STOP:
2343
wmi_prof_stop_cmd(ar->arWmi);
2345
case AR6000_XIOCTL_PROF_COUNT_GET:
2347
if (ar->bIsDestroyProgress) {
2351
if (ar->arWmiReady == FALSE) {
2355
if (down_interruptible(&ar->arSem)) {
2359
if (ar->bIsDestroyProgress) {
2365
prof_count_available = FALSE;
2366
ret = prof_count_get(dev);
2373
/* Wait for Target to respond. */
2374
wait_event_interruptible(arEvent, prof_count_available);
2375
if (signal_pending(current)) {
2378
if (copy_to_user(userdata, &prof_count_results,
2379
sizeof(prof_count_results)))
2387
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
2389
case AR6000_IOCTL_WMI_GETREV:
2391
if (copy_to_user(rq->ifr_data, &ar->arVersion,
2392
sizeof(ar->arVersion)))
2398
case AR6000_IOCTL_WMI_SETPWR:
2400
WMI_POWER_MODE_CMD pwrModeCmd;
2402
if (ar->arWmiReady == FALSE) {
2404
} else if (copy_from_user(&pwrModeCmd, userdata,
2405
sizeof(pwrModeCmd)))
2409
if (wmi_powermode_cmd(ar->arWmi, pwrModeCmd.powerMode)
2417
case AR6000_IOCTL_WMI_SET_IBSS_PM_CAPS:
2419
WMI_IBSS_PM_CAPS_CMD ibssPmCaps;
2421
if (ar->arWmiReady == FALSE) {
2423
} else if (copy_from_user(&ibssPmCaps, userdata,
2424
sizeof(ibssPmCaps)))
2428
if (wmi_ibsspmcaps_cmd(ar->arWmi, ibssPmCaps.power_saving, ibssPmCaps.ttl,
2429
ibssPmCaps.atim_windows, ibssPmCaps.timeout_value) != A_OK)
2433
AR6000_SPIN_LOCK(&ar->arLock, 0);
2434
ar->arIbssPsEnable = ibssPmCaps.power_saving;
2435
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2439
case AR6000_XIOCTL_WMI_SET_AP_PS:
2441
WMI_AP_PS_CMD apPsCmd;
2443
if (ar->arWmiReady == FALSE) {
2445
} else if (copy_from_user(&apPsCmd, userdata,
2450
if (wmi_apps_cmd(ar->arWmi, apPsCmd.psType, apPsCmd.idle_time,
2451
apPsCmd.ps_period, apPsCmd.sleep_period) != A_OK)
2458
case AR6000_IOCTL_WMI_SET_PMPARAMS:
2460
WMI_POWER_PARAMS_CMD pmParams;
2462
if (ar->arWmiReady == FALSE) {
2464
} else if (copy_from_user(&pmParams, userdata,
2469
if (wmi_pmparams_cmd(ar->arWmi, pmParams.idle_period,
2470
pmParams.pspoll_number,
2471
pmParams.dtim_policy,
2472
pmParams.tx_wakeup_policy,
2473
pmParams.num_tx_to_wakeup,
2474
#if WLAN_CONFIG_IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN
2475
IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN
2477
SEND_POWER_SAVE_FAIL_EVENT_ALWAYS
2486
case AR6000_IOCTL_WMI_SETSCAN:
2488
if (ar->arWmiReady == FALSE) {
2490
} else if (copy_from_user(&ar->scParams, userdata,
2491
sizeof(ar->scParams)))
2495
if (CAN_SCAN_IN_CONNECT(ar->scParams.scanCtrlFlags)) {
2496
ar->arSkipScan = FALSE;
2498
ar->arSkipScan = TRUE;
2501
if (wmi_scanparams_cmd(ar->arWmi, ar->scParams.fg_start_period,
2502
ar->scParams.fg_end_period,
2503
ar->scParams.bg_period,
2504
ar->scParams.minact_chdwell_time,
2505
ar->scParams.maxact_chdwell_time,
2506
ar->scParams.pas_chdwell_time,
2507
ar->scParams.shortScanRatio,
2508
ar->scParams.scanCtrlFlags,
2509
ar->scParams.max_dfsch_act_time,
2510
ar->scParams.maxact_scan_per_ssid) != A_OK)
2517
case AR6000_IOCTL_WMI_SETLISTENINT:
2519
WMI_LISTEN_INT_CMD listenCmd;
2521
if (ar->arWmiReady == FALSE) {
2523
} else if (copy_from_user(&listenCmd, userdata,
2528
if (wmi_listeninterval_cmd(ar->arWmi, listenCmd.listenInterval, listenCmd.numBeacons) != A_OK) {
2531
AR6000_SPIN_LOCK(&ar->arLock, 0);
2532
ar->arListenIntervalT = listenCmd.listenInterval;
2533
ar->arListenIntervalB = listenCmd.numBeacons;
2534
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2540
case AR6000_IOCTL_WMI_SET_BMISS_TIME:
2542
WMI_BMISS_TIME_CMD bmissCmd;
2544
if (ar->arWmiReady == FALSE) {
2546
} else if (copy_from_user(&bmissCmd, userdata,
2551
if (wmi_bmisstime_cmd(ar->arWmi, bmissCmd.bmissTime, bmissCmd.numBeacons) != A_OK) {
2557
case AR6000_IOCTL_WMI_SETBSSFILTER:
2559
WMI_BSS_FILTER_CMD filt;
2561
if (ar->arWmiReady == FALSE) {
2563
} else if (copy_from_user(&filt, userdata,
2568
if (wmi_bssfilter_cmd(ar->arWmi, filt.bssFilter, filt.ieMask)
2572
ar->arUserBssFilter = param;
2578
case AR6000_IOCTL_WMI_SET_SNRTHRESHOLD:
2580
ret = ar6000_ioctl_set_snr_threshold(dev, rq);
2583
case AR6000_XIOCTL_WMI_SET_RSSITHRESHOLD:
2585
ret = ar6000_ioctl_set_rssi_threshold(dev, rq);
2588
case AR6000_XIOCTL_WMI_CLR_RSSISNR:
2590
if (ar->arWmiReady == FALSE) {
2593
ret = wmi_clr_rssi_snr(ar->arWmi);
2596
case AR6000_XIOCTL_WMI_SET_LQTHRESHOLD:
2598
ret = ar6000_ioctl_set_lq_threshold(dev, rq);
2601
case AR6000_XIOCTL_WMI_SET_LPREAMBLE:
2603
WMI_SET_LPREAMBLE_CMD setLpreambleCmd;
2605
if (ar->arWmiReady == FALSE) {
2607
} else if (copy_from_user(&setLpreambleCmd, userdata,
2608
sizeof(setLpreambleCmd)))
2612
if (wmi_set_lpreamble_cmd(ar->arWmi, setLpreambleCmd.status,
2613
#if WLAN_CONFIG_DONOT_IGNORE_BARKER_IN_ERP
2614
WMI_DONOT_IGNORE_BARKER_IN_ERP
2616
WMI_IGNORE_BARKER_IN_ERP
2626
case AR6000_XIOCTL_WMI_SET_RTS:
2628
WMI_SET_RTS_CMD rtsCmd;
2629
if (ar->arWmiReady == FALSE) {
2631
} else if (copy_from_user(&rtsCmd, userdata,
2636
ar->arRTS = rtsCmd.threshold;
2637
if (wmi_set_rts_cmd(ar->arWmi, rtsCmd.threshold)
2646
case AR6000_XIOCTL_WMI_SET_WMM:
2648
ret = ar6000_ioctl_set_wmm(dev, rq);
2651
case AR6000_XIOCTL_WMI_SET_QOS_SUPP:
2653
ret = ar6000_ioctl_set_qos_supp(dev, rq);
2656
case AR6000_XIOCTL_WMI_SET_TXOP:
2658
ret = ar6000_ioctl_set_txop(dev, rq);
2661
case AR6000_XIOCTL_WMI_GET_RD:
2663
ret = ar6000_ioctl_get_rd(dev, rq);
2666
case AR6000_IOCTL_WMI_SET_CHANNELPARAMS:
2668
ret = ar6000_ioctl_set_channelParams(dev, rq);
2671
case AR6000_IOCTL_WMI_SET_PROBEDSSID:
2673
ret = ar6000_ioctl_set_probedSsid(dev, rq);
2676
case AR6000_IOCTL_WMI_SET_BADAP:
2678
ret = ar6000_ioctl_set_badAp(dev, rq);
2681
case AR6000_IOCTL_WMI_CREATE_QOS:
2683
ret = ar6000_ioctl_create_qos(dev, rq);
2686
case AR6000_IOCTL_WMI_DELETE_QOS:
2688
ret = ar6000_ioctl_delete_qos(dev, rq);
2691
case AR6000_IOCTL_WMI_GET_QOS_QUEUE:
2693
ret = ar6000_ioctl_get_qos_queue(dev, rq);
2696
case AR6000_IOCTL_WMI_GET_TARGET_STATS:
2698
ret = ar6000_ioctl_get_target_stats(dev, rq);
2701
case AR6000_IOCTL_WMI_SET_ERROR_REPORT_BITMASK:
2703
ret = ar6000_ioctl_set_error_report_bitmask(dev, rq);
2706
case AR6000_IOCTL_WMI_SET_ASSOC_INFO:
2708
WMI_SET_ASSOC_INFO_CMD cmd;
2709
A_UINT8 assocInfo[WMI_MAX_ASSOC_INFO_LEN];
2711
if (ar->arWmiReady == FALSE) {
2716
if (get_user(cmd.ieType, userdata)) {
2720
if (cmd.ieType >= WMI_MAX_ASSOC_INFO_TYPE) {
2725
if (get_user(cmd.bufferSize, userdata + 1) ||
2726
(cmd.bufferSize > WMI_MAX_ASSOC_INFO_LEN) ||
2727
copy_from_user(assocInfo, userdata + 2, cmd.bufferSize)) {
2731
if (wmi_associnfo_cmd(ar->arWmi, cmd.ieType,
2732
cmd.bufferSize, assocInfo) != A_OK) {
2738
case AR6000_IOCTL_WMI_SET_ACCESS_PARAMS:
2740
ret = ar6000_ioctl_set_access_params(dev, rq);
2743
case AR6000_IOCTL_WMI_SET_DISC_TIMEOUT:
2745
ret = ar6000_ioctl_set_disconnect_timeout(dev, rq);
2748
case AR6000_XIOCTL_FORCE_TARGET_RESET:
2750
if (ar->arHtcTarget)
2752
// HTCForceReset(htcTarget);
2756
AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("ar6000_ioctl cannot attempt reset.\n"));
2760
case AR6000_XIOCTL_TARGET_INFO:
2761
case AR6000_XIOCTL_CHECK_TARGET_READY: /* backwards compatibility */
2763
/* If we made it to here, then the Target exists and is ready. */
2765
if (cmd == AR6000_XIOCTL_TARGET_INFO) {
2766
if (copy_to_user((A_UINT32 *)rq->ifr_data, &ar->arVersion.target_ver,
2767
sizeof(ar->arVersion.target_ver)))
2771
if (copy_to_user(((A_UINT32 *)rq->ifr_data)+1, &ar->arTargetType,
2772
sizeof(ar->arTargetType)))
2779
case AR6000_XIOCTL_WMI_SET_HB_CHALLENGE_RESP_PARAMS:
2781
WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD hbparam;
2783
if (copy_from_user(&hbparam, userdata, sizeof(hbparam)))
2787
AR6000_SPIN_LOCK(&ar->arLock, 0);
2788
/* Start a cyclic timer with the parameters provided. */
2789
if (hbparam.frequency) {
2790
ar->arHBChallengeResp.frequency = hbparam.frequency;
2792
if (hbparam.threshold) {
2793
ar->arHBChallengeResp.missThres = hbparam.threshold;
2796
/* Delete the pending timer and start a new one */
2797
if (timer_pending(&ar->arHBChallengeResp.timer)) {
2798
A_UNTIMEOUT(&ar->arHBChallengeResp.timer);
2800
A_TIMEOUT_MS(&ar->arHBChallengeResp.timer, ar->arHBChallengeResp.frequency * 1000, 0);
2801
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2805
case AR6000_XIOCTL_WMI_GET_HB_CHALLENGE_RESP:
2809
if (copy_from_user(&cookie, userdata, sizeof(cookie))) {
2814
/* Send the challenge on the control channel */
2815
if (wmi_get_challenge_resp_cmd(ar->arWmi, cookie, APP_HB_CHALLENGE) != A_OK) {
2822
case AR6000_XIOCTL_USER_SETKEYS:
2825
ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_RUN;
2827
if (copy_from_user(&ar->user_key_ctrl, userdata,
2828
sizeof(ar->user_key_ctrl)))
2834
A_PRINTF("ar6000 USER set key %x\n", ar->user_key_ctrl);
2837
#endif /* USER_KEYS */
2839
#ifdef CONFIG_HOST_GPIO_SUPPORT
2840
case AR6000_XIOCTL_GPIO_OUTPUT_SET:
2842
struct ar6000_gpio_output_set_cmd_s gpio_output_set_cmd;
2844
if (ar->bIsDestroyProgress) {
2848
if (ar->arWmiReady == FALSE) {
2852
if (down_interruptible(&ar->arSem)) {
2856
if (ar->bIsDestroyProgress) {
2862
if (copy_from_user(&gpio_output_set_cmd, userdata,
2863
sizeof(gpio_output_set_cmd)))
2867
ret = ar6000_gpio_output_set(dev,
2868
gpio_output_set_cmd.set_mask,
2869
gpio_output_set_cmd.clear_mask,
2870
gpio_output_set_cmd.enable_mask,
2871
gpio_output_set_cmd.disable_mask);
2879
case AR6000_XIOCTL_GPIO_INPUT_GET:
2881
if (ar->bIsDestroyProgress) {
2885
if (ar->arWmiReady == FALSE) {
2889
if (down_interruptible(&ar->arSem)) {
2893
if (ar->bIsDestroyProgress) {
2899
ret = ar6000_gpio_input_get(dev);
2906
/* Wait for Target to respond. */
2907
wait_event_interruptible(arEvent, gpio_data_available);
2908
if (signal_pending(current)) {
2911
A_ASSERT(gpio_reg_results.gpioreg_id == GPIO_ID_NONE);
2913
if (copy_to_user(userdata, &gpio_reg_results.value,
2914
sizeof(gpio_reg_results.value)))
2922
case AR6000_XIOCTL_GPIO_REGISTER_SET:
2924
struct ar6000_gpio_register_cmd_s gpio_register_cmd;
2926
if (ar->bIsDestroyProgress) {
2930
if (ar->arWmiReady == FALSE) {
2934
if (down_interruptible(&ar->arSem)) {
2938
if (ar->bIsDestroyProgress) {
2944
if (copy_from_user(&gpio_register_cmd, userdata,
2945
sizeof(gpio_register_cmd)))
2949
ret = ar6000_gpio_register_set(dev,
2950
gpio_register_cmd.gpioreg_id,
2951
gpio_register_cmd.value);
2956
/* Wait for acknowledgement from Target */
2957
wait_event_interruptible(arEvent, gpio_ack_received);
2958
if (signal_pending(current)) {
2965
case AR6000_XIOCTL_GPIO_REGISTER_GET:
2967
struct ar6000_gpio_register_cmd_s gpio_register_cmd;
2969
if (ar->bIsDestroyProgress) {
2973
if (ar->arWmiReady == FALSE) {
2977
if (down_interruptible(&ar->arSem)) {
2981
if (ar->bIsDestroyProgress) {
2987
if (copy_from_user(&gpio_register_cmd, userdata,
2988
sizeof(gpio_register_cmd)))
2992
ret = ar6000_gpio_register_get(dev, gpio_register_cmd.gpioreg_id);
2999
/* Wait for Target to respond. */
3000
wait_event_interruptible(arEvent, gpio_data_available);
3001
if (signal_pending(current)) {
3004
A_ASSERT(gpio_register_cmd.gpioreg_id == gpio_reg_results.gpioreg_id);
3005
if (copy_to_user(userdata, &gpio_reg_results,
3006
sizeof(gpio_reg_results)))
3015
case AR6000_XIOCTL_GPIO_INTR_ACK:
3017
struct ar6000_gpio_intr_ack_cmd_s gpio_intr_ack_cmd;
3019
if (ar->bIsDestroyProgress) {
3023
if (ar->arWmiReady == FALSE) {
3027
if (down_interruptible(&ar->arSem)) {
3031
if (ar->bIsDestroyProgress) {
3037
if (copy_from_user(&gpio_intr_ack_cmd, userdata,
3038
sizeof(gpio_intr_ack_cmd)))
3042
ret = ar6000_gpio_intr_ack(dev, gpio_intr_ack_cmd.ack_mask);
3050
case AR6000_XIOCTL_GPIO_INTR_WAIT:
3052
/* Wait for Target to report an interrupt. */
3053
wait_event_interruptible(arEvent, gpio_intr_available);
3055
if (signal_pending(current)) {
3058
if (copy_to_user(userdata, &gpio_intr_results,
3059
sizeof(gpio_intr_results)))
3066
#endif /* CONFIG_HOST_GPIO_SUPPORT */
3068
case AR6000_XIOCTL_DBGLOG_CFG_MODULE:
3070
struct ar6000_dbglog_module_config_s config;
3072
if (copy_from_user(&config, userdata, sizeof(config))) {
3077
/* Send the challenge on the control channel */
3078
if (wmi_config_debug_module_cmd(ar->arWmi, config.mmask,
3079
config.tsr, config.rep,
3080
config.size, config.valid) != A_OK)
3088
case AR6000_XIOCTL_DBGLOG_GET_DEBUG_LOGS:
3090
/* Send the challenge on the control channel */
3091
if (ar6000_dbglog_get_debug_logs(ar) != A_OK)
3099
case AR6000_XIOCTL_SET_ADHOC_BSSID:
3101
WMI_SET_ADHOC_BSSID_CMD adhocBssid;
3103
if (ar->arWmiReady == FALSE) {
3105
} else if (copy_from_user(&adhocBssid, userdata,
3106
sizeof(adhocBssid)))
3109
} else if (A_MEMCMP(adhocBssid.bssid, bcast_mac,
3110
AR6000_ETH_ADDR_LEN) == 0)
3115
A_MEMCPY(ar->arReqBssid, adhocBssid.bssid, sizeof(ar->arReqBssid));
3120
case AR6000_XIOCTL_SET_OPT_MODE:
3122
WMI_SET_OPT_MODE_CMD optModeCmd;
3123
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
3125
if (ar->arWmiReady == FALSE) {
3127
} else if (copy_from_user(&optModeCmd, userdata,
3128
sizeof(optModeCmd)))
3131
} else if (ar->arConnected && optModeCmd.optMode == SPECIAL_ON) {
3134
} else if (wmi_set_opt_mode_cmd(ar->arWmi, optModeCmd.optMode)
3142
case AR6000_XIOCTL_OPT_SEND_FRAME:
3144
WMI_OPT_TX_FRAME_CMD optTxFrmCmd;
3145
A_UINT8 data[MAX_OPT_DATA_LEN];
3147
if (ar->arWmiReady == FALSE) {
3149
} else if (copy_from_user(&optTxFrmCmd, userdata,
3150
sizeof(optTxFrmCmd)))
3153
} else if (copy_from_user(data,
3154
userdata+sizeof(WMI_OPT_TX_FRAME_CMD)-1,
3155
optTxFrmCmd.optIEDataLen))
3159
ret = wmi_opt_tx_frame_cmd(ar->arWmi,
3160
optTxFrmCmd.frmType,
3161
optTxFrmCmd.dstAddr,
3163
optTxFrmCmd.optIEDataLen,
3169
case AR6000_XIOCTL_WMI_SETRETRYLIMITS:
3171
WMI_SET_RETRY_LIMITS_CMD setRetryParams;
3173
if (ar->arWmiReady == FALSE) {
3175
} else if (copy_from_user(&setRetryParams, userdata,
3176
sizeof(setRetryParams)))
3180
if (wmi_set_retry_limits_cmd(ar->arWmi, setRetryParams.frameType,
3181
setRetryParams.trafficClass,
3182
setRetryParams.maxRetries,
3183
setRetryParams.enableNotify) != A_OK)
3187
AR6000_SPIN_LOCK(&ar->arLock, 0);
3188
ar->arMaxRetries = setRetryParams.maxRetries;
3189
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3194
case AR6000_XIOCTL_SET_BEACON_INTVAL:
3196
WMI_BEACON_INT_CMD bIntvlCmd;
3198
if (ar->arWmiReady == FALSE) {
3200
} else if (copy_from_user(&bIntvlCmd, userdata,
3204
} else if (wmi_set_adhoc_bconIntvl_cmd(ar->arWmi, bIntvlCmd.beaconInterval)
3210
ar->ap_beacon_interval = bIntvlCmd.beaconInterval;
3211
ar->ap_profile_flag = 1; /* There is a change in profile */
3215
case IEEE80211_IOCTL_SETAUTHALG:
3217
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
3218
struct ieee80211req_authalg req;
3220
if (ar->arWmiReady == FALSE) {
3222
} else if (copy_from_user(&req, userdata,
3223
sizeof(struct ieee80211req_authalg)))
3227
if (req.auth_alg & AUTH_ALG_OPEN_SYSTEM) {
3228
ar->arDot11AuthMode |= OPEN_AUTH;
3229
ar->arPairwiseCrypto = NONE_CRYPT;
3230
ar->arGroupCrypto = NONE_CRYPT;
3232
if (req.auth_alg & AUTH_ALG_SHARED_KEY) {
3233
ar->arDot11AuthMode |= SHARED_AUTH;
3234
ar->arPairwiseCrypto = WEP_CRYPT;
3235
ar->arGroupCrypto = WEP_CRYPT;
3236
ar->arAuthMode = NONE_AUTH;
3238
if (req.auth_alg == AUTH_ALG_LEAP) {
3239
ar->arDot11AuthMode = LEAP_AUTH;
3245
case AR6000_XIOCTL_SET_VOICE_PKT_SIZE:
3246
ret = ar6000_xioctl_set_voice_pkt_size(dev, userdata);
3249
case AR6000_XIOCTL_SET_MAX_SP:
3250
ret = ar6000_xioctl_set_max_sp_len(dev, userdata);
3253
case AR6000_XIOCTL_WMI_GET_ROAM_TBL:
3254
ret = ar6000_ioctl_get_roam_tbl(dev, rq);
3256
case AR6000_XIOCTL_WMI_SET_ROAM_CTRL:
3257
ret = ar6000_ioctl_set_roam_ctrl(dev, userdata);
3259
case AR6000_XIOCTRL_WMI_SET_POWERSAVE_TIMERS:
3260
ret = ar6000_ioctl_set_powersave_timers(dev, userdata);
3262
case AR6000_XIOCTRL_WMI_GET_POWER_MODE:
3263
ret = ar6000_ioctl_get_power_mode(dev, rq);
3265
case AR6000_XIOCTRL_WMI_SET_WLAN_STATE:
3267
AR6000_WLAN_STATE state;
3268
if (get_user(state, (unsigned int *)userdata))
3270
else if (ar6000_set_wlan_state(ar, state) != A_OK)
3274
case AR6000_XIOCTL_WMI_GET_ROAM_DATA:
3275
ret = ar6000_ioctl_get_roam_data(dev, rq);
3278
case AR6000_XIOCTL_WMI_SET_BT_STATUS:
3279
ret = ar6000_xioctl_set_bt_status_cmd(dev, userdata);
3282
case AR6000_XIOCTL_WMI_SET_BT_PARAMS:
3283
ret = ar6000_xioctl_set_bt_params_cmd(dev, userdata);
3286
case AR6000_XIOCTL_WMI_SET_BTCOEX_FE_ANT:
3287
ret = ar6000_xioctl_set_btcoex_fe_ant_cmd(dev, userdata);
3290
case AR6000_XIOCTL_WMI_SET_BTCOEX_COLOCATED_BT_DEV:
3291
ret = ar6000_xioctl_set_btcoex_colocated_bt_dev_cmd(dev, userdata);
3294
case AR6000_XIOCTL_WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG:
3295
ret = ar6000_xioctl_set_btcoex_btinquiry_page_config_cmd(dev, userdata);
3298
case AR6000_XIOCTL_WMI_SET_BTCOEX_SCO_CONFIG:
3299
ret = ar6000_xioctl_set_btcoex_sco_config_cmd( dev, userdata);
3302
case AR6000_XIOCTL_WMI_SET_BTCOEX_A2DP_CONFIG:
3303
ret = ar6000_xioctl_set_btcoex_a2dp_config_cmd(dev, userdata);
3306
case AR6000_XIOCTL_WMI_SET_BTCOEX_ACLCOEX_CONFIG:
3307
ret = ar6000_xioctl_set_btcoex_aclcoex_config_cmd(dev, userdata);
3310
case AR6000_XIOCTL_WMI_SET_BTCOEX_DEBUG:
3311
ret = ar60000_xioctl_set_btcoex_debug_cmd(dev, userdata);
3314
case AR6000_XIOCTL_WMI_SET_BT_OPERATING_STATUS:
3315
ret = ar6000_xioctl_set_btcoex_bt_operating_status_cmd(dev, userdata);
3318
case AR6000_XIOCTL_WMI_GET_BTCOEX_CONFIG:
3319
ret = ar6000_xioctl_get_btcoex_config_cmd(dev, userdata, rq);
3322
case AR6000_XIOCTL_WMI_GET_BTCOEX_STATS:
3323
ret = ar6000_xioctl_get_btcoex_stats_cmd(dev, userdata, rq);
3326
case AR6000_XIOCTL_WMI_STARTSCAN:
3328
WMI_START_SCAN_CMD setStartScanCmd, *cmdp;
3330
if (ar->arWmiReady == FALSE) {
3332
} else if (copy_from_user(&setStartScanCmd, userdata,
3333
sizeof(setStartScanCmd)))
3337
if (setStartScanCmd.numChannels > 1) {
3338
cmdp = A_MALLOC(130);
3339
if (copy_from_user(cmdp, userdata,
3341
((setStartScanCmd.numChannels - 1) *
3349
cmdp = &setStartScanCmd;
3352
if (wmi_startscan_cmd(ar->arWmi, cmdp->scanType,
3355
cmdp->homeDwellTime,
3356
cmdp->forceScanInterval,
3358
cmdp->channelList) != A_OK)
3365
case AR6000_XIOCTL_WMI_SETFIXRATES:
3367
WMI_FIX_RATES_CMD setFixRatesCmd;
3368
A_STATUS returnStatus;
3370
if (ar->arWmiReady == FALSE) {
3372
} else if (copy_from_user(&setFixRatesCmd, userdata,
3373
sizeof(setFixRatesCmd)))
3377
returnStatus = wmi_set_fixrates_cmd(ar->arWmi, setFixRatesCmd.fixRateMask);
3378
if (returnStatus == A_EINVAL) {
3380
} else if(returnStatus != A_OK) {
3383
ar->ap_profile_flag = 1; /* There is a change in profile */
3389
case AR6000_XIOCTL_WMI_GETFIXRATES:
3391
WMI_FIX_RATES_CMD getFixRatesCmd;
3392
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
3395
if (ar->bIsDestroyProgress) {
3399
if (ar->arWmiReady == FALSE) {
3404
if (down_interruptible(&ar->arSem)) {
3408
if (ar->bIsDestroyProgress) {
3413
/* Used copy_from_user/copy_to_user to access user space data */
3414
if (copy_from_user(&getFixRatesCmd, userdata, sizeof(getFixRatesCmd))) {
3417
ar->arRateMask = 0xFFFFFFFF;
3419
if (wmi_get_ratemask_cmd(ar->arWmi) != A_OK) {
3425
wait_event_interruptible_timeout(arEvent, ar->arRateMask != 0xFFFFFFFF, wmitimeout * HZ);
3427
if (signal_pending(current)) {
3432
getFixRatesCmd.fixRateMask = ar->arRateMask;
3435
if(copy_to_user(userdata, &getFixRatesCmd, sizeof(getFixRatesCmd))) {
3443
case AR6000_XIOCTL_WMI_SET_AUTHMODE:
3445
WMI_SET_AUTH_MODE_CMD setAuthMode;
3447
if (ar->arWmiReady == FALSE) {
3449
} else if (copy_from_user(&setAuthMode, userdata,
3450
sizeof(setAuthMode)))
3454
if (wmi_set_authmode_cmd(ar->arWmi, setAuthMode.mode) != A_OK)
3461
case AR6000_XIOCTL_WMI_SET_REASSOCMODE:
3463
WMI_SET_REASSOC_MODE_CMD setReassocMode;
3465
if (ar->arWmiReady == FALSE) {
3467
} else if (copy_from_user(&setReassocMode, userdata,
3468
sizeof(setReassocMode)))
3472
if (wmi_set_reassocmode_cmd(ar->arWmi, setReassocMode.mode) != A_OK)
3479
case AR6000_XIOCTL_DIAG_READ:
3481
A_UINT32 addr, data;
3482
if (get_user(addr, (unsigned int *)userdata)) {
3486
addr = TARG_VTOP(ar->arTargetType, addr);
3487
if (ar6000_ReadRegDiag(ar->arHifDevice, &addr, &data) != A_OK) {
3490
if (put_user(data, (unsigned int *)userdata + 1)) {
3496
case AR6000_XIOCTL_DIAG_WRITE:
3498
A_UINT32 addr, data;
3499
if (get_user(addr, (unsigned int *)userdata) ||
3500
get_user(data, (unsigned int *)userdata + 1)) {
3504
addr = TARG_VTOP(ar->arTargetType, addr);
3505
if (ar6000_WriteRegDiag(ar->arHifDevice, &addr, &data) != A_OK) {
3510
case AR6000_XIOCTL_WMI_SET_KEEPALIVE:
3512
WMI_SET_KEEPALIVE_CMD setKeepAlive;
3513
if (ar->arWmiReady == FALSE) {
3516
} else if (copy_from_user(&setKeepAlive, userdata,
3517
sizeof(setKeepAlive))){
3520
if (wmi_set_keepalive_cmd(ar->arWmi, setKeepAlive.keepaliveInterval) != A_OK) {
3526
case AR6000_XIOCTL_WMI_SET_PARAMS:
3528
WMI_SET_PARAMS_CMD cmd;
3529
if (ar->arWmiReady == FALSE) {
3532
} else if (copy_from_user(&cmd, userdata,
3535
} else if (copy_from_user(&cmd, userdata,
3536
sizeof(cmd) + cmd.length))
3540
if (wmi_set_params_cmd(ar->arWmi, cmd.opcode, cmd.length, cmd.buffer) != A_OK) {
3546
case AR6000_XIOCTL_WMI_SET_MCAST_FILTER:
3548
WMI_SET_MCAST_FILTER_CMD cmd;
3549
if (ar->arWmiReady == FALSE) {
3552
} else if (copy_from_user(&cmd, userdata,
3556
if (wmi_set_mcast_filter_cmd(ar->arWmi, cmd.multicast_mac[0],
3557
cmd.multicast_mac[1],
3558
cmd.multicast_mac[2],
3559
cmd.multicast_mac[3]) != A_OK) {
3565
case AR6000_XIOCTL_WMI_DEL_MCAST_FILTER:
3567
WMI_SET_MCAST_FILTER_CMD cmd;
3568
if (ar->arWmiReady == FALSE) {
3571
} else if (copy_from_user(&cmd, userdata,
3575
if (wmi_del_mcast_filter_cmd(ar->arWmi, cmd.multicast_mac[0],
3576
cmd.multicast_mac[1],
3577
cmd.multicast_mac[2],
3578
cmd.multicast_mac[3]) != A_OK) {
3584
case AR6000_XIOCTL_WMI_MCAST_FILTER:
3586
WMI_MCAST_FILTER_CMD cmd;
3587
if (ar->arWmiReady == FALSE) {
3590
} else if (copy_from_user(&cmd, userdata,
3594
if (wmi_mcast_filter_cmd(ar->arWmi, cmd.enable) != A_OK) {
3600
case AR6000_XIOCTL_WMI_GET_KEEPALIVE:
3602
AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
3603
WMI_GET_KEEPALIVE_CMD getKeepAlive;
3605
if (ar->bIsDestroyProgress) {
3609
if (ar->arWmiReady == FALSE) {
3613
if (down_interruptible(&ar->arSem)) {
3617
if (ar->bIsDestroyProgress) {
3622
if (copy_from_user(&getKeepAlive, userdata,sizeof(getKeepAlive))) {
3625
getKeepAlive.keepaliveInterval = wmi_get_keepalive_cmd(ar->arWmi);
3626
ar->arKeepaliveConfigured = 0xFF;
3627
if (wmi_get_keepalive_configured(ar->arWmi) != A_OK){
3632
wait_event_interruptible_timeout(arEvent, ar->arKeepaliveConfigured != 0xFF, wmitimeout * HZ);
3633
if (signal_pending(current)) {
3638
getKeepAlive.configured = ar->arKeepaliveConfigured;
3640
if (copy_to_user(userdata, &getKeepAlive, sizeof(getKeepAlive))) {
3647
case AR6000_XIOCTL_WMI_SET_APPIE:
3649
WMI_SET_APPIE_CMD appIEcmd;
3650
A_UINT8 appIeInfo[IEEE80211_APPIE_FRAME_MAX_LEN];
3651
A_UINT32 fType,ieLen;
3653
if (ar->arWmiReady == FALSE) {
3657
if (get_user(fType, (A_UINT32 *)userdata)) {
3661
appIEcmd.mgmtFrmType = fType;
3662
if (appIEcmd.mgmtFrmType >= IEEE80211_APPIE_NUM_OF_FRAME) {
3665
if (get_user(ieLen, (A_UINT32 *)(userdata + 4))) {
3669
appIEcmd.ieLen = ieLen;
3670
A_PRINTF("WPSIE: Type-%d, Len-%d\n",appIEcmd.mgmtFrmType, appIEcmd.ieLen);
3671
if (appIEcmd.ieLen > IEEE80211_APPIE_FRAME_MAX_LEN) {
3675
if (copy_from_user(appIeInfo, userdata + 8, appIEcmd.ieLen)) {
3678
if (wmi_set_appie_cmd(ar->arWmi, appIEcmd.mgmtFrmType,
3679
appIEcmd.ieLen, appIeInfo) != A_OK)
3687
case AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER:
3689
WMI_BSS_FILTER_CMD cmd;
3690
A_UINT32 filterType;
3692
if (copy_from_user(&filterType, userdata, sizeof(A_UINT32)))
3697
if (filterType & (IEEE80211_FILTER_TYPE_BEACON |
3698
IEEE80211_FILTER_TYPE_PROBE_RESP))
3700
cmd.bssFilter = ALL_BSS_FILTER;
3702
cmd.bssFilter = NONE_BSS_FILTER;
3704
if (wmi_bssfilter_cmd(ar->arWmi, cmd.bssFilter, 0) != A_OK) {
3707
ar->arUserBssFilter = cmd.bssFilter;
3710
AR6000_SPIN_LOCK(&ar->arLock, 0);
3711
ar->arMgmtFilter = filterType;
3712
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3715
case AR6000_XIOCTL_WMI_SET_WSC_STATUS:
3717
A_UINT32 wsc_status;
3719
if (ar->arWmiReady == FALSE) {
3722
} else if (copy_from_user(&wsc_status, userdata, sizeof(A_UINT32)))
3727
if (wmi_set_wsc_status_cmd(ar->arWmi, wsc_status) != A_OK) {
3732
case AR6000_XIOCTL_BMI_ROMPATCH_INSTALL:
3737
A_UINT32 do_activate;
3738
A_UINT32 rompatch_id;
3740
if (get_user(ROM_addr, (A_UINT32 *)userdata) ||
3741
get_user(RAM_addr, (A_UINT32 *)userdata + 1) ||
3742
get_user(nbytes, (A_UINT32 *)userdata + 2) ||
3743
get_user(do_activate, (A_UINT32 *)userdata + 3)) {
3747
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Install rompatch from ROM: 0x%x to RAM: 0x%x length: %d\n",
3748
ROM_addr, RAM_addr, nbytes));
3749
ret = BMIrompatchInstall(hifDevice, ROM_addr, RAM_addr,
3750
nbytes, do_activate, &rompatch_id);
3753
if (put_user(rompatch_id, (unsigned int *)rq->ifr_data)) {
3761
case AR6000_XIOCTL_BMI_ROMPATCH_UNINSTALL:
3763
A_UINT32 rompatch_id;
3765
if (get_user(rompatch_id, (A_UINT32 *)userdata)) {
3769
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("UNinstall rompatch_id %d\n", rompatch_id));
3770
ret = BMIrompatchUninstall(hifDevice, rompatch_id);
3774
case AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE:
3775
case AR6000_XIOCTL_BMI_ROMPATCH_DEACTIVATE:
3777
A_UINT32 rompatch_count;
3779
if (get_user(rompatch_count, (A_UINT32 *)userdata)) {
3783
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Change rompatch activation count=%d\n", rompatch_count));
3784
length = sizeof(A_UINT32) * rompatch_count;
3785
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
3786
A_MEMZERO(buffer, length);
3787
if (copy_from_user(buffer, &userdata[sizeof(rompatch_count)], length))
3791
if (cmd == AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE) {
3792
ret = BMIrompatchActivate(hifDevice, rompatch_count, (A_UINT32 *)buffer);
3794
ret = BMIrompatchDeactivate(hifDevice, rompatch_count, (A_UINT32 *)buffer);
3804
case AR6000_XIOCTL_SET_IP:
3806
WMI_SET_IP_CMD setIP;
3808
if (ar->arWmiReady == FALSE) {
3810
} else if (copy_from_user(&setIP, userdata,
3815
if (wmi_set_ip_cmd(ar->arWmi,
3824
case AR6000_XIOCTL_WMI_SET_HOST_SLEEP_MODE:
3826
WMI_SET_HOST_SLEEP_MODE_CMD setHostSleepMode;
3828
if (ar->arWmiReady == FALSE) {
3830
} else if (copy_from_user(&setHostSleepMode, userdata,
3831
sizeof(setHostSleepMode)))
3835
if (wmi_set_host_sleep_mode_cmd(ar->arWmi,
3836
&setHostSleepMode) != A_OK)
3843
case AR6000_XIOCTL_WMI_SET_WOW_MODE:
3845
WMI_SET_WOW_MODE_CMD setWowMode;
3847
if (ar->arWmiReady == FALSE) {
3849
} else if (copy_from_user(&setWowMode, userdata,
3850
sizeof(setWowMode)))
3854
if (wmi_set_wow_mode_cmd(ar->arWmi,
3855
&setWowMode) != A_OK)
3862
case AR6000_XIOCTL_WMI_GET_WOW_LIST:
3864
WMI_GET_WOW_LIST_CMD getWowList;
3866
if (ar->arWmiReady == FALSE) {
3868
} else if (copy_from_user(&getWowList, userdata,
3869
sizeof(getWowList)))
3873
if (wmi_get_wow_list_cmd(ar->arWmi,
3874
&getWowList) != A_OK)
3881
case AR6000_XIOCTL_WMI_ADD_WOW_PATTERN:
3883
#define WOW_PATTERN_SIZE 64
3884
#define WOW_MASK_SIZE 64
3886
WMI_ADD_WOW_PATTERN_CMD cmd;
3887
A_UINT8 mask_data[WOW_PATTERN_SIZE]={0};
3888
A_UINT8 pattern_data[WOW_PATTERN_SIZE]={0};
3891
if (ar->arWmiReady == FALSE) {
3895
if(copy_from_user(&cmd, userdata,
3896
sizeof(WMI_ADD_WOW_PATTERN_CMD)))
3901
if (copy_from_user(pattern_data,
3908
if (copy_from_user(mask_data,
3909
(userdata + 3 + cmd.filter_size),
3915
if (wmi_add_wow_pattern_cmd(ar->arWmi,
3916
&cmd, pattern_data, mask_data, cmd.filter_size) != A_OK)
3921
#undef WOW_PATTERN_SIZE
3922
#undef WOW_MASK_SIZE
3925
case AR6000_XIOCTL_WMI_DEL_WOW_PATTERN:
3927
WMI_DEL_WOW_PATTERN_CMD delWowPattern;
3929
if (ar->arWmiReady == FALSE) {
3931
} else if (copy_from_user(&delWowPattern, userdata,
3932
sizeof(delWowPattern)))
3936
if (wmi_del_wow_pattern_cmd(ar->arWmi,
3937
&delWowPattern) != A_OK)
3944
case AR6000_XIOCTL_DUMP_HTC_CREDIT_STATE:
3945
if (ar->arHtcTarget != NULL) {
3946
#ifdef ATH_DEBUG_MODULE
3947
HTCDumpCreditStates(ar->arHtcTarget);
3948
#endif /* ATH_DEBUG_MODULE */
3949
#ifdef HTC_EP_STAT_PROFILING
3951
HTC_ENDPOINT_STATS stats;
3954
for (i = 0; i < 5; i++) {
3955
if (HTCGetEndpointStatistics(ar->arHtcTarget,
3957
HTC_EP_STAT_SAMPLE_AND_CLEAR,
3959
A_PRINTF(KERN_ALERT"------- Profiling Endpoint : %d \n", i);
3960
A_PRINTF(KERN_ALERT"TxCreditLowIndications : %d \n", stats.TxCreditLowIndications);
3961
A_PRINTF(KERN_ALERT"TxIssued : %d \n", stats.TxIssued);
3962
A_PRINTF(KERN_ALERT"TxDropped: %d \n", stats.TxDropped);
3963
A_PRINTF(KERN_ALERT"TxPacketsBundled : %d \n", stats.TxPacketsBundled);
3964
A_PRINTF(KERN_ALERT"TxBundles : %d \n", stats.TxBundles);
3965
A_PRINTF(KERN_ALERT"TxCreditRpts : %d \n", stats.TxCreditRpts);
3966
A_PRINTF(KERN_ALERT"TxCreditsRptsFromRx : %d \n", stats.TxCreditRptsFromRx);
3967
A_PRINTF(KERN_ALERT"TxCreditsRptsFromOther : %d \n", stats.TxCreditRptsFromOther);
3968
A_PRINTF(KERN_ALERT"TxCreditsRptsFromEp0 : %d \n", stats.TxCreditRptsFromEp0);
3969
A_PRINTF(KERN_ALERT"TxCreditsFromRx : %d \n", stats.TxCreditsFromRx);
3970
A_PRINTF(KERN_ALERT"TxCreditsFromOther : %d \n", stats.TxCreditsFromOther);
3971
A_PRINTF(KERN_ALERT"TxCreditsFromEp0 : %d \n", stats.TxCreditsFromEp0);
3972
A_PRINTF(KERN_ALERT"TxCreditsConsummed : %d \n", stats.TxCreditsConsummed);
3973
A_PRINTF(KERN_ALERT"TxCreditsReturned : %d \n", stats.TxCreditsReturned);
3974
A_PRINTF(KERN_ALERT"RxReceived : %d \n", stats.RxReceived);
3975
A_PRINTF(KERN_ALERT"RxPacketsBundled : %d \n", stats.RxPacketsBundled);
3976
A_PRINTF(KERN_ALERT"RxLookAheads : %d \n", stats.RxLookAheads);
3977
A_PRINTF(KERN_ALERT"RxBundleLookAheads : %d \n", stats.RxBundleLookAheads);
3978
A_PRINTF(KERN_ALERT"RxBundleIndFromHdr : %d \n", stats.RxBundleIndFromHdr);
3979
A_PRINTF(KERN_ALERT"RxAllocThreshHit : %d \n", stats.RxAllocThreshHit);
3980
A_PRINTF(KERN_ALERT"RxAllocThreshBytes : %d \n", stats.RxAllocThreshBytes);
3981
A_PRINTF(KERN_ALERT"---- \n");
3989
case AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE:
3990
if (ar->arHtcTarget != NULL) {
3991
struct ar6000_traffic_activity_change data;
3993
if (copy_from_user(&data, userdata, sizeof(data)))
3998
/* note, this is used for testing (mbox ping testing), indicate activity
3999
* change using the stream ID as the traffic class */
4000
ar6000_indicate_tx_activity(ar,
4001
(A_UINT8)data.StreamID,
4002
data.Active ? TRUE : FALSE);
4005
case AR6000_XIOCTL_WMI_SET_CONNECT_CTRL_FLAGS:
4006
if (ar->arWmiReady == FALSE) {
4008
} else if (copy_from_user(&connectCtrlFlags, userdata,
4009
sizeof(connectCtrlFlags)))
4013
ar->arConnectCtrlFlags = connectCtrlFlags;
4016
case AR6000_XIOCTL_WMI_SET_AKMP_PARAMS:
4017
if (ar->arWmiReady == FALSE) {
4019
} else if (copy_from_user(&akmpParams, userdata,
4020
sizeof(WMI_SET_AKMP_PARAMS_CMD)))
4024
if (wmi_set_akmp_params_cmd(ar->arWmi, &akmpParams) != A_OK) {
4029
case AR6000_XIOCTL_WMI_SET_PMKID_LIST:
4030
if (ar->arWmiReady == FALSE) {
4033
if (copy_from_user(&pmkidInfo.numPMKID, userdata,
4034
sizeof(pmkidInfo.numPMKID)))
4039
if (copy_from_user(&pmkidInfo.pmkidList,
4040
userdata + sizeof(pmkidInfo.numPMKID),
4041
pmkidInfo.numPMKID * sizeof(WMI_PMKID)))
4046
if (wmi_set_pmkid_list_cmd(ar->arWmi, &pmkidInfo) != A_OK) {
4051
case AR6000_XIOCTL_WMI_GET_PMKID_LIST:
4052
if (ar->arWmiReady == FALSE) {
4055
if (wmi_get_pmkid_list_cmd(ar->arWmi) != A_OK) {
4060
case AR6000_XIOCTL_WMI_ABORT_SCAN:
4061
if (ar->arWmiReady == FALSE) {
4064
ret = wmi_abort_scan_cmd(ar->arWmi);
4066
case AR6000_XIOCTL_AP_HIDDEN_SSID:
4068
A_UINT8 hidden_ssid;
4069
if (ar->arWmiReady == FALSE) {
4071
} else if (copy_from_user(&hidden_ssid, userdata, sizeof(hidden_ssid))) {
4074
wmi_ap_set_hidden_ssid(ar->arWmi, hidden_ssid);
4075
ar->ap_hidden_ssid = hidden_ssid;
4076
ar->ap_profile_flag = 1; /* There is a change in profile */
4080
case AR6000_XIOCTL_AP_GET_STA_LIST:
4082
if (ar->arWmiReady == FALSE) {
4087
A_MEMZERO(&temp, sizeof(temp));
4088
for(i=0;i<AP_MAX_NUM_STA;i++) {
4089
A_MEMCPY(temp.sta[i].mac, ar->sta_list[i].mac, ATH_MAC_LEN);
4090
temp.sta[i].aid = ar->sta_list[i].aid;
4091
temp.sta[i].keymgmt = ar->sta_list[i].keymgmt;
4092
temp.sta[i].ucipher = ar->sta_list[i].ucipher;
4093
temp.sta[i].auth = ar->sta_list[i].auth;
4095
if(copy_to_user((ap_get_sta_t *)rq->ifr_data, &temp,
4096
sizeof(ar->sta_list))) {
4102
case AR6000_XIOCTL_AP_SET_NUM_STA:
4105
if (ar->arWmiReady == FALSE) {
4107
} else if (copy_from_user(&num_sta, userdata, sizeof(num_sta))) {
4109
} else if(num_sta > AP_MAX_NUM_STA) {
4110
/* value out of range */
4113
wmi_ap_set_num_sta(ar->arWmi, num_sta);
4117
case AR6000_XIOCTL_AP_SET_ACL_POLICY:
4120
if (ar->arWmiReady == FALSE) {
4122
} else if (copy_from_user(&policy, userdata, sizeof(policy))) {
4124
} else if(policy == ar->g_acl.policy) {
4125
/* No change in policy */
4127
if(!(policy & AP_ACL_RETAIN_LIST_MASK)) {
4128
/* clear ACL list */
4129
memset(&ar->g_acl,0,sizeof(WMI_AP_ACL));
4131
ar->g_acl.policy = policy;
4132
wmi_ap_set_acl_policy(ar->arWmi, policy);
4136
case AR6000_XIOCTL_AP_SET_ACL_MAC:
4138
WMI_AP_ACL_MAC_CMD acl;
4139
if (ar->arWmiReady == FALSE) {
4141
} else if (copy_from_user(&acl, userdata, sizeof(acl))) {
4144
if(acl_add_del_mac(&ar->g_acl, &acl)) {
4145
wmi_ap_acl_mac_list(ar->arWmi, &acl);
4147
A_PRINTF("ACL list error\n");
4153
case AR6000_XIOCTL_AP_GET_ACL_LIST:
4155
if (ar->arWmiReady == FALSE) {
4157
} else if(copy_to_user((WMI_AP_ACL *)rq->ifr_data, &ar->g_acl,
4158
sizeof(WMI_AP_ACL))) {
4163
case AR6000_XIOCTL_AP_COMMIT_CONFIG:
4165
ret = ar6000_ap_mode_profile_commit(ar);
4168
case IEEE80211_IOCTL_GETWPAIE:
4170
struct ieee80211req_wpaie wpaie;
4171
if (ar->arWmiReady == FALSE) {
4173
} else if (copy_from_user(&wpaie, userdata, sizeof(wpaie))) {
4175
} else if (ar6000_ap_mode_get_wpa_ie(ar, &wpaie)) {
4177
} else if(copy_to_user(userdata, &wpaie, sizeof(wpaie))) {
4182
case AR6000_XIOCTL_AP_CONN_INACT_TIME:
4185
if (ar->arWmiReady == FALSE) {
4187
} else if (copy_from_user(&period, userdata, sizeof(period))) {
4190
wmi_ap_conn_inact_time(ar->arWmi, period);
4194
case AR6000_XIOCTL_AP_PROT_SCAN_TIME:
4196
WMI_AP_PROT_SCAN_TIME_CMD bgscan;
4197
if (ar->arWmiReady == FALSE) {
4199
} else if (copy_from_user(&bgscan, userdata, sizeof(bgscan))) {
4202
wmi_ap_bgscan_time(ar->arWmi, bgscan.period_min, bgscan.dwell_ms);
4206
case AR6000_XIOCTL_AP_SET_COUNTRY:
4208
ret = ar6000_ioctl_set_country(dev, rq);
4211
case AR6000_XIOCTL_AP_SET_DTIM:
4213
WMI_AP_SET_DTIM_CMD d;
4214
if (ar->arWmiReady == FALSE) {
4216
} else if (copy_from_user(&d, userdata, sizeof(d))) {
4219
if(d.dtim > 0 && d.dtim < 11) {
4220
ar->ap_dtim_period = d.dtim;
4221
wmi_ap_set_dtim(ar->arWmi, d.dtim);
4222
ar->ap_profile_flag = 1; /* There is a change in profile */
4224
A_PRINTF("DTIM out of range. Valid range is [1-10]\n");
4230
case AR6000_XIOCTL_WMI_TARGET_EVENT_REPORT:
4232
WMI_SET_TARGET_EVENT_REPORT_CMD evtCfgCmd;
4234
if (ar->arWmiReady == FALSE) {
4237
if (copy_from_user(&evtCfgCmd, userdata,
4238
sizeof(evtCfgCmd))) {
4242
ret = wmi_set_target_event_report_cmd(ar->arWmi, &evtCfgCmd);
4245
case AR6000_XIOCTL_AP_INTRA_BSS_COMM:
4248
if (ar->arWmiReady == FALSE) {
4250
} else if (copy_from_user(&intra, userdata, sizeof(intra))) {
4253
ar->intra_bss = (intra?1:0);
4257
case AR6000_XIOCTL_DUMP_MODULE_DEBUG_INFO:
4259
struct drv_debug_module_s moduleinfo;
4261
if (copy_from_user(&moduleinfo, userdata, sizeof(moduleinfo))) {
4266
a_dump_module_debug_info_by_name(moduleinfo.modulename);
4270
case AR6000_XIOCTL_MODULE_DEBUG_SET_MASK:
4272
struct drv_debug_module_s moduleinfo;
4274
if (copy_from_user(&moduleinfo, userdata, sizeof(moduleinfo))) {
4279
if (A_FAILED(a_set_module_mask(moduleinfo.modulename, moduleinfo.mask))) {
4285
case AR6000_XIOCTL_MODULE_DEBUG_GET_MASK:
4287
struct drv_debug_module_s moduleinfo;
4289
if (copy_from_user(&moduleinfo, userdata, sizeof(moduleinfo))) {
4294
if (A_FAILED(a_get_module_mask(moduleinfo.modulename, &moduleinfo.mask))) {
4299
if (copy_to_user(userdata, &moduleinfo, sizeof(moduleinfo))) {
4306
#ifdef ATH_AR6K_11N_SUPPORT
4307
case AR6000_XIOCTL_DUMP_RCV_AGGR_STATS:
4309
PACKET_LOG *copy_of_pkt_log;
4311
aggr_dump_stats(ar->aggr_cntxt, ©_of_pkt_log);
4312
if (copy_to_user(rq->ifr_data, copy_of_pkt_log, sizeof(PACKET_LOG))) {
4317
case AR6000_XIOCTL_SETUP_AGGR:
4319
WMI_ADDBA_REQ_CMD cmd;
4321
if (ar->arWmiReady == FALSE) {
4323
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4326
wmi_setup_aggr_cmd(ar->arWmi, cmd.tid);
4331
case AR6000_XIOCTL_DELE_AGGR:
4333
WMI_DELBA_REQ_CMD cmd;
4335
if (ar->arWmiReady == FALSE) {
4337
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4340
wmi_delete_aggr_cmd(ar->arWmi, cmd.tid, cmd.is_sender_initiator);
4345
case AR6000_XIOCTL_ALLOW_AGGR:
4347
WMI_ALLOW_AGGR_CMD cmd;
4349
if (ar->arWmiReady == FALSE) {
4351
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4354
wmi_allow_aggr_cmd(ar->arWmi, cmd.tx_allow_aggr, cmd.rx_allow_aggr);
4359
case AR6000_XIOCTL_SET_HT_CAP:
4361
if (ar->arWmiReady == FALSE) {
4363
} else if (copy_from_user(&htCap, userdata,
4369
if (wmi_set_ht_cap_cmd(ar->arWmi, &htCap) != A_OK)
4376
case AR6000_XIOCTL_SET_HT_OP:
4378
if (ar->arWmiReady == FALSE) {
4380
} else if (copy_from_user(&htOp, userdata,
4386
if (wmi_set_ht_op_cmd(ar->arWmi, htOp.sta_chan_width) != A_OK)
4394
case AR6000_XIOCTL_ACL_DATA:
4397
if (ar->arWmiReady == FALSE) {
4399
} else if (ar6000_create_acl_data_osbuf(dev, (A_UINT8*)userdata, &osbuf) != A_OK) {
4402
if (wmi_data_hdr_add(ar->arWmi, osbuf, DATA_MSGTYPE, 0, WMI_DATA_HDR_DATA_TYPE_ACL,0,NULL) != A_OK) {
4403
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("XIOCTL_ACL_DATA - wmi_data_hdr_add failed\n"));
4405
/* Send data buffer over HTC */
4406
ar6000_acl_data_tx(osbuf, ar->arNetDev);
4411
case AR6000_XIOCTL_HCI_CMD:
4415
WMI_HCI_CMD *cmd = (WMI_HCI_CMD *)tmp_buf;
4418
size = sizeof(cmd->cmd_buf_sz);
4419
if (ar->arWmiReady == FALSE) {
4421
} else if (copy_from_user(cmd, userdata, size)) {
4423
} else if(copy_from_user(cmd->buf, userdata + size, cmd->cmd_buf_sz)) {
4426
if (wmi_send_hci_cmd(ar->arWmi, cmd->buf, cmd->cmd_buf_sz) != A_OK) {
4429
A_PRINTF_LOG("HCI Command To PAL --> \n");
4430
for(i = 0; i < cmd->cmd_buf_sz; i++) {
4431
A_PRINTF_LOG("0x%02x ",cmd->buf[i]);
4437
A_PRINTF_LOG("==================================\n");
4442
case AR6000_XIOCTL_WLAN_CONN_PRECEDENCE:
4444
WMI_SET_BT_WLAN_CONN_PRECEDENCE cmd;
4445
if (ar->arWmiReady == FALSE) {
4447
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4450
if (cmd.precedence == BT_WLAN_CONN_PRECDENCE_WLAN ||
4451
cmd.precedence == BT_WLAN_CONN_PRECDENCE_PAL) {
4452
if ( wmi_set_wlan_conn_precedence_cmd(ar->arWmi, cmd.precedence) != A_OK) {
4461
case AR6000_XIOCTL_AP_GET_STAT:
4463
ret = ar6000_ioctl_get_ap_stats(dev, rq);
4466
case AR6000_XIOCTL_SET_TX_SELECT_RATES:
4468
WMI_SET_TX_SELECT_RATES_CMD masks;
4470
if (ar->arWmiReady == FALSE) {
4472
} else if (copy_from_user(&masks, userdata,
4478
if (wmi_set_tx_select_rates_cmd(ar->arWmi, masks.rateMasks) != A_OK)
4485
case AR6000_XIOCTL_AP_GET_HIDDEN_SSID:
4487
WMI_AP_HIDDEN_SSID_CMD ssid;
4488
ssid.hidden_ssid = ar->ap_hidden_ssid;
4490
if (ar->arWmiReady == FALSE) {
4492
} else if(copy_to_user((WMI_AP_HIDDEN_SSID_CMD *)rq->ifr_data,
4493
&ssid, sizeof(WMI_AP_HIDDEN_SSID_CMD))) {
4498
case AR6000_XIOCTL_AP_GET_COUNTRY:
4500
WMI_AP_SET_COUNTRY_CMD cty;
4501
A_MEMCPY(cty.countryCode, ar->ap_country_code, 3);
4503
if (ar->arWmiReady == FALSE) {
4505
} else if(copy_to_user((WMI_AP_SET_COUNTRY_CMD *)rq->ifr_data,
4506
&cty, sizeof(WMI_AP_SET_COUNTRY_CMD))) {
4511
case AR6000_XIOCTL_AP_GET_WMODE:
4513
if (ar->arWmiReady == FALSE) {
4515
} else if(copy_to_user((A_UINT8 *)rq->ifr_data,
4516
&ar->ap_wmode, sizeof(A_UINT8))) {
4521
case AR6000_XIOCTL_AP_GET_DTIM:
4523
WMI_AP_SET_DTIM_CMD dtim;
4524
dtim.dtim = ar->ap_dtim_period;
4526
if (ar->arWmiReady == FALSE) {
4528
} else if(copy_to_user((WMI_AP_SET_DTIM_CMD *)rq->ifr_data,
4529
&dtim, sizeof(WMI_AP_SET_DTIM_CMD))) {
4534
case AR6000_XIOCTL_AP_GET_BINTVL:
4536
WMI_BEACON_INT_CMD bi;
4537
bi.beaconInterval = ar->ap_beacon_interval;
4539
if (ar->arWmiReady == FALSE) {
4541
} else if(copy_to_user((WMI_BEACON_INT_CMD *)rq->ifr_data,
4542
&bi, sizeof(WMI_BEACON_INT_CMD))) {
4547
case AR6000_XIOCTL_AP_GET_RTS:
4549
WMI_SET_RTS_CMD rts;
4550
rts.threshold = ar->arRTS;
4552
if (ar->arWmiReady == FALSE) {
4554
} else if(copy_to_user((WMI_SET_RTS_CMD *)rq->ifr_data,
4555
&rts, sizeof(WMI_SET_RTS_CMD))) {
4560
case AR6000_XIOCTL_FETCH_TARGET_REGS:
4562
A_UINT32 targregs[AR6003_FETCH_TARG_REGS_COUNT];
4564
if (ar->arTargetType == TARGET_TYPE_AR6003) {
4565
ar6k_FetchTargetRegs(hifDevice, targregs);
4566
if (copy_to_user((A_UINT32 *)rq->ifr_data, &targregs, sizeof(targregs)))
4575
case AR6000_XIOCTL_AP_SET_11BG_RATESET:
4577
WMI_AP_SET_11BG_RATESET_CMD rate;
4578
if (ar->arWmiReady == FALSE) {
4580
} else if (copy_from_user(&rate, userdata, sizeof(rate))) {
4583
wmi_ap_set_rateset(ar->arWmi, rate.rateset);
4587
case AR6000_XIOCTL_GET_WLAN_SLEEP_STATE:
4589
WMI_REPORT_SLEEP_STATE_EVENT wmiSleepEvent ;
4591
if (ar->arWlanState == WLAN_ENABLED) {
4592
wmiSleepEvent.sleepState = WMI_REPORT_SLEEP_STATUS_IS_AWAKE;
4594
wmiSleepEvent.sleepState = WMI_REPORT_SLEEP_STATUS_IS_DEEP_SLEEP;
4596
rq->ifr_ifru.ifru_ivalue = ar->arWlanState; /* return value */
4598
ar6000_send_event_to_app(ar, WMI_REPORT_SLEEP_STATE_EVENTID, (A_UINT8*)&wmiSleepEvent,
4599
sizeof(WMI_REPORT_SLEEP_STATE_EVENTID));
4603
case AR6000_XIOCTL_SET_BT_HW_POWER_STATE:
4606
if (get_user(state, (unsigned int *)userdata)) {
4610
if (ar6000_set_bt_hw_state(ar, state)!=A_OK) {
4615
case AR6000_XIOCTL_GET_BT_HW_POWER_STATE:
4616
rq->ifr_ifru.ifru_ivalue = !ar->arBTOff; /* return value */
4620
case AR6000_XIOCTL_WMI_SET_TX_SGI_PARAM:
4622
WMI_SET_TX_SGI_PARAM_CMD SGICmd;
4624
if (ar->arWmiReady == FALSE) {
4626
} else if (copy_from_user(&SGICmd, userdata,
4630
if (wmi_SGI_cmd(ar->arWmi, SGICmd.sgiMask, SGICmd.sgiPERThreshold) != A_OK) {
4638
case AR6000_XIOCTL_ADD_AP_INTERFACE:
4639
#ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
4641
char ap_ifname[IFNAMSIZ] = {0,};
4642
if (copy_from_user(ap_ifname, userdata, IFNAMSIZ)) {
4645
if (ar6000_add_ap_interface(ar, ap_ifname) != A_OK) {
4654
case AR6000_XIOCTL_REMOVE_AP_INTERFACE:
4655
#ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
4656
if (ar6000_remove_ap_interface(ar) != A_OK) {
4669
rtnl_lock(); /* restore rtnl state */
4675
A_UINT8 mac_cmp_wild(A_UINT8 *mac, A_UINT8 *new_mac, A_UINT8 wild, A_UINT8 new_wild)
4679
for(i=0;i<ATH_MAC_LEN;i++) {
4680
if((wild & 1<<i) && (new_wild & 1<<i)) continue;
4681
if(mac[i] != new_mac[i]) return 1;
4683
if((A_MEMCMP(new_mac, null_mac, 6)==0) && new_wild &&
4684
(wild != new_wild)) {
4691
A_UINT8 acl_add_del_mac(WMI_AP_ACL *a, WMI_AP_ACL_MAC_CMD *acl)
4693
A_INT8 already_avail=-1, free_slot=-1, i;
4695
/* To check whether this mac is already there in our list */
4696
for(i=AP_ACL_SIZE-1;i>=0;i--)
4698
if(mac_cmp_wild(a->acl_mac[i], acl->mac, a->wildcard[i],
4702
if(!((1 << i) & a->index))
4706
if(acl->action == ADD_MAC_ADDR)
4708
/* Dont add mac if it is already available */
4709
if((already_avail >= 0) || (free_slot == -1))
4712
A_MEMCPY(a->acl_mac[free_slot], acl->mac, ATH_MAC_LEN);
4713
a->index = a->index | (1 << free_slot);
4714
acl->index = free_slot;
4715
a->wildcard[free_slot] = acl->wildcard;
4718
else if(acl->action == DEL_MAC_ADDR)
4720
if(acl->index > AP_ACL_SIZE)
4723
if(!(a->index & (1 << acl->index)))
4726
A_MEMZERO(a->acl_mac[acl->index],ATH_MAC_LEN);
4727
a->index = a->index & ~(1 << acl->index);
4728
a->wildcard[acl->index] = 0;
added
removed
updates/compat-wireless-2.6.37/drivers/staging/ath6kl/os/linux/ioctl.c
