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;
40
ar6000_ioctl_get_roam_tbl(struct net_device *dev, struct ifreq *rq)
42
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
44
if (ar->arWmiReady == false) {
48
if(wmi_get_roam_tbl_cmd(ar->arWmi) != 0) {
56
ar6000_ioctl_get_roam_data(struct net_device *dev, struct ifreq *rq)
58
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
60
if (ar->arWmiReady == false) {
65
/* currently assume only roam times are required */
66
if(wmi_get_roam_data_cmd(ar->arWmi, ROAM_DATA_TIME) != 0) {
75
ar6000_ioctl_set_roam_ctrl(struct net_device *dev, char *userdata)
77
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
78
WMI_SET_ROAM_CTRL_CMD cmd;
79
u8 size = sizeof(cmd);
81
if (ar->arWmiReady == false) {
86
if (copy_from_user(&cmd, userdata, size)) {
90
if (cmd.roamCtrlType == WMI_SET_HOST_BIAS) {
91
if (cmd.info.bssBiasInfo.numBss > 1) {
92
size += (cmd.info.bssBiasInfo.numBss - 1) * sizeof(WMI_BSS_BIAS);
96
if (copy_from_user(&cmd, userdata, size)) {
100
if(wmi_set_roam_ctrl_cmd(ar->arWmi, &cmd, size) != 0) {
108
ar6000_ioctl_set_powersave_timers(struct net_device *dev, char *userdata)
110
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
111
WMI_POWERSAVE_TIMERS_POLICY_CMD cmd;
112
u8 size = sizeof(cmd);
114
if (ar->arWmiReady == false) {
118
if (copy_from_user(&cmd, userdata, size)) {
122
if (copy_from_user(&cmd, userdata, size)) {
126
if(wmi_set_powersave_timers_cmd(ar->arWmi, &cmd, size) != 0) {
134
ar6000_ioctl_set_qos_supp(struct net_device *dev, struct ifreq *rq)
136
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
137
WMI_SET_QOS_SUPP_CMD cmd;
140
if ((dev->flags & IFF_UP) != IFF_UP) {
143
if (ar->arWmiReady == false) {
147
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
153
ret = wmi_set_qos_supp_cmd(ar->arWmi, cmd.status);
169
ar6000_ioctl_set_wmm(struct net_device *dev, struct ifreq *rq)
171
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
175
if ((dev->flags & IFF_UP) != IFF_UP) {
178
if (ar->arWmiReady == false) {
182
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
188
if (cmd.status == WMI_WMM_ENABLED) {
189
ar->arWmmEnabled = true;
191
ar->arWmmEnabled = false;
194
ret = wmi_set_wmm_cmd(ar->arWmi, cmd.status);
210
ar6000_ioctl_set_txop(struct net_device *dev, struct ifreq *rq)
212
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
213
WMI_SET_WMM_TXOP_CMD cmd;
216
if ((dev->flags & IFF_UP) != IFF_UP) {
219
if (ar->arWmiReady == false) {
223
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
229
ret = wmi_set_wmm_txop(ar->arWmi, cmd.txopEnable);
245
ar6000_ioctl_get_rd(struct net_device *dev, struct ifreq *rq)
247
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
250
if ((dev->flags & IFF_UP) != IFF_UP || ar->arWmiReady == false) {
254
if(copy_to_user((char *)((unsigned int*)rq->ifr_data + 1),
255
&ar->arRegCode, sizeof(ar->arRegCode)))
262
ar6000_ioctl_set_country(struct net_device *dev, struct ifreq *rq)
264
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
265
WMI_AP_SET_COUNTRY_CMD cmd;
268
if ((dev->flags & IFF_UP) != IFF_UP) {
271
if (ar->arWmiReady == false) {
275
if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
281
ar->ap_profile_flag = 1; /* There is a change in profile */
283
ret = wmi_set_country(ar->arWmi, cmd.countryCode);
284
memcpy(ar->ap_country_code, cmd.countryCode, 3);
300
/* Get power mode command */
302
ar6000_ioctl_get_power_mode(struct net_device *dev, struct ifreq *rq)
304
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
305
WMI_POWER_MODE_CMD power_mode;
308
if (ar->arWmiReady == false) {
312
power_mode.powerMode = wmi_get_power_mode_cmd(ar->arWmi);
313
if (copy_to_user(rq->ifr_data, &power_mode, sizeof(WMI_POWER_MODE_CMD))) {
322
ar6000_ioctl_set_channelParams(struct net_device *dev, struct ifreq *rq)
324
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
325
WMI_CHANNEL_PARAMS_CMD cmd, *cmdp;
328
if (ar->arWmiReady == false) {
333
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
337
if( (ar->arNextMode == AP_NETWORK) && (cmd.numChannels || cmd.scanParam) ) {
338
A_PRINTF("ERROR: Only wmode is allowed in AP mode\n");
342
if (cmd.numChannels > 1) {
343
cmdp = A_MALLOC(130);
344
if (copy_from_user(cmdp, rq->ifr_data,
346
((cmd.numChannels - 1) * sizeof(u16))))
355
if ((ar->arPhyCapability == WMI_11G_CAPABILITY) &&
356
((cmdp->phyMode == WMI_11A_MODE) || (cmdp->phyMode == WMI_11AG_MODE)))
362
(wmi_set_channelParams_cmd(ar->arWmi, cmdp->scanParam, cmdp->phyMode,
363
cmdp->numChannels, cmdp->channelList)
369
if (cmd.numChannels > 1) {
373
ar->ap_wmode = cmdp->phyMode;
374
/* Set the profile change flag to allow a commit cmd */
375
ar->ap_profile_flag = 1;
382
ar6000_ioctl_set_snr_threshold(struct net_device *dev, struct ifreq *rq)
385
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
386
WMI_SNR_THRESHOLD_PARAMS_CMD cmd;
389
if (ar->arWmiReady == false) {
393
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
397
if( wmi_set_snr_threshold_params(ar->arWmi, &cmd) != 0 ) {
405
ar6000_ioctl_set_rssi_threshold(struct net_device *dev, struct ifreq *rq)
407
#define SWAP_THOLD(thold1, thold2) do { \
408
USER_RSSI_THOLD tmpThold; \
409
tmpThold.tag = thold1.tag; \
410
tmpThold.rssi = thold1.rssi; \
411
thold1.tag = thold2.tag; \
412
thold1.rssi = thold2.rssi; \
413
thold2.tag = tmpThold.tag; \
414
thold2.rssi = tmpThold.rssi; \
417
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
418
WMI_RSSI_THRESHOLD_PARAMS_CMD cmd;
419
USER_RSSI_PARAMS rssiParams;
423
if (ar->arWmiReady == false) {
427
if (copy_from_user((char *)&rssiParams, (char *)((unsigned int *)rq->ifr_data + 1), sizeof(USER_RSSI_PARAMS))) {
430
cmd.weight = rssiParams.weight;
431
cmd.pollTime = rssiParams.pollTime;
433
memcpy(ar->rssi_map, &rssiParams.tholds, sizeof(ar->rssi_map));
435
* only 6 elements, so use bubble sorting, in ascending order
437
for (i = 5; i > 0; i--) {
438
for (j = 0; j < i; j++) { /* above tholds */
439
if (ar->rssi_map[j+1].rssi < ar->rssi_map[j].rssi) {
440
SWAP_THOLD(ar->rssi_map[j+1], ar->rssi_map[j]);
441
} else if (ar->rssi_map[j+1].rssi == ar->rssi_map[j].rssi) {
446
for (i = 11; i > 6; i--) {
447
for (j = 6; j < i; j++) { /* below tholds */
448
if (ar->rssi_map[j+1].rssi < ar->rssi_map[j].rssi) {
449
SWAP_THOLD(ar->rssi_map[j+1], ar->rssi_map[j]);
450
} else if (ar->rssi_map[j+1].rssi == ar->rssi_map[j].rssi) {
457
for (i = 0; i < 12; i++) {
458
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("thold[%d].tag: %d, thold[%d].rssi: %d \n",
459
i, ar->rssi_map[i].tag, i, ar->rssi_map[i].rssi));
463
if (enablerssicompensation) {
464
for (i = 0; i < 6; i++)
465
ar->rssi_map[i].rssi = rssi_compensation_reverse_calc(ar, ar->rssi_map[i].rssi, true);
466
for (i = 6; i < 12; i++)
467
ar->rssi_map[i].rssi = rssi_compensation_reverse_calc(ar, ar->rssi_map[i].rssi, false);
470
cmd.thresholdAbove1_Val = ar->rssi_map[0].rssi;
471
cmd.thresholdAbove2_Val = ar->rssi_map[1].rssi;
472
cmd.thresholdAbove3_Val = ar->rssi_map[2].rssi;
473
cmd.thresholdAbove4_Val = ar->rssi_map[3].rssi;
474
cmd.thresholdAbove5_Val = ar->rssi_map[4].rssi;
475
cmd.thresholdAbove6_Val = ar->rssi_map[5].rssi;
476
cmd.thresholdBelow1_Val = ar->rssi_map[6].rssi;
477
cmd.thresholdBelow2_Val = ar->rssi_map[7].rssi;
478
cmd.thresholdBelow3_Val = ar->rssi_map[8].rssi;
479
cmd.thresholdBelow4_Val = ar->rssi_map[9].rssi;
480
cmd.thresholdBelow5_Val = ar->rssi_map[10].rssi;
481
cmd.thresholdBelow6_Val = ar->rssi_map[11].rssi;
483
if( wmi_set_rssi_threshold_params(ar->arWmi, &cmd) != 0 ) {
491
ar6000_ioctl_set_lq_threshold(struct net_device *dev, struct ifreq *rq)
494
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
495
WMI_LQ_THRESHOLD_PARAMS_CMD cmd;
498
if (ar->arWmiReady == false) {
502
if (copy_from_user(&cmd, (char *)((unsigned int *)rq->ifr_data + 1), sizeof(cmd))) {
506
if( wmi_set_lq_threshold_params(ar->arWmi, &cmd) != 0 ) {
515
ar6000_ioctl_set_probedSsid(struct net_device *dev, struct ifreq *rq)
517
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
518
WMI_PROBED_SSID_CMD cmd;
521
if (ar->arWmiReady == false) {
525
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
529
if (wmi_probedSsid_cmd(ar->arWmi, cmd.entryIndex, cmd.flag, cmd.ssidLength,
539
ar6000_ioctl_set_badAp(struct net_device *dev, struct ifreq *rq)
541
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
542
WMI_ADD_BAD_AP_CMD cmd;
545
if (ar->arWmiReady == false) {
550
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
554
if (cmd.badApIndex > WMI_MAX_BAD_AP_INDEX) {
558
if (memcmp(cmd.bssid, null_mac, AR6000_ETH_ADDR_LEN) == 0) {
560
* This is a delete badAP.
562
if (wmi_deleteBadAp_cmd(ar->arWmi, cmd.badApIndex) != 0) {
566
if (wmi_addBadAp_cmd(ar->arWmi, cmd.badApIndex, cmd.bssid) != 0) {
575
ar6000_ioctl_create_qos(struct net_device *dev, struct ifreq *rq)
577
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
578
WMI_CREATE_PSTREAM_CMD cmd;
581
if (ar->arWmiReady == false) {
586
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
590
ret = wmi_verify_tspec_params(&cmd, tspecCompliance);
592
ret = wmi_create_pstream_cmd(ar->arWmi, &cmd);
608
ar6000_ioctl_delete_qos(struct net_device *dev, struct ifreq *rq)
610
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
611
WMI_DELETE_PSTREAM_CMD cmd;
614
if (ar->arWmiReady == false) {
618
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
622
ret = wmi_delete_pstream_cmd(ar->arWmi, cmd.trafficClass, cmd.tsid);
638
ar6000_ioctl_get_qos_queue(struct net_device *dev, struct ifreq *rq)
640
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
641
struct ar6000_queuereq qreq;
644
if (ar->arWmiReady == false) {
648
if( copy_from_user(&qreq, rq->ifr_data,
649
sizeof(struct ar6000_queuereq)))
652
qreq.activeTsids = wmi_get_mapped_qos_queue(ar->arWmi, qreq.trafficClass);
654
if (copy_to_user(rq->ifr_data, &qreq,
655
sizeof(struct ar6000_queuereq)))
663
#ifdef CONFIG_HOST_TCMD_SUPPORT
665
ar6000_ioctl_tcmd_get_rx_report(struct net_device *dev,
666
struct ifreq *rq, u8 *data, u32 len)
668
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
669
u32 buf[4+TCMD_MAX_RATES];
672
if (ar->bIsDestroyProgress) {
676
if (ar->arWmiReady == false) {
680
if (down_interruptible(&ar->arSem)) {
684
if (ar->bIsDestroyProgress) {
689
ar->tcmdRxReport = 0;
690
if (wmi_test_cmd(ar->arWmi, data, len) != 0) {
695
wait_event_interruptible_timeout(arEvent, ar->tcmdRxReport != 0, wmitimeout * HZ);
697
if (signal_pending(current)) {
701
buf[0] = ar->tcmdRxTotalPkt;
702
buf[1] = ar->tcmdRxRssi;
703
buf[2] = ar->tcmdRxcrcErrPkt;
704
buf[3] = ar->tcmdRxsecErrPkt;
705
memcpy(((u8 *)buf)+(4*sizeof(u32)), ar->tcmdRateCnt, sizeof(ar->tcmdRateCnt));
706
memcpy(((u8 *)buf)+(4*sizeof(u32))+(TCMD_MAX_RATES *sizeof(u16)), ar->tcmdRateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
708
if (!ret && copy_to_user(rq->ifr_data, buf, sizeof(buf))) {
718
ar6000_tcmd_rx_report_event(void *devt, u8 *results, int len)
720
struct ar6_softc *ar = (struct ar6_softc *)devt;
721
TCMD_CONT_RX * rx_rep = (TCMD_CONT_RX *)results;
723
if (enablerssicompensation) {
724
rx_rep->u.report.rssiInDBm = rssi_compensation_calc_tcmd(tcmdRxFreq, rx_rep->u.report.rssiInDBm,rx_rep->u.report.totalPkt);
728
ar->tcmdRxTotalPkt = rx_rep->u.report.totalPkt;
729
ar->tcmdRxRssi = rx_rep->u.report.rssiInDBm;
730
ar->tcmdRxcrcErrPkt = rx_rep->u.report.crcErrPkt;
731
ar->tcmdRxsecErrPkt = rx_rep->u.report.secErrPkt;
732
ar->tcmdRxReport = 1;
733
A_MEMZERO(ar->tcmdRateCnt, sizeof(ar->tcmdRateCnt));
734
A_MEMZERO(ar->tcmdRateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
735
memcpy(ar->tcmdRateCnt, rx_rep->u.report.rateCnt, sizeof(ar->tcmdRateCnt));
736
memcpy(ar->tcmdRateCntShortGuard, rx_rep->u.report.rateCntShortGuard, sizeof(ar->tcmdRateCntShortGuard));
740
#endif /* CONFIG_HOST_TCMD_SUPPORT*/
743
ar6000_ioctl_set_error_report_bitmask(struct net_device *dev, struct ifreq *rq)
745
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
746
WMI_TARGET_ERROR_REPORT_BITMASK cmd;
749
if (ar->arWmiReady == false) {
753
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
757
ret = wmi_set_error_report_bitmask(ar->arWmi, cmd.bitmask);
759
return (ret==0 ? ret : -EINVAL);
763
ar6000_clear_target_stats(struct net_device *dev)
765
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
766
TARGET_STATS *pStats = &ar->arTargetStats;
769
if (ar->arWmiReady == false) {
772
AR6000_SPIN_LOCK(&ar->arLock, 0);
773
A_MEMZERO(pStats, sizeof(TARGET_STATS));
774
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
779
ar6000_ioctl_get_target_stats(struct net_device *dev, struct ifreq *rq)
781
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
782
TARGET_STATS_CMD cmd;
783
TARGET_STATS *pStats = &ar->arTargetStats;
786
if (ar->bIsDestroyProgress) {
789
if (ar->arWmiReady == false) {
792
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
795
if (down_interruptible(&ar->arSem)) {
798
if (ar->bIsDestroyProgress) {
803
ar->statsUpdatePending = true;
805
if(wmi_get_stats_cmd(ar->arWmi) != 0) {
810
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == false, wmitimeout * HZ);
812
if (signal_pending(current)) {
816
if (!ret && copy_to_user(rq->ifr_data, pStats, sizeof(*pStats))) {
820
if (cmd.clearStats == 1) {
821
ret = ar6000_clear_target_stats(dev);
830
ar6000_ioctl_get_ap_stats(struct net_device *dev, struct ifreq *rq)
832
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
833
u32 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 */
834
WMI_AP_MODE_STAT *pStats = &ar->arAPStats;
837
if (ar->arWmiReady == false) {
840
if (copy_from_user(&action, (char *)((unsigned int*)rq->ifr_data + 1),
845
if (action == AP_CLEAR_STATS) {
847
AR6000_SPIN_LOCK(&ar->arLock, 0);
848
for(i = 0; i < AP_MAX_NUM_STA; i++) {
849
pStats->sta[i].tx_bytes = 0;
850
pStats->sta[i].tx_pkts = 0;
851
pStats->sta[i].tx_error = 0;
852
pStats->sta[i].tx_discard = 0;
853
pStats->sta[i].rx_bytes = 0;
854
pStats->sta[i].rx_pkts = 0;
855
pStats->sta[i].rx_error = 0;
856
pStats->sta[i].rx_discard = 0;
858
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
862
if (down_interruptible(&ar->arSem)) {
866
ar->statsUpdatePending = true;
868
if(wmi_get_stats_cmd(ar->arWmi) != 0) {
873
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == false, wmitimeout * HZ);
875
if (signal_pending(current)) {
879
if (!ret && copy_to_user(rq->ifr_data, pStats, sizeof(*pStats))) {
889
ar6000_ioctl_set_access_params(struct net_device *dev, struct ifreq *rq)
891
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
892
WMI_SET_ACCESS_PARAMS_CMD cmd;
895
if (ar->arWmiReady == false) {
899
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
903
if (wmi_set_access_params_cmd(ar->arWmi, cmd.ac, cmd.txop, cmd.eCWmin, cmd.eCWmax,
915
ar6000_ioctl_set_disconnect_timeout(struct net_device *dev, struct ifreq *rq)
917
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
918
WMI_DISC_TIMEOUT_CMD cmd;
921
if (ar->arWmiReady == false) {
925
if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
929
if (wmi_disctimeout_cmd(ar->arWmi, cmd.disconnectTimeout) == 0)
940
ar6000_xioctl_set_voice_pkt_size(struct net_device *dev, char *userdata)
942
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
943
WMI_SET_VOICE_PKT_SIZE_CMD cmd;
946
if (ar->arWmiReady == false) {
950
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
954
if (wmi_set_voice_pkt_size_cmd(ar->arWmi, cmd.voicePktSize) == 0)
966
ar6000_xioctl_set_max_sp_len(struct net_device *dev, char *userdata)
968
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
969
WMI_SET_MAX_SP_LEN_CMD cmd;
972
if (ar->arWmiReady == false) {
976
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
980
if (wmi_set_max_sp_len_cmd(ar->arWmi, cmd.maxSPLen) == 0)
992
ar6000_xioctl_set_bt_status_cmd(struct net_device *dev, char *userdata)
994
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
995
WMI_SET_BT_STATUS_CMD cmd;
998
if (ar->arWmiReady == false) {
1002
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1006
if (wmi_set_bt_status_cmd(ar->arWmi, cmd.streamType, cmd.status) == 0)
1017
ar6000_xioctl_set_bt_params_cmd(struct net_device *dev, char *userdata)
1019
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1020
WMI_SET_BT_PARAMS_CMD cmd;
1023
if (ar->arWmiReady == false) {
1027
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1031
if (wmi_set_bt_params_cmd(ar->arWmi, &cmd) == 0)
1042
ar6000_xioctl_set_btcoex_fe_ant_cmd(struct net_device * dev, char *userdata)
1044
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1045
WMI_SET_BTCOEX_FE_ANT_CMD cmd;
1048
if (ar->arWmiReady == false) {
1051
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1055
if (wmi_set_btcoex_fe_ant_cmd(ar->arWmi, &cmd) == 0)
1066
ar6000_xioctl_set_btcoex_colocated_bt_dev_cmd(struct net_device * dev, char *userdata)
1068
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1069
WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD cmd;
1072
if (ar->arWmiReady == false) {
1076
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1080
if (wmi_set_btcoex_colocated_bt_dev_cmd(ar->arWmi, &cmd) == 0)
1091
ar6000_xioctl_set_btcoex_btinquiry_page_config_cmd(struct net_device * dev, char *userdata)
1093
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1094
WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD cmd;
1097
if (ar->arWmiReady == false) {
1101
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1105
if (wmi_set_btcoex_btinquiry_page_config_cmd(ar->arWmi, &cmd) == 0)
1116
ar6000_xioctl_set_btcoex_sco_config_cmd(struct net_device * dev, char *userdata)
1118
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1119
WMI_SET_BTCOEX_SCO_CONFIG_CMD cmd;
1122
if (ar->arWmiReady == false) {
1126
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1130
if (wmi_set_btcoex_sco_config_cmd(ar->arWmi, &cmd) == 0)
1141
ar6000_xioctl_set_btcoex_a2dp_config_cmd(struct net_device * dev,
1144
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1145
WMI_SET_BTCOEX_A2DP_CONFIG_CMD cmd;
1148
if (ar->arWmiReady == false) {
1152
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1156
if (wmi_set_btcoex_a2dp_config_cmd(ar->arWmi, &cmd) == 0)
1167
ar6000_xioctl_set_btcoex_aclcoex_config_cmd(struct net_device * dev, char *userdata)
1169
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1170
WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD cmd;
1173
if (ar->arWmiReady == false) {
1177
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1181
if (wmi_set_btcoex_aclcoex_config_cmd(ar->arWmi, &cmd) == 0)
1192
ar60000_xioctl_set_btcoex_debug_cmd(struct net_device * dev, char *userdata)
1194
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1195
WMI_SET_BTCOEX_DEBUG_CMD cmd;
1198
if (ar->arWmiReady == false) {
1202
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1206
if (wmi_set_btcoex_debug_cmd(ar->arWmi, &cmd) == 0)
1217
ar6000_xioctl_set_btcoex_bt_operating_status_cmd(struct net_device * dev, char *userdata)
1219
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1220
WMI_SET_BTCOEX_BT_OPERATING_STATUS_CMD cmd;
1223
if (ar->arWmiReady == false) {
1227
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1231
if (wmi_set_btcoex_bt_operating_status_cmd(ar->arWmi, &cmd) == 0)
1241
ar6000_xioctl_get_btcoex_config_cmd(struct net_device * dev, char *userdata,
1245
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1246
AR6000_BTCOEX_CONFIG btcoexConfig;
1247
WMI_BTCOEX_CONFIG_EVENT *pbtcoexConfigEv = &ar->arBtcoexConfig;
1251
if (ar->bIsDestroyProgress) {
1254
if (ar->arWmiReady == false) {
1257
if (copy_from_user(&btcoexConfig.configCmd, userdata, sizeof(AR6000_BTCOEX_CONFIG))) {
1260
if (down_interruptible(&ar->arSem)) {
1261
return -ERESTARTSYS;
1264
if (wmi_get_btcoex_config_cmd(ar->arWmi, (WMI_GET_BTCOEX_CONFIG_CMD *)&btcoexConfig.configCmd) != 0)
1270
ar->statsUpdatePending = true;
1272
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == false, wmitimeout * HZ);
1274
if (signal_pending(current)) {
1278
if (!ret && copy_to_user(btcoexConfig.configEvent, pbtcoexConfigEv, sizeof(WMI_BTCOEX_CONFIG_EVENT))) {
1286
ar6000_xioctl_get_btcoex_stats_cmd(struct net_device * dev, char *userdata, struct ifreq *rq)
1288
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1289
AR6000_BTCOEX_STATS btcoexStats;
1290
WMI_BTCOEX_STATS_EVENT *pbtcoexStats = &ar->arBtcoexStats;
1293
if (ar->bIsDestroyProgress) {
1296
if (ar->arWmiReady == false) {
1300
if (down_interruptible(&ar->arSem)) {
1301
return -ERESTARTSYS;
1304
if (copy_from_user(&btcoexStats.statsEvent, userdata, sizeof(AR6000_BTCOEX_CONFIG))) {
1308
if (wmi_get_btcoex_stats_cmd(ar->arWmi) != 0)
1314
ar->statsUpdatePending = true;
1316
wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == false, wmitimeout * HZ);
1318
if (signal_pending(current)) {
1322
if (!ret && copy_to_user(btcoexStats.statsEvent, pbtcoexStats, sizeof(WMI_BTCOEX_STATS_EVENT))) {
1333
ar6000_xioctl_set_excess_tx_retry_thres_cmd(struct net_device * dev, char * userdata)
1335
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1336
WMI_SET_EXCESS_TX_RETRY_THRES_CMD cmd;
1339
if (ar->arWmiReady == false) {
1343
if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
1347
if (wmi_set_excess_tx_retry_thres_cmd(ar->arWmi, &cmd) != 0)
1354
#ifdef CONFIG_HOST_GPIO_SUPPORT
1355
struct ar6000_gpio_intr_wait_cmd_s gpio_intr_results;
1356
/* gpio_reg_results and gpio_data_available are protected by arSem */
1357
static struct ar6000_gpio_register_cmd_s gpio_reg_results;
1358
static bool gpio_data_available; /* Requested GPIO data available */
1359
static bool gpio_intr_available; /* GPIO interrupt info available */
1360
static bool gpio_ack_received; /* GPIO ack was received */
1362
/* Host-side initialization for General Purpose I/O support */
1363
void ar6000_gpio_init(void)
1365
gpio_intr_available = false;
1366
gpio_data_available = false;
1367
gpio_ack_received = false;
1371
* Called when a GPIO interrupt is received from the Target.
1372
* intr_values shows which GPIO pins have interrupted.
1373
* input_values shows a recent value of GPIO pins.
1376
ar6000_gpio_intr_rx(u32 intr_mask, u32 input_values)
1378
gpio_intr_results.intr_mask = intr_mask;
1379
gpio_intr_results.input_values = input_values;
1380
*((volatile bool *)&gpio_intr_available) = true;
1385
* This is called when a response is received from the Target
1386
* for a previous or ar6000_gpio_input_get or ar6000_gpio_register_get
1390
ar6000_gpio_data_rx(u32 reg_id, u32 value)
1392
gpio_reg_results.gpioreg_id = reg_id;
1393
gpio_reg_results.value = value;
1394
*((volatile bool *)&gpio_data_available) = true;
1399
* This is called when an acknowledgement is received from the Target
1400
* for a previous or ar6000_gpio_output_set or ar6000_gpio_register_set
1404
ar6000_gpio_ack_rx(void)
1406
gpio_ack_received = true;
1411
ar6000_gpio_output_set(struct net_device *dev,
1417
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1419
gpio_ack_received = false;
1420
return wmi_gpio_output_set(ar->arWmi,
1421
set_mask, clear_mask, enable_mask, disable_mask);
1425
ar6000_gpio_input_get(struct net_device *dev)
1427
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1429
*((volatile bool *)&gpio_data_available) = false;
1430
return wmi_gpio_input_get(ar->arWmi);
1434
ar6000_gpio_register_set(struct net_device *dev,
1438
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1440
gpio_ack_received = false;
1441
return wmi_gpio_register_set(ar->arWmi, gpioreg_id, value);
1445
ar6000_gpio_register_get(struct net_device *dev,
1448
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1450
*((volatile bool *)&gpio_data_available) = false;
1451
return wmi_gpio_register_get(ar->arWmi, gpioreg_id);
1455
ar6000_gpio_intr_ack(struct net_device *dev,
1458
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1460
gpio_intr_available = false;
1461
return wmi_gpio_intr_ack(ar->arWmi, ack_mask);
1463
#endif /* CONFIG_HOST_GPIO_SUPPORT */
1465
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
1466
static struct prof_count_s prof_count_results;
1467
static bool prof_count_available; /* Requested GPIO data available */
1470
prof_count_get(struct net_device *dev)
1472
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1474
*((volatile bool *)&prof_count_available) = false;
1475
return wmi_prof_count_get_cmd(ar->arWmi);
1479
* This is called when a response is received from the Target
1480
* for a previous prof_count_get call.
1483
prof_count_rx(u32 addr, u32 count)
1485
prof_count_results.addr = addr;
1486
prof_count_results.count = count;
1487
*((volatile bool *)&prof_count_available) = true;
1490
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
1494
ar6000_create_acl_data_osbuf(struct net_device *dev, u8 *userdata, void **p_osbuf)
1498
HCI_ACL_DATA_PKT *acl;
1499
u8 hdr_size, *datap=NULL;
1502
/* ACL is in data path. There is a need to create pool
1503
* mechanism for allocating and freeing NETBUFs - ToDo later.
1507
acl = (HCI_ACL_DATA_PKT *)tmp_space;
1508
hdr_size = sizeof(acl->hdl_and_flags) + sizeof(acl->data_len);
1511
if (a_copy_from_user(acl, userdata, hdr_size)) {
1516
osbuf = A_NETBUF_ALLOC(hdr_size + acl->data_len);
1517
if (osbuf == NULL) {
1521
A_NETBUF_PUT(osbuf, hdr_size + acl->data_len);
1522
datap = (u8 *)A_NETBUF_DATA(osbuf);
1524
/* Real copy to osbuf */
1525
acl = (HCI_ACL_DATA_PKT *)(datap);
1526
memcpy(acl, tmp_space, hdr_size);
1527
if (a_copy_from_user(acl->data, userdata + hdr_size, acl->data_len)) {
1536
A_NETBUF_FREE(osbuf);
1544
ar6000_ioctl_ap_setparam(struct ar6_softc *ar, int param, int value)
1549
case IEEE80211_PARAM_WPA:
1552
ar->arAuthMode = WPA_AUTH;
1555
ar->arAuthMode = WPA2_AUTH;
1558
ar->arAuthMode = WPA_AUTH | WPA2_AUTH;
1561
ar->arAuthMode = NONE_AUTH;
1565
case IEEE80211_PARAM_AUTHMODE:
1566
if(value == IEEE80211_AUTH_WPA_PSK) {
1567
if (WPA_AUTH == ar->arAuthMode) {
1568
ar->arAuthMode = WPA_PSK_AUTH;
1569
} else if (WPA2_AUTH == ar->arAuthMode) {
1570
ar->arAuthMode = WPA2_PSK_AUTH;
1571
} else if ((WPA_AUTH | WPA2_AUTH) == ar->arAuthMode) {
1572
ar->arAuthMode = WPA_PSK_AUTH | WPA2_PSK_AUTH;
1574
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Error - Setting PSK "\
1575
"mode when WPA param was set to %d\n",
1581
case IEEE80211_PARAM_UCASTCIPHER:
1582
ar->arPairwiseCrypto = 0;
1583
if(value & (1<<IEEE80211_CIPHER_AES_CCM)) {
1584
ar->arPairwiseCrypto |= AES_CRYPT;
1586
if(value & (1<<IEEE80211_CIPHER_TKIP)) {
1587
ar->arPairwiseCrypto |= TKIP_CRYPT;
1589
if(!ar->arPairwiseCrypto) {
1590
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
1591
("Error - Invalid cipher in WPA \n"));
1595
case IEEE80211_PARAM_PRIVACY:
1597
ar->arDot11AuthMode = OPEN_AUTH;
1598
ar->arAuthMode = NONE_AUTH;
1599
ar->arPairwiseCrypto = NONE_CRYPT;
1600
ar->arPairwiseCryptoLen = 0;
1601
ar->arGroupCrypto = NONE_CRYPT;
1602
ar->arGroupCryptoLen = 0;
1606
case IEEE80211_PARAM_WAPI:
1607
A_PRINTF("WAPI Policy: %d\n", value);
1608
ar->arDot11AuthMode = OPEN_AUTH;
1609
ar->arAuthMode = NONE_AUTH;
1611
ar->arPairwiseCrypto = WAPI_CRYPT;
1612
ar->arGroupCrypto = WAPI_CRYPT;
1614
ar->arPairwiseCrypto = NONE_CRYPT;
1615
ar->arGroupCrypto = NONE_CRYPT;
1624
ar6000_ioctl_setparam(struct ar6_softc *ar, int param, int value)
1626
bool profChanged = false;
1629
if(ar->arNextMode == AP_NETWORK) {
1630
ar->ap_profile_flag = 1; /* There is a change in profile */
1632
case IEEE80211_PARAM_WPA:
1633
case IEEE80211_PARAM_AUTHMODE:
1634
case IEEE80211_PARAM_UCASTCIPHER:
1635
case IEEE80211_PARAM_PRIVACY:
1636
case IEEE80211_PARAM_WAPI:
1637
ret = ar6000_ioctl_ap_setparam(ar, param, value);
1643
case IEEE80211_PARAM_WPA:
1646
ar->arAuthMode = WPA_AUTH;
1650
ar->arAuthMode = WPA2_AUTH;
1654
ar->arAuthMode = NONE_AUTH;
1659
case IEEE80211_PARAM_AUTHMODE:
1661
case IEEE80211_AUTH_WPA_PSK:
1662
if (WPA_AUTH == ar->arAuthMode) {
1663
ar->arAuthMode = WPA_PSK_AUTH;
1665
} else if (WPA2_AUTH == ar->arAuthMode) {
1666
ar->arAuthMode = WPA2_PSK_AUTH;
1669
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Error - Setting PSK "\
1670
"mode when WPA param was set to %d\n",
1675
case IEEE80211_AUTH_WPA_CCKM:
1676
if (WPA2_AUTH == ar->arAuthMode) {
1677
ar->arAuthMode = WPA2_AUTH_CCKM;
1679
ar->arAuthMode = WPA_AUTH_CCKM;
1686
case IEEE80211_PARAM_UCASTCIPHER:
1688
case IEEE80211_CIPHER_AES_CCM:
1689
ar->arPairwiseCrypto = AES_CRYPT;
1692
case IEEE80211_CIPHER_TKIP:
1693
ar->arPairwiseCrypto = TKIP_CRYPT;
1696
case IEEE80211_CIPHER_WEP:
1697
ar->arPairwiseCrypto = WEP_CRYPT;
1700
case IEEE80211_CIPHER_NONE:
1701
ar->arPairwiseCrypto = NONE_CRYPT;
1706
case IEEE80211_PARAM_UCASTKEYLEN:
1707
if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(value)) {
1710
ar->arPairwiseCryptoLen = value;
1713
case IEEE80211_PARAM_MCASTCIPHER:
1715
case IEEE80211_CIPHER_AES_CCM:
1716
ar->arGroupCrypto = AES_CRYPT;
1719
case IEEE80211_CIPHER_TKIP:
1720
ar->arGroupCrypto = TKIP_CRYPT;
1723
case IEEE80211_CIPHER_WEP:
1724
ar->arGroupCrypto = WEP_CRYPT;
1727
case IEEE80211_CIPHER_NONE:
1728
ar->arGroupCrypto = NONE_CRYPT;
1733
case IEEE80211_PARAM_MCASTKEYLEN:
1734
if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(value)) {
1737
ar->arGroupCryptoLen = value;
1740
case IEEE80211_PARAM_COUNTERMEASURES:
1741
if (ar->arWmiReady == false) {
1744
wmi_set_tkip_countermeasures_cmd(ar->arWmi, value);
1749
if ((ar->arNextMode != AP_NETWORK) && (profChanged == true)) {
1751
* profile has changed. Erase ssid to signal change
1753
A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
1760
ar6000_ioctl_setkey(struct ar6_softc *ar, struct ieee80211req_key *ik)
1764
CRYPTO_TYPE keyType = NONE_CRYPT;
1767
ar->user_saved_keys.keyOk = false;
1769
if ( (0 == memcmp(ik->ik_macaddr, null_mac, IEEE80211_ADDR_LEN)) ||
1770
(0 == memcmp(ik->ik_macaddr, bcast_mac, IEEE80211_ADDR_LEN)) ) {
1771
keyUsage = GROUP_USAGE;
1772
if(ar->arNextMode == AP_NETWORK) {
1773
memcpy(&ar->ap_mode_bkey, ik,
1774
sizeof(struct ieee80211req_key));
1776
if(ar->arPairwiseCrypto == WAPI_CRYPT) {
1777
return ap_set_wapi_key(ar, ik);
1782
memcpy(&ar->user_saved_keys.bcast_ik, ik,
1783
sizeof(struct ieee80211req_key));
1786
keyUsage = PAIRWISE_USAGE;
1788
memcpy(&ar->user_saved_keys.ucast_ik, ik,
1789
sizeof(struct ieee80211req_key));
1792
if(ar->arNextMode == AP_NETWORK) {
1793
if(ar->arPairwiseCrypto == WAPI_CRYPT) {
1794
return ap_set_wapi_key(ar, ik);
1800
switch (ik->ik_type) {
1801
case IEEE80211_CIPHER_WEP:
1802
keyType = WEP_CRYPT;
1804
case IEEE80211_CIPHER_TKIP:
1805
keyType = TKIP_CRYPT;
1807
case IEEE80211_CIPHER_AES_CCM:
1808
keyType = AES_CRYPT;
1814
ar->user_saved_keys.keyType = keyType;
1816
if (IEEE80211_CIPHER_CCKM_KRK != ik->ik_type) {
1817
if (NONE_CRYPT == keyType) {
1821
if ((WEP_CRYPT == keyType)&&(!ar->arConnected)) {
1822
int index = ik->ik_keyix;
1824
if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(ik->ik_keylen)) {
1828
A_MEMZERO(ar->arWepKeyList[index].arKey,
1829
sizeof(ar->arWepKeyList[index].arKey));
1830
memcpy(ar->arWepKeyList[index].arKey, ik->ik_keydata, ik->ik_keylen);
1831
ar->arWepKeyList[index].arKeyLen = ik->ik_keylen;
1833
if(ik->ik_flags & IEEE80211_KEY_DEFAULT){
1834
ar->arDefTxKeyIndex = index;
1840
if (((WPA_PSK_AUTH == ar->arAuthMode) || (WPA2_PSK_AUTH == ar->arAuthMode)) &&
1841
(GROUP_USAGE & keyUsage))
1843
A_UNTIMEOUT(&ar->disconnect_timer);
1846
status = wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, keyType, keyUsage,
1847
ik->ik_keylen, (u8 *)&ik->ik_keyrsc,
1848
ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
1855
status = wmi_add_krk_cmd(ar->arWmi, ik->ik_keydata);
1859
ar->user_saved_keys.keyOk = true;
1865
int ar6000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1867
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
1868
struct hif_device *hifDevice = ar->arHifDevice;
1870
unsigned int address = 0;
1871
unsigned int length = 0;
1872
unsigned char *buffer;
1874
u32 connectCtrlFlags;
1877
WMI_SET_AKMP_PARAMS_CMD akmpParams;
1878
WMI_SET_PMKID_LIST_CMD pmkidInfo;
1880
WMI_SET_HT_CAP_CMD htCap;
1881
WMI_SET_HT_OP_CMD htOp;
1884
* ioctl operations may have to wait for the Target, so we cannot hold rtnl.
1885
* Prevent the device from disappearing under us and release the lock during
1886
* the ioctl operation.
1891
if (cmd == AR6000_IOCTL_EXTENDED) {
1893
* This allows for many more wireless ioctls than would otherwise
1894
* be available. Applications embed the actual ioctl command in
1895
* the first word of the parameter block, and use the command
1896
* AR6000_IOCTL_EXTENDED_CMD on the ioctl call.
1898
if (get_user(cmd, (int *)rq->ifr_data)) {
1902
userdata = (char *)(((unsigned int *)rq->ifr_data)+1);
1903
if(is_xioctl_allowed(ar->arNextMode, cmd) != 0) {
1904
A_PRINTF("xioctl: cmd=%d not allowed in this mode\n",cmd);
1909
int ret = is_iwioctl_allowed(ar->arNextMode, cmd);
1910
if(ret == A_ENOTSUP) {
1911
A_PRINTF("iwioctl: cmd=0x%x not allowed in this mode\n", cmd);
1914
} else if (ret == A_ERROR) {
1915
/* It is not our ioctl (out of range ioctl) */
1919
userdata = (char *)rq->ifr_data;
1922
if ((ar->arWlanState == WLAN_DISABLED) &&
1923
((cmd != AR6000_XIOCTRL_WMI_SET_WLAN_STATE) &&
1924
(cmd != AR6000_XIOCTL_GET_WLAN_SLEEP_STATE) &&
1925
(cmd != AR6000_XIOCTL_DIAG_READ) &&
1926
(cmd != AR6000_XIOCTL_DIAG_WRITE) &&
1927
(cmd != AR6000_XIOCTL_SET_BT_HW_POWER_STATE) &&
1928
(cmd != AR6000_XIOCTL_GET_BT_HW_POWER_STATE) &&
1929
(cmd != AR6000_XIOCTL_ADD_AP_INTERFACE) &&
1930
(cmd != AR6000_XIOCTL_REMOVE_AP_INTERFACE) &&
1931
(cmd != AR6000_IOCTL_WMI_GETREV)))
1940
case IEEE80211_IOCTL_SETPARAM:
1943
int *ptr = (int *)rq->ifr_ifru.ifru_newname;
1944
if (ar->arWmiReady == false) {
1949
ret = ar6000_ioctl_setparam(ar,param,value);
1953
case IEEE80211_IOCTL_SETKEY:
1955
struct ieee80211req_key keydata;
1956
if (ar->arWmiReady == false) {
1958
} else if (copy_from_user(&keydata, userdata,
1959
sizeof(struct ieee80211req_key))) {
1962
ar6000_ioctl_setkey(ar, &keydata);
1966
case IEEE80211_IOCTL_DELKEY:
1967
case IEEE80211_IOCTL_SETOPTIE:
1972
case IEEE80211_IOCTL_SETMLME:
1974
struct ieee80211req_mlme mlme;
1975
if (ar->arWmiReady == false) {
1977
} else if (copy_from_user(&mlme, userdata,
1978
sizeof(struct ieee80211req_mlme))) {
1981
switch (mlme.im_op) {
1982
case IEEE80211_MLME_AUTHORIZE:
1983
A_PRINTF("setmlme AUTHORIZE %02X:%02X\n",
1984
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1986
case IEEE80211_MLME_UNAUTHORIZE:
1987
A_PRINTF("setmlme UNAUTHORIZE %02X:%02X\n",
1988
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1990
case IEEE80211_MLME_DEAUTH:
1991
A_PRINTF("setmlme DEAUTH %02X:%02X\n",
1992
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1993
//remove_sta(ar, mlme.im_macaddr);
1995
case IEEE80211_MLME_DISASSOC:
1996
A_PRINTF("setmlme DISASSOC %02X:%02X\n",
1997
mlme.im_macaddr[4], mlme.im_macaddr[5]);
1998
//remove_sta(ar, mlme.im_macaddr);
2005
wmi_ap_set_mlme(ar->arWmi, mlme.im_op, mlme.im_macaddr,
2010
case IEEE80211_IOCTL_ADDPMKID:
2012
struct ieee80211req_addpmkid req;
2013
if (ar->arWmiReady == false) {
2015
} else if (copy_from_user(&req, userdata, sizeof(struct ieee80211req_addpmkid))) {
2020
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",
2021
req.pi_bssid[0], req.pi_bssid[1], req.pi_bssid[2],
2022
req.pi_bssid[3], req.pi_bssid[4], req.pi_bssid[5],
2025
status = wmi_setPmkid_cmd(ar->arWmi, req.pi_bssid, req.pi_pmkid,
2035
#ifdef CONFIG_HOST_TCMD_SUPPORT
2036
case AR6000_XIOCTL_TCMD_CONT_TX:
2040
if ((ar->tcmdPm == TCMD_PM_SLEEP) ||
2041
(ar->tcmdPm == TCMD_PM_DEEPSLEEP))
2043
A_PRINTF("Can NOT send tx tcmd when target is asleep! \n");
2048
if(copy_from_user(&txCmd, userdata, sizeof(TCMD_CONT_TX))) {
2052
wmi_test_cmd(ar->arWmi,(u8 *)&txCmd, sizeof(TCMD_CONT_TX));
2056
case AR6000_XIOCTL_TCMD_CONT_RX:
2060
if ((ar->tcmdPm == TCMD_PM_SLEEP) ||
2061
(ar->tcmdPm == TCMD_PM_DEEPSLEEP))
2063
A_PRINTF("Can NOT send rx tcmd when target is asleep! \n");
2067
if(copy_from_user(&rxCmd, userdata, sizeof(TCMD_CONT_RX))) {
2074
case TCMD_CONT_RX_PROMIS:
2075
case TCMD_CONT_RX_FILTER:
2076
case TCMD_CONT_RX_SETMAC:
2077
case TCMD_CONT_RX_SET_ANT_SWITCH_TABLE:
2078
wmi_test_cmd(ar->arWmi,(u8 *)&rxCmd,
2079
sizeof(TCMD_CONT_RX));
2080
tcmdRxFreq = rxCmd.u.para.freq;
2082
case TCMD_CONT_RX_REPORT:
2083
ar6000_ioctl_tcmd_get_rx_report(dev, rq,
2084
(u8 *)&rxCmd, sizeof(TCMD_CONT_RX));
2087
A_PRINTF("Unknown Cont Rx mode: %d\n",rxCmd.act);
2093
case AR6000_XIOCTL_TCMD_PM:
2097
if(copy_from_user(&pmCmd, userdata, sizeof(TCMD_PM))) {
2101
ar->tcmdPm = pmCmd.mode;
2102
wmi_test_cmd(ar->arWmi, (u8 *)&pmCmd, sizeof(TCMD_PM));
2105
#endif /* CONFIG_HOST_TCMD_SUPPORT */
2107
case AR6000_XIOCTL_BMI_DONE:
2110
rtnl_lock(); /* ar6000_init expects to be called holding rtnl lock */
2111
ret = ar6000_init(dev);
2116
ret = BMIDone(hifDevice);
2120
case AR6000_XIOCTL_BMI_READ_MEMORY:
2121
if (get_user(address, (unsigned int *)userdata) ||
2122
get_user(length, (unsigned int *)userdata + 1)) {
2127
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Read Memory (address: 0x%x, length: %d)\n",
2129
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2130
A_MEMZERO(buffer, length);
2131
ret = BMIReadMemory(hifDevice, address, buffer, length);
2132
if (copy_to_user(rq->ifr_data, buffer, length)) {
2141
case AR6000_XIOCTL_BMI_WRITE_MEMORY:
2142
if (get_user(address, (unsigned int *)userdata) ||
2143
get_user(length, (unsigned int *)userdata + 1)) {
2147
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Write Memory (address: 0x%x, length: %d)\n",
2149
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2150
A_MEMZERO(buffer, length);
2151
if (copy_from_user(buffer, &userdata[sizeof(address) +
2152
sizeof(length)], length))
2156
ret = BMIWriteMemory(hifDevice, address, buffer, length);
2164
case AR6000_XIOCTL_BMI_TEST:
2165
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("No longer supported\n"));
2169
case AR6000_XIOCTL_BMI_EXECUTE:
2170
if (get_user(address, (unsigned int *)userdata) ||
2171
get_user(param, (unsigned int *)userdata + 1)) {
2175
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Execute (address: 0x%x, param: %d)\n",
2177
ret = BMIExecute(hifDevice, address, (u32 *)¶m);
2179
if (put_user(param, (unsigned int *)rq->ifr_data)) {
2185
case AR6000_XIOCTL_BMI_SET_APP_START:
2186
if (get_user(address, (unsigned int *)userdata)) {
2190
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Set App Start (address: 0x%x)\n", address));
2191
ret = BMISetAppStart(hifDevice, address);
2194
case AR6000_XIOCTL_BMI_READ_SOC_REGISTER:
2195
if (get_user(address, (unsigned int *)userdata)) {
2199
ret = BMIReadSOCRegister(hifDevice, address, (u32 *)¶m);
2201
if (put_user(param, (unsigned int *)rq->ifr_data)) {
2207
case AR6000_XIOCTL_BMI_WRITE_SOC_REGISTER:
2208
if (get_user(address, (unsigned int *)userdata) ||
2209
get_user(param, (unsigned int *)userdata + 1)) {
2213
ret = BMIWriteSOCRegister(hifDevice, address, param);
2216
#ifdef HTC_RAW_INTERFACE
2217
case AR6000_XIOCTL_HTC_RAW_OPEN:
2219
if (!arRawIfEnabled(ar)) {
2220
/* make sure block size is set in case the target was reset since last
2221
* BMI phase (i.e. flashup downloads) */
2222
ret = ar6000_set_htc_params(ar->arHifDevice,
2224
0, /* use default yield */
2225
0 /* use default number of HTC ctrl buffers */
2230
/* Terminate the BMI phase */
2231
ret = BMIDone(hifDevice);
2233
ret = ar6000_htc_raw_open(ar);
2238
case AR6000_XIOCTL_HTC_RAW_CLOSE:
2239
if (arRawIfEnabled(ar)) {
2240
ret = ar6000_htc_raw_close(ar);
2241
arRawIfEnabled(ar) = false;
2247
case AR6000_XIOCTL_HTC_RAW_READ:
2248
if (arRawIfEnabled(ar)) {
2249
unsigned int streamID;
2250
if (get_user(streamID, (unsigned int *)userdata) ||
2251
get_user(length, (unsigned int *)userdata + 1)) {
2255
buffer = (unsigned char*)rq->ifr_data + sizeof(length);
2256
ret = ar6000_htc_raw_read(ar, (HTC_RAW_STREAM_ID)streamID,
2257
(char*)buffer, length);
2258
if (put_user(ret, (unsigned int *)rq->ifr_data)) {
2267
case AR6000_XIOCTL_HTC_RAW_WRITE:
2268
if (arRawIfEnabled(ar)) {
2269
unsigned int streamID;
2270
if (get_user(streamID, (unsigned int *)userdata) ||
2271
get_user(length, (unsigned int *)userdata + 1)) {
2275
buffer = (unsigned char*)userdata + sizeof(streamID) + sizeof(length);
2276
ret = ar6000_htc_raw_write(ar, (HTC_RAW_STREAM_ID)streamID,
2277
(char*)buffer, length);
2278
if (put_user(ret, (unsigned int *)rq->ifr_data)) {
2286
#endif /* HTC_RAW_INTERFACE */
2288
case AR6000_XIOCTL_BMI_LZ_STREAM_START:
2289
if (get_user(address, (unsigned int *)userdata)) {
2293
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Start Compressed Stream (address: 0x%x)\n", address));
2294
ret = BMILZStreamStart(hifDevice, address);
2297
case AR6000_XIOCTL_BMI_LZ_DATA:
2298
if (get_user(length, (unsigned int *)userdata)) {
2302
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Send Compressed Data (length: %d)\n", length));
2303
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2304
A_MEMZERO(buffer, length);
2305
if (copy_from_user(buffer, &userdata[sizeof(length)], length))
2309
ret = BMILZData(hifDevice, buffer, length);
2317
#if defined(CONFIG_TARGET_PROFILE_SUPPORT)
2319
* Optional support for Target-side profiling.
2320
* Not needed in production.
2323
/* Configure Target-side profiling */
2324
case AR6000_XIOCTL_PROF_CFG:
2328
if (get_user(period, (unsigned int *)userdata) ||
2329
get_user(nbins, (unsigned int *)userdata + 1)) {
2334
if (wmi_prof_cfg_cmd(ar->arWmi, period, nbins) != 0) {
2341
/* Start a profiling bucket/bin at the specified address */
2342
case AR6000_XIOCTL_PROF_ADDR_SET:
2345
if (get_user(addr, (unsigned int *)userdata)) {
2350
if (wmi_prof_addr_set_cmd(ar->arWmi, addr) != 0) {
2357
/* START Target-side profiling */
2358
case AR6000_XIOCTL_PROF_START:
2359
wmi_prof_start_cmd(ar->arWmi);
2362
/* STOP Target-side profiling */
2363
case AR6000_XIOCTL_PROF_STOP:
2364
wmi_prof_stop_cmd(ar->arWmi);
2366
case AR6000_XIOCTL_PROF_COUNT_GET:
2368
if (ar->bIsDestroyProgress) {
2372
if (ar->arWmiReady == false) {
2376
if (down_interruptible(&ar->arSem)) {
2380
if (ar->bIsDestroyProgress) {
2386
prof_count_available = false;
2387
ret = prof_count_get(dev);
2394
/* Wait for Target to respond. */
2395
wait_event_interruptible(arEvent, prof_count_available);
2396
if (signal_pending(current)) {
2399
if (copy_to_user(userdata, &prof_count_results,
2400
sizeof(prof_count_results)))
2408
#endif /* CONFIG_TARGET_PROFILE_SUPPORT */
2410
case AR6000_IOCTL_WMI_GETREV:
2412
if (copy_to_user(rq->ifr_data, &ar->arVersion,
2413
sizeof(ar->arVersion)))
2419
case AR6000_IOCTL_WMI_SETPWR:
2421
WMI_POWER_MODE_CMD pwrModeCmd;
2423
if (ar->arWmiReady == false) {
2425
} else if (copy_from_user(&pwrModeCmd, userdata,
2426
sizeof(pwrModeCmd)))
2430
if (wmi_powermode_cmd(ar->arWmi, pwrModeCmd.powerMode)
2438
case AR6000_IOCTL_WMI_SET_IBSS_PM_CAPS:
2440
WMI_IBSS_PM_CAPS_CMD ibssPmCaps;
2442
if (ar->arWmiReady == false) {
2444
} else if (copy_from_user(&ibssPmCaps, userdata,
2445
sizeof(ibssPmCaps)))
2449
if (wmi_ibsspmcaps_cmd(ar->arWmi, ibssPmCaps.power_saving, ibssPmCaps.ttl,
2450
ibssPmCaps.atim_windows, ibssPmCaps.timeout_value) != 0)
2454
AR6000_SPIN_LOCK(&ar->arLock, 0);
2455
ar->arIbssPsEnable = ibssPmCaps.power_saving;
2456
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2460
case AR6000_XIOCTL_WMI_SET_AP_PS:
2462
WMI_AP_PS_CMD apPsCmd;
2464
if (ar->arWmiReady == false) {
2466
} else if (copy_from_user(&apPsCmd, userdata,
2471
if (wmi_apps_cmd(ar->arWmi, apPsCmd.psType, apPsCmd.idle_time,
2472
apPsCmd.ps_period, apPsCmd.sleep_period) != 0)
2479
case AR6000_IOCTL_WMI_SET_PMPARAMS:
2481
WMI_POWER_PARAMS_CMD pmParams;
2483
if (ar->arWmiReady == false) {
2485
} else if (copy_from_user(&pmParams, userdata,
2490
if (wmi_pmparams_cmd(ar->arWmi, pmParams.idle_period,
2491
pmParams.pspoll_number,
2492
pmParams.dtim_policy,
2493
pmParams.tx_wakeup_policy,
2494
pmParams.num_tx_to_wakeup,
2495
#if WLAN_CONFIG_IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN
2496
IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN
2498
SEND_POWER_SAVE_FAIL_EVENT_ALWAYS
2507
case AR6000_IOCTL_WMI_SETSCAN:
2509
if (ar->arWmiReady == false) {
2511
} else if (copy_from_user(&ar->scParams, userdata,
2512
sizeof(ar->scParams)))
2516
if (CAN_SCAN_IN_CONNECT(ar->scParams.scanCtrlFlags)) {
2517
ar->arSkipScan = false;
2519
ar->arSkipScan = true;
2522
if (wmi_scanparams_cmd(ar->arWmi, ar->scParams.fg_start_period,
2523
ar->scParams.fg_end_period,
2524
ar->scParams.bg_period,
2525
ar->scParams.minact_chdwell_time,
2526
ar->scParams.maxact_chdwell_time,
2527
ar->scParams.pas_chdwell_time,
2528
ar->scParams.shortScanRatio,
2529
ar->scParams.scanCtrlFlags,
2530
ar->scParams.max_dfsch_act_time,
2531
ar->scParams.maxact_scan_per_ssid) != 0)
2538
case AR6000_IOCTL_WMI_SETLISTENINT:
2540
WMI_LISTEN_INT_CMD listenCmd;
2542
if (ar->arWmiReady == false) {
2544
} else if (copy_from_user(&listenCmd, userdata,
2549
if (wmi_listeninterval_cmd(ar->arWmi, listenCmd.listenInterval, listenCmd.numBeacons) != 0) {
2552
AR6000_SPIN_LOCK(&ar->arLock, 0);
2553
ar->arListenIntervalT = listenCmd.listenInterval;
2554
ar->arListenIntervalB = listenCmd.numBeacons;
2555
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2561
case AR6000_IOCTL_WMI_SET_BMISS_TIME:
2563
WMI_BMISS_TIME_CMD bmissCmd;
2565
if (ar->arWmiReady == false) {
2567
} else if (copy_from_user(&bmissCmd, userdata,
2572
if (wmi_bmisstime_cmd(ar->arWmi, bmissCmd.bmissTime, bmissCmd.numBeacons) != 0) {
2578
case AR6000_IOCTL_WMI_SETBSSFILTER:
2580
WMI_BSS_FILTER_CMD filt;
2582
if (ar->arWmiReady == false) {
2584
} else if (copy_from_user(&filt, userdata,
2589
if (wmi_bssfilter_cmd(ar->arWmi, filt.bssFilter, filt.ieMask)
2593
ar->arUserBssFilter = filt.bssFilter;
2599
case AR6000_IOCTL_WMI_SET_SNRTHRESHOLD:
2601
ret = ar6000_ioctl_set_snr_threshold(dev, rq);
2604
case AR6000_XIOCTL_WMI_SET_RSSITHRESHOLD:
2606
ret = ar6000_ioctl_set_rssi_threshold(dev, rq);
2609
case AR6000_XIOCTL_WMI_CLR_RSSISNR:
2611
if (ar->arWmiReady == false) {
2614
ret = wmi_clr_rssi_snr(ar->arWmi);
2617
case AR6000_XIOCTL_WMI_SET_LQTHRESHOLD:
2619
ret = ar6000_ioctl_set_lq_threshold(dev, rq);
2622
case AR6000_XIOCTL_WMI_SET_LPREAMBLE:
2624
WMI_SET_LPREAMBLE_CMD setLpreambleCmd;
2626
if (ar->arWmiReady == false) {
2628
} else if (copy_from_user(&setLpreambleCmd, userdata,
2629
sizeof(setLpreambleCmd)))
2633
if (wmi_set_lpreamble_cmd(ar->arWmi, setLpreambleCmd.status,
2634
#if WLAN_CONFIG_DONOT_IGNORE_BARKER_IN_ERP
2635
WMI_DONOT_IGNORE_BARKER_IN_ERP
2637
WMI_IGNORE_BARKER_IN_ERP
2647
case AR6000_XIOCTL_WMI_SET_RTS:
2649
WMI_SET_RTS_CMD rtsCmd;
2650
if (ar->arWmiReady == false) {
2652
} else if (copy_from_user(&rtsCmd, userdata,
2657
ar->arRTS = rtsCmd.threshold;
2658
if (wmi_set_rts_cmd(ar->arWmi, rtsCmd.threshold)
2667
case AR6000_XIOCTL_WMI_SET_WMM:
2669
ret = ar6000_ioctl_set_wmm(dev, rq);
2672
case AR6000_XIOCTL_WMI_SET_QOS_SUPP:
2674
ret = ar6000_ioctl_set_qos_supp(dev, rq);
2677
case AR6000_XIOCTL_WMI_SET_TXOP:
2679
ret = ar6000_ioctl_set_txop(dev, rq);
2682
case AR6000_XIOCTL_WMI_GET_RD:
2684
ret = ar6000_ioctl_get_rd(dev, rq);
2687
case AR6000_IOCTL_WMI_SET_CHANNELPARAMS:
2689
ret = ar6000_ioctl_set_channelParams(dev, rq);
2692
case AR6000_IOCTL_WMI_SET_PROBEDSSID:
2694
ret = ar6000_ioctl_set_probedSsid(dev, rq);
2697
case AR6000_IOCTL_WMI_SET_BADAP:
2699
ret = ar6000_ioctl_set_badAp(dev, rq);
2702
case AR6000_IOCTL_WMI_CREATE_QOS:
2704
ret = ar6000_ioctl_create_qos(dev, rq);
2707
case AR6000_IOCTL_WMI_DELETE_QOS:
2709
ret = ar6000_ioctl_delete_qos(dev, rq);
2712
case AR6000_IOCTL_WMI_GET_QOS_QUEUE:
2714
ret = ar6000_ioctl_get_qos_queue(dev, rq);
2717
case AR6000_IOCTL_WMI_GET_TARGET_STATS:
2719
ret = ar6000_ioctl_get_target_stats(dev, rq);
2722
case AR6000_IOCTL_WMI_SET_ERROR_REPORT_BITMASK:
2724
ret = ar6000_ioctl_set_error_report_bitmask(dev, rq);
2727
case AR6000_IOCTL_WMI_SET_ASSOC_INFO:
2729
WMI_SET_ASSOC_INFO_CMD cmd;
2730
u8 assocInfo[WMI_MAX_ASSOC_INFO_LEN];
2732
if (ar->arWmiReady == false) {
2737
if (get_user(cmd.ieType, userdata)) {
2741
if (cmd.ieType >= WMI_MAX_ASSOC_INFO_TYPE) {
2746
if (get_user(cmd.bufferSize, userdata + 1) ||
2747
(cmd.bufferSize > WMI_MAX_ASSOC_INFO_LEN) ||
2748
copy_from_user(assocInfo, userdata + 2, cmd.bufferSize)) {
2752
if (wmi_associnfo_cmd(ar->arWmi, cmd.ieType,
2753
cmd.bufferSize, assocInfo) != 0) {
2759
case AR6000_IOCTL_WMI_SET_ACCESS_PARAMS:
2761
ret = ar6000_ioctl_set_access_params(dev, rq);
2764
case AR6000_IOCTL_WMI_SET_DISC_TIMEOUT:
2766
ret = ar6000_ioctl_set_disconnect_timeout(dev, rq);
2769
case AR6000_XIOCTL_FORCE_TARGET_RESET:
2771
if (ar->arHtcTarget)
2773
// HTCForceReset(htcTarget);
2777
AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("ar6000_ioctl cannot attempt reset.\n"));
2781
case AR6000_XIOCTL_TARGET_INFO:
2782
case AR6000_XIOCTL_CHECK_TARGET_READY: /* backwards compatibility */
2784
/* If we made it to here, then the Target exists and is ready. */
2786
if (cmd == AR6000_XIOCTL_TARGET_INFO) {
2787
if (copy_to_user((u32 *)rq->ifr_data, &ar->arVersion.target_ver,
2788
sizeof(ar->arVersion.target_ver)))
2792
if (copy_to_user(((u32 *)rq->ifr_data)+1, &ar->arTargetType,
2793
sizeof(ar->arTargetType)))
2800
case AR6000_XIOCTL_WMI_SET_HB_CHALLENGE_RESP_PARAMS:
2802
WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD hbparam;
2804
if (copy_from_user(&hbparam, userdata, sizeof(hbparam)))
2808
AR6000_SPIN_LOCK(&ar->arLock, 0);
2809
/* Start a cyclic timer with the parameters provided. */
2810
if (hbparam.frequency) {
2811
ar->arHBChallengeResp.frequency = hbparam.frequency;
2813
if (hbparam.threshold) {
2814
ar->arHBChallengeResp.missThres = hbparam.threshold;
2817
/* Delete the pending timer and start a new one */
2818
if (timer_pending(&ar->arHBChallengeResp.timer)) {
2819
A_UNTIMEOUT(&ar->arHBChallengeResp.timer);
2821
A_TIMEOUT_MS(&ar->arHBChallengeResp.timer, ar->arHBChallengeResp.frequency * 1000, 0);
2822
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2826
case AR6000_XIOCTL_WMI_GET_HB_CHALLENGE_RESP:
2830
if (copy_from_user(&cookie, userdata, sizeof(cookie))) {
2835
/* Send the challenge on the control channel */
2836
if (wmi_get_challenge_resp_cmd(ar->arWmi, cookie, APP_HB_CHALLENGE) != 0) {
2843
case AR6000_XIOCTL_USER_SETKEYS:
2846
ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_RUN;
2848
if (copy_from_user(&ar->user_key_ctrl, userdata,
2849
sizeof(ar->user_key_ctrl)))
2855
A_PRINTF("ar6000 USER set key %x\n", ar->user_key_ctrl);
2858
#endif /* USER_KEYS */
2860
#ifdef CONFIG_HOST_GPIO_SUPPORT
2861
case AR6000_XIOCTL_GPIO_OUTPUT_SET:
2863
struct ar6000_gpio_output_set_cmd_s gpio_output_set_cmd;
2865
if (ar->bIsDestroyProgress) {
2869
if (ar->arWmiReady == false) {
2873
if (down_interruptible(&ar->arSem)) {
2877
if (ar->bIsDestroyProgress) {
2883
if (copy_from_user(&gpio_output_set_cmd, userdata,
2884
sizeof(gpio_output_set_cmd)))
2888
ret = ar6000_gpio_output_set(dev,
2889
gpio_output_set_cmd.set_mask,
2890
gpio_output_set_cmd.clear_mask,
2891
gpio_output_set_cmd.enable_mask,
2892
gpio_output_set_cmd.disable_mask);
2900
case AR6000_XIOCTL_GPIO_INPUT_GET:
2902
if (ar->bIsDestroyProgress) {
2906
if (ar->arWmiReady == false) {
2910
if (down_interruptible(&ar->arSem)) {
2914
if (ar->bIsDestroyProgress) {
2920
ret = ar6000_gpio_input_get(dev);
2927
/* Wait for Target to respond. */
2928
wait_event_interruptible(arEvent, gpio_data_available);
2929
if (signal_pending(current)) {
2932
A_ASSERT(gpio_reg_results.gpioreg_id == GPIO_ID_NONE);
2934
if (copy_to_user(userdata, &gpio_reg_results.value,
2935
sizeof(gpio_reg_results.value)))
2943
case AR6000_XIOCTL_GPIO_REGISTER_SET:
2945
struct ar6000_gpio_register_cmd_s gpio_register_cmd;
2947
if (ar->bIsDestroyProgress) {
2951
if (ar->arWmiReady == false) {
2955
if (down_interruptible(&ar->arSem)) {
2959
if (ar->bIsDestroyProgress) {
2965
if (copy_from_user(&gpio_register_cmd, userdata,
2966
sizeof(gpio_register_cmd)))
2970
ret = ar6000_gpio_register_set(dev,
2971
gpio_register_cmd.gpioreg_id,
2972
gpio_register_cmd.value);
2977
/* Wait for acknowledgement from Target */
2978
wait_event_interruptible(arEvent, gpio_ack_received);
2979
if (signal_pending(current)) {
2986
case AR6000_XIOCTL_GPIO_REGISTER_GET:
2988
struct ar6000_gpio_register_cmd_s gpio_register_cmd;
2990
if (ar->bIsDestroyProgress) {
2994
if (ar->arWmiReady == false) {
2998
if (down_interruptible(&ar->arSem)) {
3002
if (ar->bIsDestroyProgress) {
3008
if (copy_from_user(&gpio_register_cmd, userdata,
3009
sizeof(gpio_register_cmd)))
3013
ret = ar6000_gpio_register_get(dev, gpio_register_cmd.gpioreg_id);
3020
/* Wait for Target to respond. */
3021
wait_event_interruptible(arEvent, gpio_data_available);
3022
if (signal_pending(current)) {
3025
A_ASSERT(gpio_register_cmd.gpioreg_id == gpio_reg_results.gpioreg_id);
3026
if (copy_to_user(userdata, &gpio_reg_results,
3027
sizeof(gpio_reg_results)))
3036
case AR6000_XIOCTL_GPIO_INTR_ACK:
3038
struct ar6000_gpio_intr_ack_cmd_s gpio_intr_ack_cmd;
3040
if (ar->bIsDestroyProgress) {
3044
if (ar->arWmiReady == false) {
3048
if (down_interruptible(&ar->arSem)) {
3052
if (ar->bIsDestroyProgress) {
3058
if (copy_from_user(&gpio_intr_ack_cmd, userdata,
3059
sizeof(gpio_intr_ack_cmd)))
3063
ret = ar6000_gpio_intr_ack(dev, gpio_intr_ack_cmd.ack_mask);
3071
case AR6000_XIOCTL_GPIO_INTR_WAIT:
3073
/* Wait for Target to report an interrupt. */
3074
wait_event_interruptible(arEvent, gpio_intr_available);
3076
if (signal_pending(current)) {
3079
if (copy_to_user(userdata, &gpio_intr_results,
3080
sizeof(gpio_intr_results)))
3087
#endif /* CONFIG_HOST_GPIO_SUPPORT */
3089
case AR6000_XIOCTL_DBGLOG_CFG_MODULE:
3091
struct ar6000_dbglog_module_config_s config;
3093
if (copy_from_user(&config, userdata, sizeof(config))) {
3098
/* Send the challenge on the control channel */
3099
if (wmi_config_debug_module_cmd(ar->arWmi, config.mmask,
3100
config.tsr, config.rep,
3101
config.size, config.valid) != 0)
3109
case AR6000_XIOCTL_DBGLOG_GET_DEBUG_LOGS:
3111
/* Send the challenge on the control channel */
3112
if (ar6000_dbglog_get_debug_logs(ar) != 0)
3120
case AR6000_XIOCTL_SET_ADHOC_BSSID:
3122
WMI_SET_ADHOC_BSSID_CMD adhocBssid;
3124
if (ar->arWmiReady == false) {
3126
} else if (copy_from_user(&adhocBssid, userdata,
3127
sizeof(adhocBssid)))
3130
} else if (memcmp(adhocBssid.bssid, bcast_mac,
3131
AR6000_ETH_ADDR_LEN) == 0)
3136
memcpy(ar->arReqBssid, adhocBssid.bssid, sizeof(ar->arReqBssid));
3141
case AR6000_XIOCTL_SET_OPT_MODE:
3143
WMI_SET_OPT_MODE_CMD optModeCmd;
3144
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
3146
if (ar->arWmiReady == false) {
3148
} else if (copy_from_user(&optModeCmd, userdata,
3149
sizeof(optModeCmd)))
3152
} else if (ar->arConnected && optModeCmd.optMode == SPECIAL_ON) {
3155
} else if (wmi_set_opt_mode_cmd(ar->arWmi, optModeCmd.optMode)
3163
case AR6000_XIOCTL_OPT_SEND_FRAME:
3165
WMI_OPT_TX_FRAME_CMD optTxFrmCmd;
3166
u8 data[MAX_OPT_DATA_LEN];
3168
if (ar->arWmiReady == false) {
3173
if (copy_from_user(&optTxFrmCmd, userdata, sizeof(optTxFrmCmd))) {
3178
if (optTxFrmCmd.optIEDataLen > MAX_OPT_DATA_LEN) {
3183
if (copy_from_user(data, userdata+sizeof(WMI_OPT_TX_FRAME_CMD) - 1,
3184
optTxFrmCmd.optIEDataLen)) {
3189
ret = wmi_opt_tx_frame_cmd(ar->arWmi,
3190
optTxFrmCmd.frmType,
3191
optTxFrmCmd.dstAddr,
3193
optTxFrmCmd.optIEDataLen,
3197
case AR6000_XIOCTL_WMI_SETRETRYLIMITS:
3199
WMI_SET_RETRY_LIMITS_CMD setRetryParams;
3201
if (ar->arWmiReady == false) {
3203
} else if (copy_from_user(&setRetryParams, userdata,
3204
sizeof(setRetryParams)))
3208
if (wmi_set_retry_limits_cmd(ar->arWmi, setRetryParams.frameType,
3209
setRetryParams.trafficClass,
3210
setRetryParams.maxRetries,
3211
setRetryParams.enableNotify) != 0)
3215
AR6000_SPIN_LOCK(&ar->arLock, 0);
3216
ar->arMaxRetries = setRetryParams.maxRetries;
3217
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3222
case AR6000_XIOCTL_SET_BEACON_INTVAL:
3224
WMI_BEACON_INT_CMD bIntvlCmd;
3226
if (ar->arWmiReady == false) {
3228
} else if (copy_from_user(&bIntvlCmd, userdata,
3232
} else if (wmi_set_adhoc_bconIntvl_cmd(ar->arWmi, bIntvlCmd.beaconInterval)
3238
ar->ap_beacon_interval = bIntvlCmd.beaconInterval;
3239
ar->ap_profile_flag = 1; /* There is a change in profile */
3243
case IEEE80211_IOCTL_SETAUTHALG:
3245
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
3246
struct ieee80211req_authalg req;
3248
if (ar->arWmiReady == false) {
3250
} else if (copy_from_user(&req, userdata,
3251
sizeof(struct ieee80211req_authalg)))
3255
if (req.auth_alg & AUTH_ALG_OPEN_SYSTEM) {
3256
ar->arDot11AuthMode |= OPEN_AUTH;
3257
ar->arPairwiseCrypto = NONE_CRYPT;
3258
ar->arGroupCrypto = NONE_CRYPT;
3260
if (req.auth_alg & AUTH_ALG_SHARED_KEY) {
3261
ar->arDot11AuthMode |= SHARED_AUTH;
3262
ar->arPairwiseCrypto = WEP_CRYPT;
3263
ar->arGroupCrypto = WEP_CRYPT;
3264
ar->arAuthMode = NONE_AUTH;
3266
if (req.auth_alg == AUTH_ALG_LEAP) {
3267
ar->arDot11AuthMode = LEAP_AUTH;
3273
case AR6000_XIOCTL_SET_VOICE_PKT_SIZE:
3274
ret = ar6000_xioctl_set_voice_pkt_size(dev, userdata);
3277
case AR6000_XIOCTL_SET_MAX_SP:
3278
ret = ar6000_xioctl_set_max_sp_len(dev, userdata);
3281
case AR6000_XIOCTL_WMI_GET_ROAM_TBL:
3282
ret = ar6000_ioctl_get_roam_tbl(dev, rq);
3284
case AR6000_XIOCTL_WMI_SET_ROAM_CTRL:
3285
ret = ar6000_ioctl_set_roam_ctrl(dev, userdata);
3287
case AR6000_XIOCTRL_WMI_SET_POWERSAVE_TIMERS:
3288
ret = ar6000_ioctl_set_powersave_timers(dev, userdata);
3290
case AR6000_XIOCTRL_WMI_GET_POWER_MODE:
3291
ret = ar6000_ioctl_get_power_mode(dev, rq);
3293
case AR6000_XIOCTRL_WMI_SET_WLAN_STATE:
3295
AR6000_WLAN_STATE state;
3296
if (get_user(state, (unsigned int *)userdata))
3298
else if (ar6000_set_wlan_state(ar, state) != 0)
3302
case AR6000_XIOCTL_WMI_GET_ROAM_DATA:
3303
ret = ar6000_ioctl_get_roam_data(dev, rq);
3306
case AR6000_XIOCTL_WMI_SET_BT_STATUS:
3307
ret = ar6000_xioctl_set_bt_status_cmd(dev, userdata);
3310
case AR6000_XIOCTL_WMI_SET_BT_PARAMS:
3311
ret = ar6000_xioctl_set_bt_params_cmd(dev, userdata);
3314
case AR6000_XIOCTL_WMI_SET_BTCOEX_FE_ANT:
3315
ret = ar6000_xioctl_set_btcoex_fe_ant_cmd(dev, userdata);
3318
case AR6000_XIOCTL_WMI_SET_BTCOEX_COLOCATED_BT_DEV:
3319
ret = ar6000_xioctl_set_btcoex_colocated_bt_dev_cmd(dev, userdata);
3322
case AR6000_XIOCTL_WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG:
3323
ret = ar6000_xioctl_set_btcoex_btinquiry_page_config_cmd(dev, userdata);
3326
case AR6000_XIOCTL_WMI_SET_BTCOEX_SCO_CONFIG:
3327
ret = ar6000_xioctl_set_btcoex_sco_config_cmd( dev, userdata);
3330
case AR6000_XIOCTL_WMI_SET_BTCOEX_A2DP_CONFIG:
3331
ret = ar6000_xioctl_set_btcoex_a2dp_config_cmd(dev, userdata);
3334
case AR6000_XIOCTL_WMI_SET_BTCOEX_ACLCOEX_CONFIG:
3335
ret = ar6000_xioctl_set_btcoex_aclcoex_config_cmd(dev, userdata);
3338
case AR6000_XIOCTL_WMI_SET_BTCOEX_DEBUG:
3339
ret = ar60000_xioctl_set_btcoex_debug_cmd(dev, userdata);
3342
case AR6000_XIOCTL_WMI_SET_BT_OPERATING_STATUS:
3343
ret = ar6000_xioctl_set_btcoex_bt_operating_status_cmd(dev, userdata);
3346
case AR6000_XIOCTL_WMI_GET_BTCOEX_CONFIG:
3347
ret = ar6000_xioctl_get_btcoex_config_cmd(dev, userdata, rq);
3350
case AR6000_XIOCTL_WMI_GET_BTCOEX_STATS:
3351
ret = ar6000_xioctl_get_btcoex_stats_cmd(dev, userdata, rq);
3354
case AR6000_XIOCTL_WMI_STARTSCAN:
3356
WMI_START_SCAN_CMD setStartScanCmd, *cmdp;
3358
if (ar->arWmiReady == false) {
3360
} else if (copy_from_user(&setStartScanCmd, userdata,
3361
sizeof(setStartScanCmd)))
3365
if (setStartScanCmd.numChannels > 1) {
3366
cmdp = A_MALLOC(130);
3367
if (copy_from_user(cmdp, userdata,
3369
((setStartScanCmd.numChannels - 1) *
3377
cmdp = &setStartScanCmd;
3380
if (wmi_startscan_cmd(ar->arWmi, cmdp->scanType,
3383
cmdp->homeDwellTime,
3384
cmdp->forceScanInterval,
3386
cmdp->channelList) != 0)
3393
case AR6000_XIOCTL_WMI_SETFIXRATES:
3395
WMI_FIX_RATES_CMD setFixRatesCmd;
3398
if (ar->arWmiReady == false) {
3400
} else if (copy_from_user(&setFixRatesCmd, userdata,
3401
sizeof(setFixRatesCmd)))
3405
returnStatus = wmi_set_fixrates_cmd(ar->arWmi, setFixRatesCmd.fixRateMask);
3406
if (returnStatus == A_EINVAL) {
3408
} else if(returnStatus != 0) {
3411
ar->ap_profile_flag = 1; /* There is a change in profile */
3417
case AR6000_XIOCTL_WMI_GETFIXRATES:
3419
WMI_FIX_RATES_CMD getFixRatesCmd;
3420
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
3423
if (ar->bIsDestroyProgress) {
3427
if (ar->arWmiReady == false) {
3432
if (down_interruptible(&ar->arSem)) {
3436
if (ar->bIsDestroyProgress) {
3441
/* Used copy_from_user/copy_to_user to access user space data */
3442
if (copy_from_user(&getFixRatesCmd, userdata, sizeof(getFixRatesCmd))) {
3445
ar->arRateMask = 0xFFFFFFFF;
3447
if (wmi_get_ratemask_cmd(ar->arWmi) != 0) {
3453
wait_event_interruptible_timeout(arEvent, ar->arRateMask != 0xFFFFFFFF, wmitimeout * HZ);
3455
if (signal_pending(current)) {
3460
getFixRatesCmd.fixRateMask = ar->arRateMask;
3463
if(copy_to_user(userdata, &getFixRatesCmd, sizeof(getFixRatesCmd))) {
3471
case AR6000_XIOCTL_WMI_SET_AUTHMODE:
3473
WMI_SET_AUTH_MODE_CMD setAuthMode;
3475
if (ar->arWmiReady == false) {
3477
} else if (copy_from_user(&setAuthMode, userdata,
3478
sizeof(setAuthMode)))
3482
if (wmi_set_authmode_cmd(ar->arWmi, setAuthMode.mode) != 0)
3489
case AR6000_XIOCTL_WMI_SET_REASSOCMODE:
3491
WMI_SET_REASSOC_MODE_CMD setReassocMode;
3493
if (ar->arWmiReady == false) {
3495
} else if (copy_from_user(&setReassocMode, userdata,
3496
sizeof(setReassocMode)))
3500
if (wmi_set_reassocmode_cmd(ar->arWmi, setReassocMode.mode) != 0)
3507
case AR6000_XIOCTL_DIAG_READ:
3510
if (get_user(addr, (unsigned int *)userdata)) {
3514
addr = TARG_VTOP(ar->arTargetType, addr);
3515
if (ar6000_ReadRegDiag(ar->arHifDevice, &addr, &data) != 0) {
3518
if (put_user(data, (unsigned int *)userdata + 1)) {
3524
case AR6000_XIOCTL_DIAG_WRITE:
3527
if (get_user(addr, (unsigned int *)userdata) ||
3528
get_user(data, (unsigned int *)userdata + 1)) {
3532
addr = TARG_VTOP(ar->arTargetType, addr);
3533
if (ar6000_WriteRegDiag(ar->arHifDevice, &addr, &data) != 0) {
3538
case AR6000_XIOCTL_WMI_SET_KEEPALIVE:
3540
WMI_SET_KEEPALIVE_CMD setKeepAlive;
3541
if (ar->arWmiReady == false) {
3544
} else if (copy_from_user(&setKeepAlive, userdata,
3545
sizeof(setKeepAlive))){
3548
if (wmi_set_keepalive_cmd(ar->arWmi, setKeepAlive.keepaliveInterval) != 0) {
3554
case AR6000_XIOCTL_WMI_SET_PARAMS:
3556
WMI_SET_PARAMS_CMD cmd;
3557
if (ar->arWmiReady == false) {
3560
} else if (copy_from_user(&cmd, userdata,
3563
} else if (copy_from_user(&cmd, userdata,
3564
sizeof(cmd) + cmd.length))
3568
if (wmi_set_params_cmd(ar->arWmi, cmd.opcode, cmd.length, cmd.buffer) != 0) {
3574
case AR6000_XIOCTL_WMI_SET_MCAST_FILTER:
3576
WMI_SET_MCAST_FILTER_CMD cmd;
3577
if (ar->arWmiReady == false) {
3580
} else if (copy_from_user(&cmd, userdata,
3584
if (wmi_set_mcast_filter_cmd(ar->arWmi, cmd.multicast_mac[0],
3585
cmd.multicast_mac[1],
3586
cmd.multicast_mac[2],
3587
cmd.multicast_mac[3]) != 0) {
3593
case AR6000_XIOCTL_WMI_DEL_MCAST_FILTER:
3595
WMI_SET_MCAST_FILTER_CMD cmd;
3596
if (ar->arWmiReady == false) {
3599
} else if (copy_from_user(&cmd, userdata,
3603
if (wmi_del_mcast_filter_cmd(ar->arWmi, cmd.multicast_mac[0],
3604
cmd.multicast_mac[1],
3605
cmd.multicast_mac[2],
3606
cmd.multicast_mac[3]) != 0) {
3612
case AR6000_XIOCTL_WMI_MCAST_FILTER:
3614
WMI_MCAST_FILTER_CMD cmd;
3615
if (ar->arWmiReady == false) {
3618
} else if (copy_from_user(&cmd, userdata,
3622
if (wmi_mcast_filter_cmd(ar->arWmi, cmd.enable) != 0) {
3628
case AR6000_XIOCTL_WMI_GET_KEEPALIVE:
3630
struct ar6_softc *ar = (struct ar6_softc *)ar6k_priv(dev);
3631
WMI_GET_KEEPALIVE_CMD getKeepAlive;
3633
if (ar->bIsDestroyProgress) {
3637
if (ar->arWmiReady == false) {
3641
if (down_interruptible(&ar->arSem)) {
3645
if (ar->bIsDestroyProgress) {
3650
if (copy_from_user(&getKeepAlive, userdata,sizeof(getKeepAlive))) {
3653
getKeepAlive.keepaliveInterval = wmi_get_keepalive_cmd(ar->arWmi);
3654
ar->arKeepaliveConfigured = 0xFF;
3655
if (wmi_get_keepalive_configured(ar->arWmi) != 0){
3660
wait_event_interruptible_timeout(arEvent, ar->arKeepaliveConfigured != 0xFF, wmitimeout * HZ);
3661
if (signal_pending(current)) {
3666
getKeepAlive.configured = ar->arKeepaliveConfigured;
3668
if (copy_to_user(userdata, &getKeepAlive, sizeof(getKeepAlive))) {
3675
case AR6000_XIOCTL_WMI_SET_APPIE:
3677
WMI_SET_APPIE_CMD appIEcmd;
3678
u8 appIeInfo[IEEE80211_APPIE_FRAME_MAX_LEN];
3681
if (ar->arWmiReady == false) {
3685
if (get_user(fType, (u32 *)userdata)) {
3689
appIEcmd.mgmtFrmType = fType;
3690
if (appIEcmd.mgmtFrmType >= IEEE80211_APPIE_NUM_OF_FRAME) {
3693
if (get_user(ieLen, (u32 *)(userdata + 4))) {
3697
appIEcmd.ieLen = ieLen;
3698
A_PRINTF("WPSIE: Type-%d, Len-%d\n",appIEcmd.mgmtFrmType, appIEcmd.ieLen);
3699
if (appIEcmd.ieLen > IEEE80211_APPIE_FRAME_MAX_LEN) {
3703
if (copy_from_user(appIeInfo, userdata + 8, appIEcmd.ieLen)) {
3706
if (wmi_set_appie_cmd(ar->arWmi, appIEcmd.mgmtFrmType,
3707
appIEcmd.ieLen, appIeInfo) != 0)
3715
case AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER:
3717
WMI_BSS_FILTER_CMD cmd;
3720
if (copy_from_user(&filterType, userdata, sizeof(u32)))
3725
if (filterType & (IEEE80211_FILTER_TYPE_BEACON |
3726
IEEE80211_FILTER_TYPE_PROBE_RESP))
3728
cmd.bssFilter = ALL_BSS_FILTER;
3730
cmd.bssFilter = NONE_BSS_FILTER;
3732
if (wmi_bssfilter_cmd(ar->arWmi, cmd.bssFilter, 0) != 0) {
3735
ar->arUserBssFilter = cmd.bssFilter;
3738
AR6000_SPIN_LOCK(&ar->arLock, 0);
3739
ar->arMgmtFilter = filterType;
3740
AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3743
case AR6000_XIOCTL_WMI_SET_WSC_STATUS:
3747
if (ar->arWmiReady == false) {
3750
} else if (copy_from_user(&wsc_status, userdata, sizeof(u32)))
3755
if (wmi_set_wsc_status_cmd(ar->arWmi, wsc_status) != 0) {
3760
case AR6000_XIOCTL_BMI_ROMPATCH_INSTALL:
3768
if (get_user(ROM_addr, (u32 *)userdata) ||
3769
get_user(RAM_addr, (u32 *)userdata + 1) ||
3770
get_user(nbytes, (u32 *)userdata + 2) ||
3771
get_user(do_activate, (u32 *)userdata + 3)) {
3775
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Install rompatch from ROM: 0x%x to RAM: 0x%x length: %d\n",
3776
ROM_addr, RAM_addr, nbytes));
3777
ret = BMIrompatchInstall(hifDevice, ROM_addr, RAM_addr,
3778
nbytes, do_activate, &rompatch_id);
3781
if (put_user(rompatch_id, (unsigned int *)rq->ifr_data)) {
3789
case AR6000_XIOCTL_BMI_ROMPATCH_UNINSTALL:
3793
if (get_user(rompatch_id, (u32 *)userdata)) {
3797
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("UNinstall rompatch_id %d\n", rompatch_id));
3798
ret = BMIrompatchUninstall(hifDevice, rompatch_id);
3802
case AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE:
3803
case AR6000_XIOCTL_BMI_ROMPATCH_DEACTIVATE:
3807
if (get_user(rompatch_count, (u32 *)userdata)) {
3811
AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Change rompatch activation count=%d\n", rompatch_count));
3812
length = sizeof(u32) * rompatch_count;
3813
if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
3814
A_MEMZERO(buffer, length);
3815
if (copy_from_user(buffer, &userdata[sizeof(rompatch_count)], length))
3819
if (cmd == AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE) {
3820
ret = BMIrompatchActivate(hifDevice, rompatch_count, (u32 *)buffer);
3822
ret = BMIrompatchDeactivate(hifDevice, rompatch_count, (u32 *)buffer);
3832
case AR6000_XIOCTL_SET_IP:
3834
WMI_SET_IP_CMD setIP;
3836
if (ar->arWmiReady == false) {
3838
} else if (copy_from_user(&setIP, userdata,
3843
if (wmi_set_ip_cmd(ar->arWmi,
3852
case AR6000_XIOCTL_WMI_SET_HOST_SLEEP_MODE:
3854
WMI_SET_HOST_SLEEP_MODE_CMD setHostSleepMode;
3856
if (ar->arWmiReady == false) {
3858
} else if (copy_from_user(&setHostSleepMode, userdata,
3859
sizeof(setHostSleepMode)))
3863
if (wmi_set_host_sleep_mode_cmd(ar->arWmi,
3864
&setHostSleepMode) != 0)
3871
case AR6000_XIOCTL_WMI_SET_WOW_MODE:
3873
WMI_SET_WOW_MODE_CMD setWowMode;
3875
if (ar->arWmiReady == false) {
3877
} else if (copy_from_user(&setWowMode, userdata,
3878
sizeof(setWowMode)))
3882
if (wmi_set_wow_mode_cmd(ar->arWmi,
3890
case AR6000_XIOCTL_WMI_GET_WOW_LIST:
3892
WMI_GET_WOW_LIST_CMD getWowList;
3894
if (ar->arWmiReady == false) {
3896
} else if (copy_from_user(&getWowList, userdata,
3897
sizeof(getWowList)))
3901
if (wmi_get_wow_list_cmd(ar->arWmi,
3909
case AR6000_XIOCTL_WMI_ADD_WOW_PATTERN:
3911
#define WOW_PATTERN_SIZE 64
3912
#define WOW_MASK_SIZE 64
3914
WMI_ADD_WOW_PATTERN_CMD cmd;
3915
u8 mask_data[WOW_PATTERN_SIZE]={0};
3916
u8 pattern_data[WOW_PATTERN_SIZE]={0};
3919
if (ar->arWmiReady == false) {
3923
if(copy_from_user(&cmd, userdata,
3924
sizeof(WMI_ADD_WOW_PATTERN_CMD)))
3929
if (copy_from_user(pattern_data,
3936
if (copy_from_user(mask_data,
3937
(userdata + 3 + cmd.filter_size),
3943
if (wmi_add_wow_pattern_cmd(ar->arWmi,
3944
&cmd, pattern_data, mask_data, cmd.filter_size) != 0)
3949
#undef WOW_PATTERN_SIZE
3950
#undef WOW_MASK_SIZE
3953
case AR6000_XIOCTL_WMI_DEL_WOW_PATTERN:
3955
WMI_DEL_WOW_PATTERN_CMD delWowPattern;
3957
if (ar->arWmiReady == false) {
3959
} else if (copy_from_user(&delWowPattern, userdata,
3960
sizeof(delWowPattern)))
3964
if (wmi_del_wow_pattern_cmd(ar->arWmi,
3965
&delWowPattern) != 0)
3972
case AR6000_XIOCTL_DUMP_HTC_CREDIT_STATE:
3973
if (ar->arHtcTarget != NULL) {
3974
#ifdef ATH_DEBUG_MODULE
3975
HTCDumpCreditStates(ar->arHtcTarget);
3976
#endif /* ATH_DEBUG_MODULE */
3977
#ifdef HTC_EP_STAT_PROFILING
3979
struct htc_endpoint_stats stats;
3982
for (i = 0; i < 5; i++) {
3983
if (HTCGetEndpointStatistics(ar->arHtcTarget,
3985
HTC_EP_STAT_SAMPLE_AND_CLEAR,
3987
A_PRINTF(KERN_ALERT"------- Profiling Endpoint : %d \n", i);
3988
A_PRINTF(KERN_ALERT"TxCreditLowIndications : %d \n", stats.TxCreditLowIndications);
3989
A_PRINTF(KERN_ALERT"TxIssued : %d \n", stats.TxIssued);
3990
A_PRINTF(KERN_ALERT"TxDropped: %d \n", stats.TxDropped);
3991
A_PRINTF(KERN_ALERT"TxPacketsBundled : %d \n", stats.TxPacketsBundled);
3992
A_PRINTF(KERN_ALERT"TxBundles : %d \n", stats.TxBundles);
3993
A_PRINTF(KERN_ALERT"TxCreditRpts : %d \n", stats.TxCreditRpts);
3994
A_PRINTF(KERN_ALERT"TxCreditsRptsFromRx : %d \n", stats.TxCreditRptsFromRx);
3995
A_PRINTF(KERN_ALERT"TxCreditsRptsFromOther : %d \n", stats.TxCreditRptsFromOther);
3996
A_PRINTF(KERN_ALERT"TxCreditsRptsFromEp0 : %d \n", stats.TxCreditRptsFromEp0);
3997
A_PRINTF(KERN_ALERT"TxCreditsFromRx : %d \n", stats.TxCreditsFromRx);
3998
A_PRINTF(KERN_ALERT"TxCreditsFromOther : %d \n", stats.TxCreditsFromOther);
3999
A_PRINTF(KERN_ALERT"TxCreditsFromEp0 : %d \n", stats.TxCreditsFromEp0);
4000
A_PRINTF(KERN_ALERT"TxCreditsConsummed : %d \n", stats.TxCreditsConsummed);
4001
A_PRINTF(KERN_ALERT"TxCreditsReturned : %d \n", stats.TxCreditsReturned);
4002
A_PRINTF(KERN_ALERT"RxReceived : %d \n", stats.RxReceived);
4003
A_PRINTF(KERN_ALERT"RxPacketsBundled : %d \n", stats.RxPacketsBundled);
4004
A_PRINTF(KERN_ALERT"RxLookAheads : %d \n", stats.RxLookAheads);
4005
A_PRINTF(KERN_ALERT"RxBundleLookAheads : %d \n", stats.RxBundleLookAheads);
4006
A_PRINTF(KERN_ALERT"RxBundleIndFromHdr : %d \n", stats.RxBundleIndFromHdr);
4007
A_PRINTF(KERN_ALERT"RxAllocThreshHit : %d \n", stats.RxAllocThreshHit);
4008
A_PRINTF(KERN_ALERT"RxAllocThreshBytes : %d \n", stats.RxAllocThreshBytes);
4009
A_PRINTF(KERN_ALERT"---- \n");
4017
case AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE:
4018
if (ar->arHtcTarget != NULL) {
4019
struct ar6000_traffic_activity_change data;
4021
if (copy_from_user(&data, userdata, sizeof(data)))
4026
/* note, this is used for testing (mbox ping testing), indicate activity
4027
* change using the stream ID as the traffic class */
4028
ar6000_indicate_tx_activity(ar,
4030
data.Active ? true : false);
4033
case AR6000_XIOCTL_WMI_SET_CONNECT_CTRL_FLAGS:
4034
if (ar->arWmiReady == false) {
4036
} else if (copy_from_user(&connectCtrlFlags, userdata,
4037
sizeof(connectCtrlFlags)))
4041
ar->arConnectCtrlFlags = connectCtrlFlags;
4044
case AR6000_XIOCTL_WMI_SET_AKMP_PARAMS:
4045
if (ar->arWmiReady == false) {
4047
} else if (copy_from_user(&akmpParams, userdata,
4048
sizeof(WMI_SET_AKMP_PARAMS_CMD)))
4052
if (wmi_set_akmp_params_cmd(ar->arWmi, &akmpParams) != 0) {
4057
case AR6000_XIOCTL_WMI_SET_PMKID_LIST:
4058
if (ar->arWmiReady == false) {
4061
if (copy_from_user(&pmkidInfo.numPMKID, userdata,
4062
sizeof(pmkidInfo.numPMKID)))
4067
if (copy_from_user(&pmkidInfo.pmkidList,
4068
userdata + sizeof(pmkidInfo.numPMKID),
4069
pmkidInfo.numPMKID * sizeof(WMI_PMKID)))
4074
if (wmi_set_pmkid_list_cmd(ar->arWmi, &pmkidInfo) != 0) {
4079
case AR6000_XIOCTL_WMI_GET_PMKID_LIST:
4080
if (ar->arWmiReady == false) {
4083
if (wmi_get_pmkid_list_cmd(ar->arWmi) != 0) {
4088
case AR6000_XIOCTL_WMI_ABORT_SCAN:
4089
if (ar->arWmiReady == false) {
4092
ret = wmi_abort_scan_cmd(ar->arWmi);
4094
case AR6000_XIOCTL_AP_HIDDEN_SSID:
4097
if (ar->arWmiReady == false) {
4099
} else if (copy_from_user(&hidden_ssid, userdata, sizeof(hidden_ssid))) {
4102
wmi_ap_set_hidden_ssid(ar->arWmi, hidden_ssid);
4103
ar->ap_hidden_ssid = hidden_ssid;
4104
ar->ap_profile_flag = 1; /* There is a change in profile */
4108
case AR6000_XIOCTL_AP_GET_STA_LIST:
4110
if (ar->arWmiReady == false) {
4115
A_MEMZERO(&temp, sizeof(temp));
4116
for(i=0;i<AP_MAX_NUM_STA;i++) {
4117
memcpy(temp.sta[i].mac, ar->sta_list[i].mac, ATH_MAC_LEN);
4118
temp.sta[i].aid = ar->sta_list[i].aid;
4119
temp.sta[i].keymgmt = ar->sta_list[i].keymgmt;
4120
temp.sta[i].ucipher = ar->sta_list[i].ucipher;
4121
temp.sta[i].auth = ar->sta_list[i].auth;
4123
if(copy_to_user((ap_get_sta_t *)rq->ifr_data, &temp,
4124
sizeof(ar->sta_list))) {
4130
case AR6000_XIOCTL_AP_SET_NUM_STA:
4133
if (ar->arWmiReady == false) {
4135
} else if (copy_from_user(&num_sta, userdata, sizeof(num_sta))) {
4137
} else if(num_sta > AP_MAX_NUM_STA) {
4138
/* value out of range */
4141
wmi_ap_set_num_sta(ar->arWmi, num_sta);
4145
case AR6000_XIOCTL_AP_SET_ACL_POLICY:
4148
if (ar->arWmiReady == false) {
4150
} else if (copy_from_user(&policy, userdata, sizeof(policy))) {
4152
} else if(policy == ar->g_acl.policy) {
4153
/* No change in policy */
4155
if(!(policy & AP_ACL_RETAIN_LIST_MASK)) {
4156
/* clear ACL list */
4157
memset(&ar->g_acl,0,sizeof(WMI_AP_ACL));
4159
ar->g_acl.policy = policy;
4160
wmi_ap_set_acl_policy(ar->arWmi, policy);
4164
case AR6000_XIOCTL_AP_SET_ACL_MAC:
4166
WMI_AP_ACL_MAC_CMD acl;
4167
if (ar->arWmiReady == false) {
4169
} else if (copy_from_user(&acl, userdata, sizeof(acl))) {
4172
if(acl_add_del_mac(&ar->g_acl, &acl)) {
4173
wmi_ap_acl_mac_list(ar->arWmi, &acl);
4175
A_PRINTF("ACL list error\n");
4181
case AR6000_XIOCTL_AP_GET_ACL_LIST:
4183
if (ar->arWmiReady == false) {
4185
} else if(copy_to_user((WMI_AP_ACL *)rq->ifr_data, &ar->g_acl,
4186
sizeof(WMI_AP_ACL))) {
4191
case AR6000_XIOCTL_AP_COMMIT_CONFIG:
4193
ret = ar6000_ap_mode_profile_commit(ar);
4196
case IEEE80211_IOCTL_GETWPAIE:
4198
struct ieee80211req_wpaie wpaie;
4199
if (ar->arWmiReady == false) {
4201
} else if (copy_from_user(&wpaie, userdata, sizeof(wpaie))) {
4203
} else if (ar6000_ap_mode_get_wpa_ie(ar, &wpaie)) {
4205
} else if(copy_to_user(userdata, &wpaie, sizeof(wpaie))) {
4210
case AR6000_XIOCTL_AP_CONN_INACT_TIME:
4213
if (ar->arWmiReady == false) {
4215
} else if (copy_from_user(&period, userdata, sizeof(period))) {
4218
wmi_ap_conn_inact_time(ar->arWmi, period);
4222
case AR6000_XIOCTL_AP_PROT_SCAN_TIME:
4224
WMI_AP_PROT_SCAN_TIME_CMD bgscan;
4225
if (ar->arWmiReady == false) {
4227
} else if (copy_from_user(&bgscan, userdata, sizeof(bgscan))) {
4230
wmi_ap_bgscan_time(ar->arWmi, bgscan.period_min, bgscan.dwell_ms);
4234
case AR6000_XIOCTL_AP_SET_COUNTRY:
4236
ret = ar6000_ioctl_set_country(dev, rq);
4239
case AR6000_XIOCTL_AP_SET_DTIM:
4241
WMI_AP_SET_DTIM_CMD d;
4242
if (ar->arWmiReady == false) {
4244
} else if (copy_from_user(&d, userdata, sizeof(d))) {
4247
if(d.dtim > 0 && d.dtim < 11) {
4248
ar->ap_dtim_period = d.dtim;
4249
wmi_ap_set_dtim(ar->arWmi, d.dtim);
4250
ar->ap_profile_flag = 1; /* There is a change in profile */
4252
A_PRINTF("DTIM out of range. Valid range is [1-10]\n");
4258
case AR6000_XIOCTL_WMI_TARGET_EVENT_REPORT:
4260
WMI_SET_TARGET_EVENT_REPORT_CMD evtCfgCmd;
4262
if (ar->arWmiReady == false) {
4265
if (copy_from_user(&evtCfgCmd, userdata,
4266
sizeof(evtCfgCmd))) {
4270
ret = wmi_set_target_event_report_cmd(ar->arWmi, &evtCfgCmd);
4273
case AR6000_XIOCTL_AP_INTRA_BSS_COMM:
4276
if (ar->arWmiReady == false) {
4278
} else if (copy_from_user(&intra, userdata, sizeof(intra))) {
4281
ar->intra_bss = (intra?1:0);
4285
case AR6000_XIOCTL_DUMP_MODULE_DEBUG_INFO:
4287
struct drv_debug_module_s moduleinfo;
4289
if (copy_from_user(&moduleinfo, userdata, sizeof(moduleinfo))) {
4294
a_dump_module_debug_info_by_name(moduleinfo.modulename);
4298
case AR6000_XIOCTL_MODULE_DEBUG_SET_MASK:
4300
struct drv_debug_module_s moduleinfo;
4302
if (copy_from_user(&moduleinfo, userdata, sizeof(moduleinfo))) {
4307
if (a_set_module_mask(moduleinfo.modulename, moduleinfo.mask)) {
4313
case AR6000_XIOCTL_MODULE_DEBUG_GET_MASK:
4315
struct drv_debug_module_s moduleinfo;
4317
if (copy_from_user(&moduleinfo, userdata, sizeof(moduleinfo))) {
4322
if (a_get_module_mask(moduleinfo.modulename, &moduleinfo.mask)) {
4327
if (copy_to_user(userdata, &moduleinfo, sizeof(moduleinfo))) {
4334
#ifdef ATH_AR6K_11N_SUPPORT
4335
case AR6000_XIOCTL_DUMP_RCV_AGGR_STATS:
4337
PACKET_LOG *copy_of_pkt_log;
4339
aggr_dump_stats(ar->aggr_cntxt, ©_of_pkt_log);
4340
if (copy_to_user(rq->ifr_data, copy_of_pkt_log, sizeof(PACKET_LOG))) {
4345
case AR6000_XIOCTL_SETUP_AGGR:
4347
WMI_ADDBA_REQ_CMD cmd;
4349
if (ar->arWmiReady == false) {
4351
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4354
wmi_setup_aggr_cmd(ar->arWmi, cmd.tid);
4359
case AR6000_XIOCTL_DELE_AGGR:
4361
WMI_DELBA_REQ_CMD cmd;
4363
if (ar->arWmiReady == false) {
4365
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4368
wmi_delete_aggr_cmd(ar->arWmi, cmd.tid, cmd.is_sender_initiator);
4373
case AR6000_XIOCTL_ALLOW_AGGR:
4375
WMI_ALLOW_AGGR_CMD cmd;
4377
if (ar->arWmiReady == false) {
4379
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4382
wmi_allow_aggr_cmd(ar->arWmi, cmd.tx_allow_aggr, cmd.rx_allow_aggr);
4387
case AR6000_XIOCTL_SET_HT_CAP:
4389
if (ar->arWmiReady == false) {
4391
} else if (copy_from_user(&htCap, userdata,
4397
if (wmi_set_ht_cap_cmd(ar->arWmi, &htCap) != 0)
4404
case AR6000_XIOCTL_SET_HT_OP:
4406
if (ar->arWmiReady == false) {
4408
} else if (copy_from_user(&htOp, userdata,
4414
if (wmi_set_ht_op_cmd(ar->arWmi, htOp.sta_chan_width) != 0)
4422
case AR6000_XIOCTL_ACL_DATA:
4425
if (ar->arWmiReady == false) {
4427
} else if (ar6000_create_acl_data_osbuf(dev, (u8 *)userdata, &osbuf) != 0) {
4430
if (wmi_data_hdr_add(ar->arWmi, osbuf, DATA_MSGTYPE, 0, WMI_DATA_HDR_DATA_TYPE_ACL,0,NULL) != 0) {
4431
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("XIOCTL_ACL_DATA - wmi_data_hdr_add failed\n"));
4433
/* Send data buffer over HTC */
4434
ar6000_acl_data_tx(osbuf, ar->arNetDev);
4439
case AR6000_XIOCTL_HCI_CMD:
4443
WMI_HCI_CMD *cmd = (WMI_HCI_CMD *)tmp_buf;
4446
size = sizeof(cmd->cmd_buf_sz);
4447
if (ar->arWmiReady == false) {
4449
} else if (copy_from_user(cmd, userdata, size)) {
4451
} else if(copy_from_user(cmd->buf, userdata + size, cmd->cmd_buf_sz)) {
4454
if (wmi_send_hci_cmd(ar->arWmi, cmd->buf, cmd->cmd_buf_sz) != 0) {
4457
A_PRINTF_LOG("HCI Command To PAL --> \n");
4458
for(i = 0; i < cmd->cmd_buf_sz; i++) {
4459
A_PRINTF_LOG("0x%02x ",cmd->buf[i]);
4465
A_PRINTF_LOG("==================================\n");
4470
case AR6000_XIOCTL_WLAN_CONN_PRECEDENCE:
4472
WMI_SET_BT_WLAN_CONN_PRECEDENCE cmd;
4473
if (ar->arWmiReady == false) {
4475
} else if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
4478
if (cmd.precedence == BT_WLAN_CONN_PRECDENCE_WLAN ||
4479
cmd.precedence == BT_WLAN_CONN_PRECDENCE_PAL) {
4480
if ( wmi_set_wlan_conn_precedence_cmd(ar->arWmi, cmd.precedence) != 0) {
4489
case AR6000_XIOCTL_AP_GET_STAT:
4491
ret = ar6000_ioctl_get_ap_stats(dev, rq);
4494
case AR6000_XIOCTL_SET_TX_SELECT_RATES:
4496
WMI_SET_TX_SELECT_RATES_CMD masks;
4498
if (ar->arWmiReady == false) {
4500
} else if (copy_from_user(&masks, userdata,
4506
if (wmi_set_tx_select_rates_cmd(ar->arWmi, masks.rateMasks) != 0)
4513
case AR6000_XIOCTL_AP_GET_HIDDEN_SSID:
4515
WMI_AP_HIDDEN_SSID_CMD ssid;
4516
ssid.hidden_ssid = ar->ap_hidden_ssid;
4518
if (ar->arWmiReady == false) {
4520
} else if(copy_to_user((WMI_AP_HIDDEN_SSID_CMD *)rq->ifr_data,
4521
&ssid, sizeof(WMI_AP_HIDDEN_SSID_CMD))) {
4526
case AR6000_XIOCTL_AP_GET_COUNTRY:
4528
WMI_AP_SET_COUNTRY_CMD cty;
4529
memcpy(cty.countryCode, ar->ap_country_code, 3);
4531
if (ar->arWmiReady == false) {
4533
} else if(copy_to_user((WMI_AP_SET_COUNTRY_CMD *)rq->ifr_data,
4534
&cty, sizeof(WMI_AP_SET_COUNTRY_CMD))) {
4539
case AR6000_XIOCTL_AP_GET_WMODE:
4541
if (ar->arWmiReady == false) {
4543
} else if(copy_to_user((u8 *)rq->ifr_data,
4544
&ar->ap_wmode, sizeof(u8))) {
4549
case AR6000_XIOCTL_AP_GET_DTIM:
4551
WMI_AP_SET_DTIM_CMD dtim;
4552
dtim.dtim = ar->ap_dtim_period;
4554
if (ar->arWmiReady == false) {
4556
} else if(copy_to_user((WMI_AP_SET_DTIM_CMD *)rq->ifr_data,
4557
&dtim, sizeof(WMI_AP_SET_DTIM_CMD))) {
4562
case AR6000_XIOCTL_AP_GET_BINTVL:
4564
WMI_BEACON_INT_CMD bi;
4565
bi.beaconInterval = ar->ap_beacon_interval;
4567
if (ar->arWmiReady == false) {
4569
} else if(copy_to_user((WMI_BEACON_INT_CMD *)rq->ifr_data,
4570
&bi, sizeof(WMI_BEACON_INT_CMD))) {
4575
case AR6000_XIOCTL_AP_GET_RTS:
4577
WMI_SET_RTS_CMD rts;
4578
rts.threshold = ar->arRTS;
4580
if (ar->arWmiReady == false) {
4582
} else if(copy_to_user((WMI_SET_RTS_CMD *)rq->ifr_data,
4583
&rts, sizeof(WMI_SET_RTS_CMD))) {
4588
case AR6000_XIOCTL_FETCH_TARGET_REGS:
4590
u32 targregs[AR6003_FETCH_TARG_REGS_COUNT];
4592
if (ar->arTargetType == TARGET_TYPE_AR6003) {
4593
ar6k_FetchTargetRegs(hifDevice, targregs);
4594
if (copy_to_user((u32 *)rq->ifr_data, &targregs, sizeof(targregs)))
4603
case AR6000_XIOCTL_AP_SET_11BG_RATESET:
4605
WMI_AP_SET_11BG_RATESET_CMD rate;
4606
if (ar->arWmiReady == false) {
4608
} else if (copy_from_user(&rate, userdata, sizeof(rate))) {
4611
wmi_ap_set_rateset(ar->arWmi, rate.rateset);
4615
case AR6000_XIOCTL_GET_WLAN_SLEEP_STATE:
4617
WMI_REPORT_SLEEP_STATE_EVENT wmiSleepEvent ;
4619
if (ar->arWlanState == WLAN_ENABLED) {
4620
wmiSleepEvent.sleepState = WMI_REPORT_SLEEP_STATUS_IS_AWAKE;
4622
wmiSleepEvent.sleepState = WMI_REPORT_SLEEP_STATUS_IS_DEEP_SLEEP;
4624
rq->ifr_ifru.ifru_ivalue = ar->arWlanState; /* return value */
4626
ar6000_send_event_to_app(ar, WMI_REPORT_SLEEP_STATE_EVENTID, (u8 *)&wmiSleepEvent,
4627
sizeof(WMI_REPORT_SLEEP_STATE_EVENTID));
4631
case AR6000_XIOCTL_SET_BT_HW_POWER_STATE:
4634
if (get_user(state, (unsigned int *)userdata)) {
4638
if (ar6000_set_bt_hw_state(ar, state)!= 0) {
4643
case AR6000_XIOCTL_GET_BT_HW_POWER_STATE:
4644
rq->ifr_ifru.ifru_ivalue = !ar->arBTOff; /* return value */
4648
case AR6000_XIOCTL_WMI_SET_TX_SGI_PARAM:
4650
WMI_SET_TX_SGI_PARAM_CMD SGICmd;
4652
if (ar->arWmiReady == false) {
4654
} else if (copy_from_user(&SGICmd, userdata,
4658
if (wmi_SGI_cmd(ar->arWmi, SGICmd.sgiMask, SGICmd.sgiPERThreshold) != 0) {
4666
case AR6000_XIOCTL_ADD_AP_INTERFACE:
4667
#ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
4669
char ap_ifname[IFNAMSIZ] = {0,};
4670
if (copy_from_user(ap_ifname, userdata, IFNAMSIZ)) {
4673
if (ar6000_add_ap_interface(ar, ap_ifname) != 0) {
4682
case AR6000_XIOCTL_REMOVE_AP_INTERFACE:
4683
#ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
4684
if (ar6000_remove_ap_interface(ar) != 0) {
4692
case AR6000_XIOCTL_WMI_SET_EXCESS_TX_RETRY_THRES:
4694
ret = ar6000_xioctl_set_excess_tx_retry_thres_cmd(dev, userdata);
4703
rtnl_lock(); /* restore rtnl state */
4709
u8 mac_cmp_wild(u8 *mac, u8 *new_mac, u8 wild, u8 new_wild)
4713
for(i=0;i<ATH_MAC_LEN;i++) {
4714
if((wild & 1<<i) && (new_wild & 1<<i)) continue;
4715
if(mac[i] != new_mac[i]) return 1;
4717
if((memcmp(new_mac, null_mac, 6)==0) && new_wild &&
4718
(wild != new_wild)) {
4725
u8 acl_add_del_mac(WMI_AP_ACL *a, WMI_AP_ACL_MAC_CMD *acl)
4727
s8 already_avail=-1, free_slot=-1, i;
4729
/* To check whether this mac is already there in our list */
4730
for(i=AP_ACL_SIZE-1;i>=0;i--)
4732
if(mac_cmp_wild(a->acl_mac[i], acl->mac, a->wildcard[i],
4736
if(!((1 << i) & a->index))
4740
if(acl->action == ADD_MAC_ADDR)
4742
/* Dont add mac if it is already available */
4743
if((already_avail >= 0) || (free_slot == -1))
4746
memcpy(a->acl_mac[free_slot], acl->mac, ATH_MAC_LEN);
4747
a->index = a->index | (1 << free_slot);
4748
acl->index = free_slot;
4749
a->wildcard[free_slot] = acl->wildcard;
4752
else if(acl->action == DEL_MAC_ADDR)
4754
if(acl->index > AP_ACL_SIZE)
4757
if(!(a->index & (1 << acl->index)))
4760
A_MEMZERO(a->acl_mac[acl->index],ATH_MAC_LEN);
4761
a->index = a->index & ~(1 << acl->index);
4762
a->wildcard[acl->index] = 0;
added
removed
drivers/staging/ath6kl/os/linux/ioctl.c
