projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[s3c24xx] bump to 2.6.30-rc6
[openwrt/svn-archive/archive.git] / target / linux / s3c24xx / files-2.6.30 / drivers / ar6000 / ar6000 / ioctl.c
1 /*
2 *
3 * Copyright (c) 2004-2007 Atheros Communications Inc.
4 * All rights reserved.
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation;
10 *
11 * Software distributed under the License is distributed on an "AS
12 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
13 * implied. See the License for the specific language governing
14 * rights and limitations under the License.
15 *
16 *
17 *
18 */
19
20 #include "ar6000_drv.h"
21
22 static A_UINT8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
23 static A_UINT8 null_mac[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
24 extern USER_RSSI_THOLD rssi_map[12];
25 extern unsigned int wmitimeout;
26 extern A_WAITQUEUE_HEAD arEvent;
27 extern int tspecCompliance;
28 extern int bmienable;
29 extern int bypasswmi;
30
31 static int
32 ar6000_ioctl_get_roam_tbl(struct net_device *dev, struct ifreq *rq)
33 {
34 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
35
36 if (ar->arWmiReady == FALSE) {
37 return -EIO;
38 }
39
40 if(wmi_get_roam_tbl_cmd(ar->arWmi) != A_OK) {
41 return -EIO;
42 }
43
44 return 0;
45 }
46
47 static int
48 ar6000_ioctl_get_roam_data(struct net_device *dev, struct ifreq *rq)
49 {
50 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
51
52 if (ar->arWmiReady == FALSE) {
53 return -EIO;
54 }
55
56
57 /* currently assume only roam times are required */
58 if(wmi_get_roam_data_cmd(ar->arWmi, ROAM_DATA_TIME) != A_OK) {
59 return -EIO;
60 }
61
62
63 return 0;
64 }
65
66 static int
67 ar6000_ioctl_set_roam_ctrl(struct net_device *dev, char *userdata)
68 {
69 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
70 WMI_SET_ROAM_CTRL_CMD cmd;
71 A_UINT8 size = sizeof(cmd);
72
73 if (ar->arWmiReady == FALSE) {
74 return -EIO;
75 }
76
77
78 if (copy_from_user(&cmd, userdata, size)) {
79 return -EFAULT;
80 }
81
82 if (cmd.roamCtrlType == WMI_SET_HOST_BIAS) {
83 if (cmd.info.bssBiasInfo.numBss > 1) {
84 size += (cmd.info.bssBiasInfo.numBss - 1) * sizeof(WMI_BSS_BIAS);
85 }
86 }
87
88 if (copy_from_user(&cmd, userdata, size)) {
89 return -EFAULT;
90 }
91
92 if(wmi_set_roam_ctrl_cmd(ar->arWmi, &cmd, size) != A_OK) {
93 return -EIO;
94 }
95
96 return 0;
97 }
98
99 static int
100 ar6000_ioctl_set_powersave_timers(struct net_device *dev, char *userdata)
101 {
102 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
103 WMI_POWERSAVE_TIMERS_POLICY_CMD cmd;
104 A_UINT8 size = sizeof(cmd);
105
106 if (ar->arWmiReady == FALSE) {
107 return -EIO;
108 }
109
110 if (copy_from_user(&cmd, userdata, size)) {
111 return -EFAULT;
112 }
113
114 if (copy_from_user(&cmd, userdata, size)) {
115 return -EFAULT;
116 }
117
118 if(wmi_set_powersave_timers_cmd(ar->arWmi, &cmd, size) != A_OK) {
119 return -EIO;
120 }
121
122 return 0;
123 }
124
125 static int
126 ar6000_ioctl_set_wmm(struct net_device *dev, struct ifreq *rq)
127 {
128 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
129 WMI_SET_WMM_CMD cmd;
130 A_STATUS ret;
131
132 if ((dev->flags & IFF_UP) != IFF_UP) {
133 return -EIO;
134 }
135 if (ar->arWmiReady == FALSE) {
136 return -EIO;
137 }
138
139 if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
140 sizeof(cmd)))
141 {
142 return -EFAULT;
143 }
144
145 if (cmd.status == WMI_WMM_ENABLED) {
146 ar->arWmmEnabled = TRUE;
147 } else {
148 ar->arWmmEnabled = FALSE;
149 }
150
151 ret = wmi_set_wmm_cmd(ar->arWmi, cmd.status);
152
153 switch (ret) {
154 case A_OK:
155 return 0;
156 case A_EBUSY :
157 return -EBUSY;
158 case A_NO_MEMORY:
159 return -ENOMEM;
160 case A_EINVAL:
161 default:
162 return -EFAULT;
163 }
164 }
165
166 static int
167 ar6000_ioctl_set_txop(struct net_device *dev, struct ifreq *rq)
168 {
169 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
170 WMI_SET_WMM_TXOP_CMD cmd;
171 A_STATUS ret;
172
173 if ((dev->flags & IFF_UP) != IFF_UP) {
174 return -EIO;
175 }
176 if (ar->arWmiReady == FALSE) {
177 return -EIO;
178 }
179
180 if (copy_from_user(&cmd, (char *)((unsigned int*)rq->ifr_data + 1),
181 sizeof(cmd)))
182 {
183 return -EFAULT;
184 }
185
186 ret = wmi_set_wmm_txop(ar->arWmi, cmd.txopEnable);
187
188 switch (ret) {
189 case A_OK:
190 return 0;
191 case A_EBUSY :
192 return -EBUSY;
193 case A_NO_MEMORY:
194 return -ENOMEM;
195 case A_EINVAL:
196 default:
197 return -EFAULT;
198 }
199 }
200
201 static int
202 ar6000_ioctl_get_rd(struct net_device *dev, struct ifreq *rq)
203 {
204 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
205 A_STATUS ret = 0;
206
207 if ((dev->flags & IFF_UP) != IFF_UP || ar->arWmiReady == FALSE) {
208 return -EIO;
209 }
210
211 if(copy_to_user((char *)((unsigned int*)rq->ifr_data + 1),
212 &ar->arRegCode, sizeof(ar->arRegCode)))
213 ret = -EFAULT;
214
215 return ret;
216 }
217
218
219 /* Get power mode command */
220 static int
221 ar6000_ioctl_get_power_mode(struct net_device *dev, struct ifreq *rq)
222 {
223 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
224 WMI_POWER_MODE_CMD power_mode;
225 int ret = 0;
226
227 if (ar->arWmiReady == FALSE) {
228 return -EIO;
229 }
230
231 power_mode.powerMode = wmi_get_power_mode_cmd(ar->arWmi);
232 if (copy_to_user(rq->ifr_data, &power_mode, sizeof(WMI_POWER_MODE_CMD))) {
233 ret = -EFAULT;
234 }
235
236 return ret;
237 }
238
239
240 static int
241 ar6000_ioctl_set_channelParams(struct net_device *dev, struct ifreq *rq)
242 {
243 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
244 WMI_CHANNEL_PARAMS_CMD cmd, *cmdp;
245 int ret = 0;
246
247 if (ar->arWmiReady == FALSE) {
248 return -EIO;
249 }
250
251
252 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
253 return -EFAULT;
254 }
255
256 if (cmd.numChannels > 1) {
257 cmdp = A_MALLOC(130);
258 if (copy_from_user(cmdp, rq->ifr_data,
259 sizeof (*cmdp) +
260 ((cmd.numChannels - 1) * sizeof(A_UINT16))))
261 {
262 kfree(cmdp);
263 return -EFAULT;
264 }
265 } else {
266 cmdp = &cmd;
267 }
268
269 if ((ar->arPhyCapability == WMI_11G_CAPABILITY) &&
270 ((cmdp->phyMode == WMI_11A_MODE) || (cmdp->phyMode == WMI_11AG_MODE)))
271 {
272 ret = -EINVAL;
273 }
274
275 if (!ret &&
276 (wmi_set_channelParams_cmd(ar->arWmi, cmdp->scanParam, cmdp->phyMode,
277 cmdp->numChannels, cmdp->channelList)
278 != A_OK))
279 {
280 ret = -EIO;
281 }
282
283 if (cmd.numChannels > 1) {
284 kfree(cmdp);
285 }
286
287 return ret;
288 }
289
290 static int
291 ar6000_ioctl_set_snr_threshold(struct net_device *dev, struct ifreq *rq)
292 {
293
294 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
295 WMI_SNR_THRESHOLD_PARAMS_CMD cmd;
296 int ret = 0;
297
298 if (ar->arWmiReady == FALSE) {
299 return -EIO;
300 }
301
302 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
303 return -EFAULT;
304 }
305
306 if( wmi_set_snr_threshold_params(ar->arWmi, &cmd) != A_OK ) {
307 ret = -EIO;
308 }
309
310 return ret;
311 }
312
313 static int
314 ar6000_ioctl_set_rssi_threshold(struct net_device *dev, struct ifreq *rq)
315 {
316 #define SWAP_THOLD(thold1, thold2) do { \
317 USER_RSSI_THOLD tmpThold; \
318 tmpThold.tag = thold1.tag; \
319 tmpThold.rssi = thold1.rssi; \
320 thold1.tag = thold2.tag; \
321 thold1.rssi = thold2.rssi; \
322 thold2.tag = tmpThold.tag; \
323 thold2.rssi = tmpThold.rssi; \
324 } while (0)
325
326 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
327 WMI_RSSI_THRESHOLD_PARAMS_CMD cmd;
328 USER_RSSI_PARAMS rssiParams;
329 A_INT32 i, j;
330
331 int ret = 0;
332
333 if (ar->arWmiReady == FALSE) {
334 return -EIO;
335 }
336
337 if (copy_from_user((char *)&rssiParams, (char *)((unsigned int *)rq->ifr_data + 1), sizeof(USER_RSSI_PARAMS))) {
338 return -EFAULT;
339 }
340 cmd.weight = rssiParams.weight;
341 cmd.pollTime = rssiParams.pollTime;
342
343 A_MEMCPY(rssi_map, &rssiParams.tholds, sizeof(rssi_map));
344 /*
345 * only 6 elements, so use bubble sorting, in ascending order
346 */
347 for (i = 5; i > 0; i--) {
348 for (j = 0; j < i; j++) { /* above tholds */
349 if (rssi_map[j+1].rssi < rssi_map[j].rssi) {
350 SWAP_THOLD(rssi_map[j+1], rssi_map[j]);
351 } else if (rssi_map[j+1].rssi == rssi_map[j].rssi) {
352 return EFAULT;
353 }
354 }
355 }
356 for (i = 11; i > 6; i--) {
357 for (j = 6; j < i; j++) { /* below tholds */
358 if (rssi_map[j+1].rssi < rssi_map[j].rssi) {
359 SWAP_THOLD(rssi_map[j+1], rssi_map[j]);
360 } else if (rssi_map[j+1].rssi == rssi_map[j].rssi) {
361 return EFAULT;
362 }
363 }
364 }
365
366 #ifdef DEBUG
367 for (i = 0; i < 12; i++) {
368 AR_DEBUG2_PRINTF("thold[%d].tag: %d, thold[%d].rssi: %d \n",
369 i, rssi_map[i].tag, i, rssi_map[i].rssi);
370 }
371 #endif
372 cmd.thresholdAbove1_Val = rssi_map[0].rssi;
373 cmd.thresholdAbove2_Val = rssi_map[1].rssi;
374 cmd.thresholdAbove3_Val = rssi_map[2].rssi;
375 cmd.thresholdAbove4_Val = rssi_map[3].rssi;
376 cmd.thresholdAbove5_Val = rssi_map[4].rssi;
377 cmd.thresholdAbove6_Val = rssi_map[5].rssi;
378 cmd.thresholdBelow1_Val = rssi_map[6].rssi;
379 cmd.thresholdBelow2_Val = rssi_map[7].rssi;
380 cmd.thresholdBelow3_Val = rssi_map[8].rssi;
381 cmd.thresholdBelow4_Val = rssi_map[9].rssi;
382 cmd.thresholdBelow5_Val = rssi_map[10].rssi;
383 cmd.thresholdBelow6_Val = rssi_map[11].rssi;
384
385 if( wmi_set_rssi_threshold_params(ar->arWmi, &cmd) != A_OK ) {
386 ret = -EIO;
387 }
388
389 return ret;
390 }
391
392 static int
393 ar6000_ioctl_set_lq_threshold(struct net_device *dev, struct ifreq *rq)
394 {
395
396 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
397 WMI_LQ_THRESHOLD_PARAMS_CMD cmd;
398 int ret = 0;
399
400 if (ar->arWmiReady == FALSE) {
401 return -EIO;
402 }
403
404 if (copy_from_user(&cmd, (char *)((unsigned int *)rq->ifr_data + 1), sizeof(cmd))) {
405 return -EFAULT;
406 }
407
408 if( wmi_set_lq_threshold_params(ar->arWmi, &cmd) != A_OK ) {
409 ret = -EIO;
410 }
411
412 return ret;
413 }
414
415
416 static int
417 ar6000_ioctl_set_probedSsid(struct net_device *dev, struct ifreq *rq)
418 {
419 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
420 WMI_PROBED_SSID_CMD cmd;
421 int ret = 0;
422
423 if (ar->arWmiReady == FALSE) {
424 return -EIO;
425 }
426
427 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
428 return -EFAULT;
429 }
430
431 if (wmi_probedSsid_cmd(ar->arWmi, cmd.entryIndex, cmd.flag, cmd.ssidLength,
432 cmd.ssid) != A_OK)
433 {
434 ret = -EIO;
435 }
436
437 return ret;
438 }
439
440 static int
441 ar6000_ioctl_set_badAp(struct net_device *dev, struct ifreq *rq)
442 {
443 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
444 WMI_ADD_BAD_AP_CMD cmd;
445 int ret = 0;
446
447 if (ar->arWmiReady == FALSE) {
448 return -EIO;
449 }
450
451
452 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
453 return -EFAULT;
454 }
455
456 if (cmd.badApIndex > WMI_MAX_BAD_AP_INDEX) {
457 return -EIO;
458 }
459
460 if (A_MEMCMP(cmd.bssid, null_mac, AR6000_ETH_ADDR_LEN) == 0) {
461 /*
462 * This is a delete badAP.
463 */
464 if (wmi_deleteBadAp_cmd(ar->arWmi, cmd.badApIndex) != A_OK) {
465 ret = -EIO;
466 }
467 } else {
468 if (wmi_addBadAp_cmd(ar->arWmi, cmd.badApIndex, cmd.bssid) != A_OK) {
469 ret = -EIO;
470 }
471 }
472
473 return ret;
474 }
475
476 static int
477 ar6000_ioctl_create_qos(struct net_device *dev, struct ifreq *rq)
478 {
479 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
480 WMI_CREATE_PSTREAM_CMD cmd;
481 A_STATUS ret;
482
483 if (ar->arWmiReady == FALSE) {
484 return -EIO;
485 }
486
487
488 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
489 return -EFAULT;
490 }
491
492 ret = wmi_verify_tspec_params(&cmd, tspecCompliance);
493 if (ret == A_OK)
494 ret = wmi_create_pstream_cmd(ar->arWmi, &cmd);
495
496 switch (ret) {
497 case A_OK:
498 return 0;
499 case A_EBUSY :
500 return -EBUSY;
501 case A_NO_MEMORY:
502 return -ENOMEM;
503 case A_EINVAL:
504 default:
505 return -EFAULT;
506 }
507 }
508
509 static int
510 ar6000_ioctl_delete_qos(struct net_device *dev, struct ifreq *rq)
511 {
512 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
513 WMI_DELETE_PSTREAM_CMD cmd;
514 int ret = 0;
515
516 if (ar->arWmiReady == FALSE) {
517 return -EIO;
518 }
519
520 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
521 return -EFAULT;
522 }
523
524 ret = wmi_delete_pstream_cmd(ar->arWmi, cmd.trafficClass, cmd.tsid);
525
526 switch (ret) {
527 case A_OK:
528 return 0;
529 case A_EBUSY :
530 return -EBUSY;
531 case A_NO_MEMORY:
532 return -ENOMEM;
533 case A_EINVAL:
534 default:
535 return -EFAULT;
536 }
537 }
538
539 static int
540 ar6000_ioctl_get_qos_queue(struct net_device *dev, struct ifreq *rq)
541 {
542 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
543 struct ar6000_queuereq qreq;
544 int ret = 0;
545
546 if (ar->arWmiReady == FALSE) {
547 return -EIO;
548 }
549
550 if( copy_from_user(&qreq, rq->ifr_data,
551 sizeof(struct ar6000_queuereq)))
552 return -EFAULT;
553
554 qreq.activeTsids = wmi_get_mapped_qos_queue(ar->arWmi, qreq.trafficClass);
555
556 if (copy_to_user(rq->ifr_data, &qreq,
557 sizeof(struct ar6000_queuereq)))
558 {
559 ret = -EFAULT;
560 }
561
562 return ret;
563 }
564
565 #ifdef CONFIG_HOST_TCMD_SUPPORT
566 static A_STATUS
567 ar6000_ioctl_tcmd_get_rx_report(struct net_device *dev,
568 struct ifreq *rq, A_UINT8 *data, A_UINT32 len)
569 {
570 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
571 A_UINT32 buf[2];
572 int ret = 0;
573
574 if (ar->arWmiReady == FALSE) {
575 return -EIO;
576 }
577
578 if (down_interruptible(&ar->arSem)) {
579 return -ERESTARTSYS;
580 }
581 ar->tcmdRxReport = 0;
582 if (wmi_test_cmd(ar->arWmi, data, len) != A_OK) {
583 up(&ar->arSem);
584 return -EIO;
585 }
586
587 wait_event_interruptible_timeout(arEvent, ar->tcmdRxReport != 0, wmitimeout * HZ);
588
589 if (signal_pending(current)) {
590 ret = -EINTR;
591 }
592
593 buf[0] = ar->tcmdRxTotalPkt;
594 buf[1] = ar->tcmdRxRssi;
595 if (!ret && copy_to_user(rq->ifr_data, buf, sizeof(buf))) {
596 ret = -EFAULT;
597 }
598
599 up(&ar->arSem);
600
601 return ret;
602 }
603
604 void
605 ar6000_tcmd_rx_report_event(void *devt, A_UINT8 * results, int len)
606 {
607 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
608 TCMD_CONT_RX * rx_rep = (TCMD_CONT_RX *)results;
609
610 ar->tcmdRxTotalPkt = rx_rep->u.report.totalPkt;
611 ar->tcmdRxRssi = rx_rep->u.report.rssiInDBm;
612 ar->tcmdRxReport = 1;
613
614 wake_up(&arEvent);
615 }
616 #endif /* CONFIG_HOST_TCMD_SUPPORT*/
617
618 static int
619 ar6000_ioctl_set_error_report_bitmask(struct net_device *dev, struct ifreq *rq)
620 {
621 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
622 WMI_TARGET_ERROR_REPORT_BITMASK cmd;
623 int ret = 0;
624
625 if (ar->arWmiReady == FALSE) {
626 return -EIO;
627 }
628
629 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
630 return -EFAULT;
631 }
632
633 ret = wmi_set_error_report_bitmask(ar->arWmi, cmd.bitmask);
634
635 return (ret==0 ? ret : -EINVAL);
636 }
637
638 static int
639 ar6000_clear_target_stats(struct net_device *dev)
640 {
641 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
642 TARGET_STATS *pStats = &ar->arTargetStats;
643 int ret = 0;
644
645 if (ar->arWmiReady == FALSE) {
646 return -EIO;
647 }
648 AR6000_SPIN_LOCK(&ar->arLock, 0);
649 A_MEMZERO(pStats, sizeof(TARGET_STATS));
650 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
651 return ret;
652 }
653
654 static int
655 ar6000_ioctl_get_target_stats(struct net_device *dev, struct ifreq *rq)
656 {
657 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
658 TARGET_STATS_CMD cmd;
659 TARGET_STATS *pStats = &ar->arTargetStats;
660 int ret = 0;
661
662 if (ar->arWmiReady == FALSE) {
663 return -EIO;
664 }
665 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
666 return -EFAULT;
667 }
668 if (down_interruptible(&ar->arSem)) {
669 return -ERESTARTSYS;
670 }
671
672 ar->statsUpdatePending = TRUE;
673
674 if(wmi_get_stats_cmd(ar->arWmi) != A_OK) {
675 up(&ar->arSem);
676 return -EIO;
677 }
678
679 wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
680
681 if (signal_pending(current)) {
682 ret = -EINTR;
683 }
684
685 if (!ret && copy_to_user(rq->ifr_data, pStats, sizeof(*pStats))) {
686 ret = -EFAULT;
687 }
688
689 if (cmd.clearStats == 1) {
690 ret = ar6000_clear_target_stats(dev);
691 }
692
693 up(&ar->arSem);
694
695 return ret;
696 }
697
698 static int
699 ar6000_ioctl_set_access_params(struct net_device *dev, struct ifreq *rq)
700 {
701 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
702 WMI_SET_ACCESS_PARAMS_CMD cmd;
703 int ret = 0;
704
705 if (ar->arWmiReady == FALSE) {
706 return -EIO;
707 }
708
709 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
710 return -EFAULT;
711 }
712
713 if (wmi_set_access_params_cmd(ar->arWmi, cmd.txop, cmd.eCWmin, cmd.eCWmax,
714 cmd.aifsn) == A_OK)
715 {
716 ret = 0;
717 } else {
718 ret = -EINVAL;
719 }
720
721 return (ret);
722 }
723
724 static int
725 ar6000_ioctl_set_disconnect_timeout(struct net_device *dev, struct ifreq *rq)
726 {
727 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
728 WMI_DISC_TIMEOUT_CMD cmd;
729 int ret = 0;
730
731 if (ar->arWmiReady == FALSE) {
732 return -EIO;
733 }
734
735 if (copy_from_user(&cmd, rq->ifr_data, sizeof(cmd))) {
736 return -EFAULT;
737 }
738
739 if (wmi_disctimeout_cmd(ar->arWmi, cmd.disconnectTimeout) == A_OK)
740 {
741 ret = 0;
742 } else {
743 ret = -EINVAL;
744 }
745
746 return (ret);
747 }
748
749 static int
750 ar6000_xioctl_set_voice_pkt_size(struct net_device *dev, char * userdata)
751 {
752 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
753 WMI_SET_VOICE_PKT_SIZE_CMD cmd;
754 int ret = 0;
755
756 if (ar->arWmiReady == FALSE) {
757 return -EIO;
758 }
759
760 if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
761 return -EFAULT;
762 }
763
764 if (wmi_set_voice_pkt_size_cmd(ar->arWmi, cmd.voicePktSize) == A_OK)
765 {
766 ret = 0;
767 } else {
768 ret = -EINVAL;
769 }
770
771
772 return (ret);
773 }
774
775 static int
776 ar6000_xioctl_set_max_sp_len(struct net_device *dev, char * userdata)
777 {
778 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
779 WMI_SET_MAX_SP_LEN_CMD cmd;
780 int ret = 0;
781
782 if (ar->arWmiReady == FALSE) {
783 return -EIO;
784 }
785
786 if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
787 return -EFAULT;
788 }
789
790 if (wmi_set_max_sp_len_cmd(ar->arWmi, cmd.maxSPLen) == A_OK)
791 {
792 ret = 0;
793 } else {
794 ret = -EINVAL;
795 }
796
797 return (ret);
798 }
799
800
801 static int
802 ar6000_xioctl_set_bt_status_cmd(struct net_device *dev, char * userdata)
803 {
804 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
805 WMI_SET_BT_STATUS_CMD cmd;
806 int ret = 0;
807
808 if (ar->arWmiReady == FALSE) {
809 return -EIO;
810 }
811
812 if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
813 return -EFAULT;
814 }
815
816 if (wmi_set_bt_status_cmd(ar->arWmi, cmd.streamType, cmd.status) == A_OK)
817 {
818 ret = 0;
819 } else {
820 ret = -EINVAL;
821 }
822
823 return (ret);
824 }
825
826 static int
827 ar6000_xioctl_set_bt_params_cmd(struct net_device *dev, char * userdata)
828 {
829 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
830 WMI_SET_BT_PARAMS_CMD cmd;
831 int ret = 0;
832
833 if (ar->arWmiReady == FALSE) {
834 return -EIO;
835 }
836
837 if (copy_from_user(&cmd, userdata, sizeof(cmd))) {
838 return -EFAULT;
839 }
840
841 if (wmi_set_bt_params_cmd(ar->arWmi, &cmd) == A_OK)
842 {
843 ret = 0;
844 } else {
845 ret = -EINVAL;
846 }
847
848 return (ret);
849 }
850
851 #ifdef CONFIG_HOST_GPIO_SUPPORT
852 struct ar6000_gpio_intr_wait_cmd_s gpio_intr_results;
853 /* gpio_reg_results and gpio_data_available are protected by arSem */
854 static struct ar6000_gpio_register_cmd_s gpio_reg_results;
855 static A_BOOL gpio_data_available; /* Requested GPIO data available */
856 static A_BOOL gpio_intr_available; /* GPIO interrupt info available */
857 static A_BOOL gpio_ack_received; /* GPIO ack was received */
858
859 /* Host-side initialization for General Purpose I/O support */
860 void ar6000_gpio_init(void)
861 {
862 gpio_intr_available = FALSE;
863 gpio_data_available = FALSE;
864 gpio_ack_received = FALSE;
865 }
866
867 /*
868 * Called when a GPIO interrupt is received from the Target.
869 * intr_values shows which GPIO pins have interrupted.
870 * input_values shows a recent value of GPIO pins.
871 */
872 void
873 ar6000_gpio_intr_rx(A_UINT32 intr_mask, A_UINT32 input_values)
874 {
875 gpio_intr_results.intr_mask = intr_mask;
876 gpio_intr_results.input_values = input_values;
877 *((volatile A_BOOL *)&gpio_intr_available) = TRUE;
878 wake_up(&arEvent);
879 }
880
881 /*
882 * This is called when a response is received from the Target
883 * for a previous or ar6000_gpio_input_get or ar6000_gpio_register_get
884 * call.
885 */
886 void
887 ar6000_gpio_data_rx(A_UINT32 reg_id, A_UINT32 value)
888 {
889 gpio_reg_results.gpioreg_id = reg_id;
890 gpio_reg_results.value = value;
891 *((volatile A_BOOL *)&gpio_data_available) = TRUE;
892 wake_up(&arEvent);
893 }
894
895 /*
896 * This is called when an acknowledgement is received from the Target
897 * for a previous or ar6000_gpio_output_set or ar6000_gpio_register_set
898 * call.
899 */
900 void
901 ar6000_gpio_ack_rx(void)
902 {
903 gpio_ack_received = TRUE;
904 wake_up(&arEvent);
905 }
906
907 A_STATUS
908 ar6000_gpio_output_set(struct net_device *dev,
909 A_UINT32 set_mask,
910 A_UINT32 clear_mask,
911 A_UINT32 enable_mask,
912 A_UINT32 disable_mask)
913 {
914 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
915
916 gpio_ack_received = FALSE;
917 return wmi_gpio_output_set(ar->arWmi,
918 set_mask, clear_mask, enable_mask, disable_mask);
919 }
920
921 static A_STATUS
922 ar6000_gpio_input_get(struct net_device *dev)
923 {
924 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
925
926 *((volatile A_BOOL *)&gpio_data_available) = FALSE;
927 return wmi_gpio_input_get(ar->arWmi);
928 }
929
930 static A_STATUS
931 ar6000_gpio_register_set(struct net_device *dev,
932 A_UINT32 gpioreg_id,
933 A_UINT32 value)
934 {
935 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
936
937 gpio_ack_received = FALSE;
938 return wmi_gpio_register_set(ar->arWmi, gpioreg_id, value);
939 }
940
941 static A_STATUS
942 ar6000_gpio_register_get(struct net_device *dev,
943 A_UINT32 gpioreg_id)
944 {
945 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
946
947 *((volatile A_BOOL *)&gpio_data_available) = FALSE;
948 return wmi_gpio_register_get(ar->arWmi, gpioreg_id);
949 }
950
951 static A_STATUS
952 ar6000_gpio_intr_ack(struct net_device *dev,
953 A_UINT32 ack_mask)
954 {
955 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
956
957 gpio_intr_available = FALSE;
958 return wmi_gpio_intr_ack(ar->arWmi, ack_mask);
959 }
960 #endif /* CONFIG_HOST_GPIO_SUPPORT */
961
962 int ar6000_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
963 {
964 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
965 HIF_DEVICE *hifDevice = ar->arHifDevice;
966 int ret, param, param2;
967 unsigned int address = 0;
968 unsigned int length = 0;
969 unsigned char *buffer;
970 char *userdata;
971 A_UINT32 connectCtrlFlags;
972
973
974 static WMI_SCAN_PARAMS_CMD scParams = {0, 0, 0, 0, 0,
975 WMI_SHORTSCANRATIO_DEFAULT,
976 DEFAULT_SCAN_CTRL_FLAGS,
977 0};
978 WMI_SET_AKMP_PARAMS_CMD akmpParams;
979 WMI_SET_PMKID_LIST_CMD pmkidInfo;
980
981 if (cmd == AR6000_IOCTL_EXTENDED)
982 {
983 /*
984 * This allows for many more wireless ioctls than would otherwise
985 * be available. Applications embed the actual ioctl command in
986 * the first word of the parameter block, and use the command
987 * AR6000_IOCTL_EXTENDED_CMD on the ioctl call.
988 */
989 get_user(cmd, (int *)rq->ifr_data);
990 userdata = (char *)(((unsigned int *)rq->ifr_data)+1);
991 }
992 else
993 {
994 userdata = (char *)rq->ifr_data;
995 }
996
997 if ((ar->arWlanState == WLAN_DISABLED) &&
998 ((cmd != AR6000_XIOCTRL_WMI_SET_WLAN_STATE) &&
999 (cmd != AR6000_XIOCTL_DIAG_READ) &&
1000 (cmd != AR6000_XIOCTL_DIAG_WRITE)))
1001 {
1002 return -EIO;
1003 }
1004
1005 ret = 0;
1006 switch(cmd)
1007 {
1008 #ifdef CONFIG_HOST_TCMD_SUPPORT
1009 case AR6000_XIOCTL_TCMD_CONT_TX:
1010 {
1011 TCMD_CONT_TX txCmd;
1012
1013 if (ar->tcmdPm == TCMD_PM_SLEEP) {
1014 A_PRINTF("Can NOT send tx tcmd when target is asleep! \n");
1015 return -EFAULT;
1016 }
1017
1018 if(copy_from_user(&txCmd, userdata, sizeof(TCMD_CONT_TX)))
1019 return -EFAULT;
1020 wmi_test_cmd(ar->arWmi,(A_UINT8 *)&txCmd, sizeof(TCMD_CONT_TX));
1021 }
1022 break;
1023 case AR6000_XIOCTL_TCMD_CONT_RX:
1024 {
1025 TCMD_CONT_RX rxCmd;
1026
1027 if (ar->tcmdPm == TCMD_PM_SLEEP) {
1028 A_PRINTF("Can NOT send rx tcmd when target is asleep! \n");
1029 return -EFAULT;
1030 }
1031 if(copy_from_user(&rxCmd, userdata, sizeof(TCMD_CONT_RX)))
1032 return -EFAULT;
1033 switch(rxCmd.act)
1034 {
1035 case TCMD_CONT_RX_PROMIS:
1036 case TCMD_CONT_RX_FILTER:
1037 case TCMD_CONT_RX_SETMAC:
1038 wmi_test_cmd(ar->arWmi,(A_UINT8 *)&rxCmd,
1039 sizeof(TCMD_CONT_RX));
1040 break;
1041 case TCMD_CONT_RX_REPORT:
1042 ar6000_ioctl_tcmd_get_rx_report(dev, rq,
1043 (A_UINT8 *)&rxCmd, sizeof(TCMD_CONT_RX));
1044 break;
1045 default:
1046 A_PRINTF("Unknown Cont Rx mode: %d\n",rxCmd.act);
1047 return -EINVAL;
1048 }
1049 }
1050 break;
1051 case AR6000_XIOCTL_TCMD_PM:
1052 {
1053 TCMD_PM pmCmd;
1054
1055 if(copy_from_user(&pmCmd, userdata, sizeof(TCMD_PM)))
1056 return -EFAULT;
1057 ar->tcmdPm = pmCmd.mode;
1058 wmi_test_cmd(ar->arWmi, (A_UINT8*)&pmCmd, sizeof(TCMD_PM));
1059 }
1060 break;
1061 #endif /* CONFIG_HOST_TCMD_SUPPORT */
1062
1063 case AR6000_XIOCTL_BMI_DONE:
1064 if(bmienable)
1065 {
1066 ret = ar6000_init(dev);
1067 }
1068 else
1069 {
1070 ret = BMIDone(hifDevice);
1071 }
1072 break;
1073
1074 case AR6000_XIOCTL_BMI_READ_MEMORY:
1075 get_user(address, (unsigned int *)userdata);
1076 get_user(length, (unsigned int *)userdata + 1);
1077 AR_DEBUG_PRINTF("Read Memory (address: 0x%x, length: %d)\n",
1078 address, length);
1079 if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
1080 A_MEMZERO(buffer, length);
1081 ret = BMIReadMemory(hifDevice, address, buffer, length);
1082 if (copy_to_user(rq->ifr_data, buffer, length)) {
1083 ret = -EFAULT;
1084 }
1085 A_FREE(buffer);
1086 } else {
1087 ret = -ENOMEM;
1088 }
1089 break;
1090
1091 case AR6000_XIOCTL_BMI_WRITE_MEMORY:
1092 get_user(address, (unsigned int *)userdata);
1093 get_user(length, (unsigned int *)userdata + 1);
1094 AR_DEBUG_PRINTF("Write Memory (address: 0x%x, length: %d)\n",
1095 address, length);
1096 if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
1097 A_MEMZERO(buffer, length);
1098 if (copy_from_user(buffer, &userdata[sizeof(address) +
1099 sizeof(length)], length))
1100 {
1101 ret = -EFAULT;
1102 } else {
1103 ret = BMIWriteMemory(hifDevice, address, buffer, length);
1104 }
1105 A_FREE(buffer);
1106 } else {
1107 ret = -ENOMEM;
1108 }
1109 break;
1110
1111 case AR6000_XIOCTL_BMI_TEST:
1112 AR_DEBUG_PRINTF("No longer supported\n");
1113 ret = -EOPNOTSUPP;
1114 break;
1115
1116 case AR6000_XIOCTL_BMI_EXECUTE:
1117 get_user(address, (unsigned int *)userdata);
1118 get_user(param, (unsigned int *)userdata + 1);
1119 AR_DEBUG_PRINTF("Execute (address: 0x%x, param: %d)\n",
1120 address, param);
1121 ret = BMIExecute(hifDevice, address, &param);
1122 put_user(param, (unsigned int *)rq->ifr_data); /* return value */
1123 break;
1124
1125 case AR6000_XIOCTL_BMI_SET_APP_START:
1126 get_user(address, (unsigned int *)userdata);
1127 AR_DEBUG_PRINTF("Set App Start (address: 0x%x)\n", address);
1128 ret = BMISetAppStart(hifDevice, address);
1129 break;
1130
1131 case AR6000_XIOCTL_BMI_READ_SOC_REGISTER:
1132 get_user(address, (unsigned int *)userdata);
1133 ret = BMIReadSOCRegister(hifDevice, address, &param);
1134 put_user(param, (unsigned int *)rq->ifr_data); /* return value */
1135 break;
1136
1137 case AR6000_XIOCTL_BMI_WRITE_SOC_REGISTER:
1138 get_user(address, (unsigned int *)userdata);
1139 get_user(param, (unsigned int *)userdata + 1);
1140 ret = BMIWriteSOCRegister(hifDevice, address, param);
1141 break;
1142
1143 #ifdef HTC_RAW_INTERFACE
1144 case AR6000_XIOCTL_HTC_RAW_OPEN:
1145 ret = A_OK;
1146 if (!arRawIfEnabled(ar)) {
1147 /* make sure block size is set in case the target was reset since last
1148 * BMI phase (i.e. flashup downloads) */
1149 ret = ar6000_SetHTCBlockSize(ar);
1150 if (A_FAILED(ret)) {
1151 break;
1152 }
1153 /* Terminate the BMI phase */
1154 ret = BMIDone(hifDevice);
1155 if (ret == A_OK) {
1156 ret = ar6000_htc_raw_open(ar);
1157 }
1158 }
1159 break;
1160
1161 case AR6000_XIOCTL_HTC_RAW_CLOSE:
1162 if (arRawIfEnabled(ar)) {
1163 ret = ar6000_htc_raw_close(ar);
1164 arRawIfEnabled(ar) = FALSE;
1165 } else {
1166 ret = A_ERROR;
1167 }
1168 break;
1169
1170 case AR6000_XIOCTL_HTC_RAW_READ:
1171 if (arRawIfEnabled(ar)) {
1172 unsigned int streamID;
1173 get_user(streamID, (unsigned int *)userdata);
1174 get_user(length, (unsigned int *)userdata + 1);
1175 buffer = rq->ifr_data + sizeof(length);
1176 ret = ar6000_htc_raw_read(ar, (HTC_RAW_STREAM_ID)streamID,
1177 buffer, length);
1178 put_user(ret, (unsigned int *)rq->ifr_data);
1179 } else {
1180 ret = A_ERROR;
1181 }
1182 break;
1183
1184 case AR6000_XIOCTL_HTC_RAW_WRITE:
1185 if (arRawIfEnabled(ar)) {
1186 unsigned int streamID;
1187 get_user(streamID, (unsigned int *)userdata);
1188 get_user(length, (unsigned int *)userdata + 1);
1189 buffer = userdata + sizeof(streamID) + sizeof(length);
1190 ret = ar6000_htc_raw_write(ar, (HTC_RAW_STREAM_ID)streamID,
1191 buffer, length);
1192 put_user(ret, (unsigned int *)rq->ifr_data);
1193 } else {
1194 ret = A_ERROR;
1195 }
1196 break;
1197 #endif /* HTC_RAW_INTERFACE */
1198
1199 case AR6000_IOCTL_WMI_GETREV:
1200 {
1201 if (copy_to_user(rq->ifr_data, &ar->arVersion,
1202 sizeof(ar->arVersion)))
1203 {
1204 ret = -EFAULT;
1205 }
1206 break;
1207 }
1208 case AR6000_IOCTL_WMI_SETPWR:
1209 {
1210 WMI_POWER_MODE_CMD pwrModeCmd;
1211
1212 if (ar->arWmiReady == FALSE) {
1213 ret = -EIO;
1214 } else if (copy_from_user(&pwrModeCmd, userdata,
1215 sizeof(pwrModeCmd)))
1216 {
1217 ret = -EFAULT;
1218 } else {
1219 if (wmi_powermode_cmd(ar->arWmi, pwrModeCmd.powerMode)
1220 != A_OK)
1221 {
1222 ret = -EIO;
1223 }
1224 }
1225 break;
1226 }
1227 case AR6000_IOCTL_WMI_SET_IBSS_PM_CAPS:
1228 {
1229 WMI_IBSS_PM_CAPS_CMD ibssPmCaps;
1230
1231 if (ar->arWmiReady == FALSE) {
1232 ret = -EIO;
1233 } else if (copy_from_user(&ibssPmCaps, userdata,
1234 sizeof(ibssPmCaps)))
1235 {
1236 ret = -EFAULT;
1237 } else {
1238 if (wmi_ibsspmcaps_cmd(ar->arWmi, ibssPmCaps.power_saving, ibssPmCaps.ttl,
1239 ibssPmCaps.atim_windows, ibssPmCaps.timeout_value) != A_OK)
1240 {
1241 ret = -EIO;
1242 }
1243 AR6000_SPIN_LOCK(&ar->arLock, 0);
1244 ar->arIbssPsEnable = ibssPmCaps.power_saving;
1245 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1246 }
1247 break;
1248 }
1249 case AR6000_IOCTL_WMI_SET_PMPARAMS:
1250 {
1251 WMI_POWER_PARAMS_CMD pmParams;
1252
1253 if (ar->arWmiReady == FALSE) {
1254 ret = -EIO;
1255 } else if (copy_from_user(&pmParams, userdata,
1256 sizeof(pmParams)))
1257 {
1258 ret = -EFAULT;
1259 } else {
1260 if (wmi_pmparams_cmd(ar->arWmi, pmParams.idle_period,
1261 pmParams.pspoll_number,
1262 pmParams.dtim_policy) != A_OK)
1263 {
1264 ret = -EIO;
1265 }
1266 }
1267 break;
1268 }
1269 case AR6000_IOCTL_WMI_SETSCAN:
1270 {
1271 if (ar->arWmiReady == FALSE) {
1272 ret = -EIO;
1273 } else if (copy_from_user(&scParams, userdata,
1274 sizeof(scParams)))
1275 {
1276 ret = -EFAULT;
1277 } else {
1278 if (CAN_SCAN_IN_CONNECT(scParams.scanCtrlFlags)) {
1279 ar->arSkipScan = FALSE;
1280 } else {
1281 ar->arSkipScan = TRUE;
1282 }
1283
1284 if (wmi_scanparams_cmd(ar->arWmi, scParams.fg_start_period,
1285 scParams.fg_end_period,
1286 scParams.bg_period,
1287 scParams.minact_chdwell_time,
1288 scParams.maxact_chdwell_time,
1289 scParams.pas_chdwell_time,
1290 scParams.shortScanRatio,
1291 scParams.scanCtrlFlags,
1292 scParams.max_dfsch_act_time) != A_OK)
1293 {
1294 ret = -EIO;
1295 }
1296 }
1297 break;
1298 }
1299 case AR6000_IOCTL_WMI_SETLISTENINT:
1300 {
1301 WMI_LISTEN_INT_CMD listenCmd;
1302
1303 if (ar->arWmiReady == FALSE) {
1304 ret = -EIO;
1305 } else if (copy_from_user(&listenCmd, userdata,
1306 sizeof(listenCmd)))
1307 {
1308 ret = -EFAULT;
1309 } else {
1310 if (wmi_listeninterval_cmd(ar->arWmi, listenCmd.listenInterval, listenCmd.numBeacons) != A_OK) {
1311 ret = -EIO;
1312 } else {
1313 AR6000_SPIN_LOCK(&ar->arLock, 0);
1314 ar->arListenInterval = param;
1315 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1316 }
1317
1318 }
1319 break;
1320 }
1321 case AR6000_IOCTL_WMI_SET_BMISS_TIME:
1322 {
1323 WMI_BMISS_TIME_CMD bmissCmd;
1324
1325 if (ar->arWmiReady == FALSE) {
1326 ret = -EIO;
1327 } else if (copy_from_user(&bmissCmd, userdata,
1328 sizeof(bmissCmd)))
1329 {
1330 ret = -EFAULT;
1331 } else {
1332 if (wmi_bmisstime_cmd(ar->arWmi, bmissCmd.bmissTime, bmissCmd.numBeacons) != A_OK) {
1333 ret = -EIO;
1334 }
1335 }
1336 break;
1337 }
1338 case AR6000_IOCTL_WMI_SETBSSFILTER:
1339 {
1340 if (ar->arWmiReady == FALSE) {
1341 ret = -EIO;
1342 } else {
1343
1344 get_user(param, (unsigned char *)userdata);
1345 get_user(param2, (unsigned int *)(userdata + 1));
1346 printk("SETBSSFILTER: filter 0x%x, mask: 0x%x\n", param, param2);
1347 if (wmi_bssfilter_cmd(ar->arWmi, param, param2) != A_OK) {
1348 ret = -EIO;
1349 }
1350 }
1351 break;
1352 }
1353 case AR6000_IOCTL_WMI_SET_SNRTHRESHOLD:
1354 {
1355 ret = ar6000_ioctl_set_snr_threshold(dev, rq);
1356 break;
1357 }
1358 case AR6000_XIOCTL_WMI_SET_RSSITHRESHOLD:
1359 {
1360 ret = ar6000_ioctl_set_rssi_threshold(dev, rq);
1361 break;
1362 }
1363 case AR6000_XIOCTL_WMI_CLR_RSSISNR:
1364 {
1365 if (ar->arWmiReady == FALSE) {
1366 ret = -EIO;
1367 }
1368 ret = wmi_clr_rssi_snr(ar->arWmi);
1369 break;
1370 }
1371 case AR6000_XIOCTL_WMI_SET_LQTHRESHOLD:
1372 {
1373 ret = ar6000_ioctl_set_lq_threshold(dev, rq);
1374 break;
1375 }
1376 case AR6000_XIOCTL_WMI_SET_LPREAMBLE:
1377 {
1378 WMI_SET_LPREAMBLE_CMD setLpreambleCmd;
1379
1380 if (ar->arWmiReady == FALSE) {
1381 ret = -EIO;
1382 } else if (copy_from_user(&setLpreambleCmd, userdata,
1383 sizeof(setLpreambleCmd)))
1384 {
1385 ret = -EFAULT;
1386 } else {
1387 if (wmi_set_lpreamble_cmd(ar->arWmi, setLpreambleCmd.status)
1388 != A_OK)
1389 {
1390 ret = -EIO;
1391 }
1392 }
1393
1394 break;
1395 }
1396 case AR6000_XIOCTL_WMI_SET_RTS:
1397 {
1398 WMI_SET_RTS_CMD rtsCmd;
1399
1400 if (ar->arWmiReady == FALSE) {
1401 ret = -EIO;
1402 } else if (copy_from_user(&rtsCmd, userdata,
1403 sizeof(rtsCmd)))
1404 {
1405 ret = -EFAULT;
1406 } else {
1407 if (wmi_set_rts_cmd(ar->arWmi, rtsCmd.threshold)
1408 != A_OK)
1409 {
1410 ret = -EIO;
1411 }
1412 }
1413
1414 break;
1415 }
1416 case AR6000_XIOCTL_WMI_SET_WMM:
1417 {
1418 ret = ar6000_ioctl_set_wmm(dev, rq);
1419 break;
1420 }
1421 case AR6000_XIOCTL_WMI_SET_TXOP:
1422 {
1423 ret = ar6000_ioctl_set_txop(dev, rq);
1424 break;
1425 }
1426 case AR6000_XIOCTL_WMI_GET_RD:
1427 {
1428 ret = ar6000_ioctl_get_rd(dev, rq);
1429 break;
1430 }
1431 case AR6000_IOCTL_WMI_SET_CHANNELPARAMS:
1432 {
1433 ret = ar6000_ioctl_set_channelParams(dev, rq);
1434 break;
1435 }
1436 case AR6000_IOCTL_WMI_SET_PROBEDSSID:
1437 {
1438 ret = ar6000_ioctl_set_probedSsid(dev, rq);
1439 break;
1440 }
1441 case AR6000_IOCTL_WMI_SET_BADAP:
1442 {
1443 ret = ar6000_ioctl_set_badAp(dev, rq);
1444 break;
1445 }
1446 case AR6000_IOCTL_WMI_CREATE_QOS:
1447 {
1448 ret = ar6000_ioctl_create_qos(dev, rq);
1449 break;
1450 }
1451 case AR6000_IOCTL_WMI_DELETE_QOS:
1452 {
1453 ret = ar6000_ioctl_delete_qos(dev, rq);
1454 break;
1455 }
1456 case AR6000_IOCTL_WMI_GET_QOS_QUEUE:
1457 {
1458 ret = ar6000_ioctl_get_qos_queue(dev, rq);
1459 break;
1460 }
1461 case AR6000_IOCTL_WMI_GET_TARGET_STATS:
1462 {
1463 ret = ar6000_ioctl_get_target_stats(dev, rq);
1464 break;
1465 }
1466 case AR6000_IOCTL_WMI_SET_ERROR_REPORT_BITMASK:
1467 {
1468 ret = ar6000_ioctl_set_error_report_bitmask(dev, rq);
1469 break;
1470 }
1471 case AR6000_IOCTL_WMI_SET_ASSOC_INFO:
1472 {
1473 WMI_SET_ASSOC_INFO_CMD cmd;
1474 A_UINT8 assocInfo[WMI_MAX_ASSOC_INFO_LEN];
1475
1476 if (ar->arWmiReady == FALSE) {
1477 ret = -EIO;
1478 } else {
1479 get_user(cmd.ieType, userdata);
1480 if (cmd.ieType >= WMI_MAX_ASSOC_INFO_TYPE) {
1481 ret = -EIO;
1482 } else {
1483 get_user(cmd.bufferSize, userdata + 1);
1484 if (cmd.bufferSize > WMI_MAX_ASSOC_INFO_LEN) {
1485 ret = -EFAULT;
1486 break;
1487 }
1488 if (copy_from_user(assocInfo, userdata + 2,
1489 cmd.bufferSize))
1490 {
1491 ret = -EFAULT;
1492 } else {
1493 if (wmi_associnfo_cmd(ar->arWmi, cmd.ieType,
1494 cmd.bufferSize,
1495 assocInfo) != A_OK)
1496 {
1497 ret = -EIO;
1498 }
1499 }
1500 }
1501 }
1502 break;
1503 }
1504 case AR6000_IOCTL_WMI_SET_ACCESS_PARAMS:
1505 {
1506 ret = ar6000_ioctl_set_access_params(dev, rq);
1507 break;
1508 }
1509 case AR6000_IOCTL_WMI_SET_DISC_TIMEOUT:
1510 {
1511 ret = ar6000_ioctl_set_disconnect_timeout(dev, rq);
1512 break;
1513 }
1514 case AR6000_XIOCTL_FORCE_TARGET_RESET:
1515 {
1516 if (ar->arHtcTarget)
1517 {
1518 // HTCForceReset(htcTarget);
1519 }
1520 else
1521 {
1522 AR_DEBUG_PRINTF("ar6000_ioctl cannot attempt reset.\n");
1523 }
1524 break;
1525 }
1526 case AR6000_XIOCTL_TARGET_INFO:
1527 case AR6000_XIOCTL_CHECK_TARGET_READY: /* backwards compatibility */
1528 {
1529 /* If we made it to here, then the Target exists and is ready. */
1530
1531 if (cmd == AR6000_XIOCTL_TARGET_INFO) {
1532 if (copy_to_user((A_UINT32 *)rq->ifr_data, &ar->arVersion.target_ver,
1533 sizeof(ar->arVersion.target_ver)))
1534 {
1535 ret = -EFAULT;
1536 }
1537 if (copy_to_user(((A_UINT32 *)rq->ifr_data)+1, &ar->arTargetType,
1538 sizeof(ar->arTargetType)))
1539 {
1540 ret = -EFAULT;
1541 }
1542 }
1543 break;
1544 }
1545 case AR6000_XIOCTL_WMI_SET_HB_CHALLENGE_RESP_PARAMS:
1546 {
1547 WMI_SET_HB_CHALLENGE_RESP_PARAMS_CMD hbparam;
1548
1549 if (copy_from_user(&hbparam, userdata, sizeof(hbparam)))
1550 {
1551 ret = -EFAULT;
1552 } else {
1553 AR6000_SPIN_LOCK(&ar->arLock, 0);
1554 /* Start a cyclic timer with the parameters provided. */
1555 if (hbparam.frequency) {
1556 ar->arHBChallengeResp.frequency = hbparam.frequency;
1557 }
1558 if (hbparam.threshold) {
1559 ar->arHBChallengeResp.missThres = hbparam.threshold;
1560 }
1561
1562 /* Delete the pending timer and start a new one */
1563 if (timer_pending(&ar->arHBChallengeResp.timer)) {
1564 A_UNTIMEOUT(&ar->arHBChallengeResp.timer);
1565 }
1566 A_TIMEOUT_MS(&ar->arHBChallengeResp.timer, ar->arHBChallengeResp.frequency * 1000, 0);
1567 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1568 }
1569 break;
1570 }
1571 case AR6000_XIOCTL_WMI_GET_HB_CHALLENGE_RESP:
1572 {
1573 A_UINT32 cookie;
1574
1575 if (copy_from_user(&cookie, userdata, sizeof(cookie))) {
1576 return -EFAULT;
1577 }
1578
1579 /* Send the challenge on the control channel */
1580 if (wmi_get_challenge_resp_cmd(ar->arWmi, cookie, APP_HB_CHALLENGE) != A_OK) {
1581 return -EIO;
1582 }
1583 break;
1584 }
1585 #ifdef USER_KEYS
1586 case AR6000_XIOCTL_USER_SETKEYS:
1587 {
1588
1589 ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_RUN;
1590
1591 if (copy_from_user(&ar->user_key_ctrl, userdata,
1592 sizeof(ar->user_key_ctrl)))
1593 {
1594 return -EFAULT;
1595 }
1596
1597 A_PRINTF("ar6000 USER set key %x\n", ar->user_key_ctrl);
1598 break;
1599 }
1600 #endif /* USER_KEYS */
1601
1602 #ifdef CONFIG_HOST_GPIO_SUPPORT
1603 case AR6000_XIOCTL_GPIO_OUTPUT_SET:
1604 {
1605 struct ar6000_gpio_output_set_cmd_s gpio_output_set_cmd;
1606
1607 if (ar->arWmiReady == FALSE) {
1608 return -EIO;
1609 }
1610 if (down_interruptible(&ar->arSem)) {
1611 return -ERESTARTSYS;
1612 }
1613
1614 if (copy_from_user(&gpio_output_set_cmd, userdata,
1615 sizeof(gpio_output_set_cmd)))
1616 {
1617 ret = -EFAULT;
1618 } else {
1619 ret = ar6000_gpio_output_set(dev,
1620 gpio_output_set_cmd.set_mask,
1621 gpio_output_set_cmd.clear_mask,
1622 gpio_output_set_cmd.enable_mask,
1623 gpio_output_set_cmd.disable_mask);
1624 if (ret != A_OK) {
1625 ret = EIO;
1626 }
1627 }
1628 up(&ar->arSem);
1629 break;
1630 }
1631 case AR6000_XIOCTL_GPIO_INPUT_GET:
1632 {
1633 if (ar->arWmiReady == FALSE) {
1634 return -EIO;
1635 }
1636 if (down_interruptible(&ar->arSem)) {
1637 return -ERESTARTSYS;
1638 }
1639
1640 ret = ar6000_gpio_input_get(dev);
1641 if (ret != A_OK) {
1642 up(&ar->arSem);
1643 return -EIO;
1644 }
1645
1646 /* Wait for Target to respond. */
1647 wait_event_interruptible(arEvent, gpio_data_available);
1648 if (signal_pending(current)) {
1649 ret = -EINTR;
1650 } else {
1651 A_ASSERT(gpio_reg_results.gpioreg_id == GPIO_ID_NONE);
1652
1653 if (copy_to_user(userdata, &gpio_reg_results.value,
1654 sizeof(gpio_reg_results.value)))
1655 {
1656 ret = -EFAULT;
1657 }
1658 }
1659 up(&ar->arSem);
1660 break;
1661 }
1662 case AR6000_XIOCTL_GPIO_REGISTER_SET:
1663 {
1664 struct ar6000_gpio_register_cmd_s gpio_register_cmd;
1665
1666 if (ar->arWmiReady == FALSE) {
1667 return -EIO;
1668 }
1669 if (down_interruptible(&ar->arSem)) {
1670 return -ERESTARTSYS;
1671 }
1672
1673 if (copy_from_user(&gpio_register_cmd, userdata,
1674 sizeof(gpio_register_cmd)))
1675 {
1676 ret = -EFAULT;
1677 } else {
1678 ret = ar6000_gpio_register_set(dev,
1679 gpio_register_cmd.gpioreg_id,
1680 gpio_register_cmd.value);
1681 if (ret != A_OK) {
1682 ret = EIO;
1683 }
1684
1685 /* Wait for acknowledgement from Target */
1686 wait_event_interruptible(arEvent, gpio_ack_received);
1687 if (signal_pending(current)) {
1688 ret = -EINTR;
1689 }
1690 }
1691 up(&ar->arSem);
1692 break;
1693 }
1694 case AR6000_XIOCTL_GPIO_REGISTER_GET:
1695 {
1696 struct ar6000_gpio_register_cmd_s gpio_register_cmd;
1697
1698 if (ar->arWmiReady == FALSE) {
1699 return -EIO;
1700 }
1701 if (down_interruptible(&ar->arSem)) {
1702 return -ERESTARTSYS;
1703 }
1704
1705 if (copy_from_user(&gpio_register_cmd, userdata,
1706 sizeof(gpio_register_cmd)))
1707 {
1708 ret = -EFAULT;
1709 } else {
1710 ret = ar6000_gpio_register_get(dev, gpio_register_cmd.gpioreg_id);
1711 if (ret != A_OK) {
1712 up(&ar->arSem);
1713 return -EIO;
1714 }
1715
1716 /* Wait for Target to respond. */
1717 wait_event_interruptible(arEvent, gpio_data_available);
1718 if (signal_pending(current)) {
1719 ret = -EINTR;
1720 } else {
1721 A_ASSERT(gpio_register_cmd.gpioreg_id == gpio_reg_results.gpioreg_id);
1722 if (copy_to_user(userdata, &gpio_reg_results,
1723 sizeof(gpio_reg_results)))
1724 {
1725 ret = -EFAULT;
1726 }
1727 }
1728 }
1729 up(&ar->arSem);
1730 break;
1731 }
1732 case AR6000_XIOCTL_GPIO_INTR_ACK:
1733 {
1734 struct ar6000_gpio_intr_ack_cmd_s gpio_intr_ack_cmd;
1735
1736 if (ar->arWmiReady == FALSE) {
1737 return -EIO;
1738 }
1739 if (down_interruptible(&ar->arSem)) {
1740 return -ERESTARTSYS;
1741 }
1742
1743 if (copy_from_user(&gpio_intr_ack_cmd, userdata,
1744 sizeof(gpio_intr_ack_cmd)))
1745 {
1746 ret = -EFAULT;
1747 } else {
1748 ret = ar6000_gpio_intr_ack(dev, gpio_intr_ack_cmd.ack_mask);
1749 if (ret != A_OK) {
1750 ret = EIO;
1751 }
1752 }
1753 up(&ar->arSem);
1754 break;
1755 }
1756 case AR6000_XIOCTL_GPIO_INTR_WAIT:
1757 {
1758 /* Wait for Target to report an interrupt. */
1759 dev_hold(dev);
1760 rtnl_unlock();
1761 wait_event_interruptible(arEvent, gpio_intr_available);
1762 rtnl_lock();
1763 __dev_put(dev);
1764
1765 if (signal_pending(current)) {
1766 ret = -EINTR;
1767 } else {
1768 if (copy_to_user(userdata, &gpio_intr_results,
1769 sizeof(gpio_intr_results)))
1770 {
1771 ret = -EFAULT;
1772 }
1773 }
1774 break;
1775 }
1776 #endif /* CONFIG_HOST_GPIO_SUPPORT */
1777
1778 case AR6000_XIOCTL_DBGLOG_CFG_MODULE:
1779 {
1780 struct ar6000_dbglog_module_config_s config;
1781
1782 if (copy_from_user(&config, userdata, sizeof(config))) {
1783 return -EFAULT;
1784 }
1785
1786 /* Send the challenge on the control channel */
1787 if (wmi_config_debug_module_cmd(ar->arWmi, config.mmask,
1788 config.tsr, config.rep,
1789 config.size, config.valid) != A_OK)
1790 {
1791 return -EIO;
1792 }
1793 break;
1794 }
1795
1796 case AR6000_XIOCTL_DBGLOG_GET_DEBUG_LOGS:
1797 {
1798 /* Send the challenge on the control channel */
1799 if (ar6000_dbglog_get_debug_logs(ar) != A_OK)
1800 {
1801 return -EIO;
1802 }
1803 break;
1804 }
1805
1806 case AR6000_XIOCTL_SET_ADHOC_BSSID:
1807 {
1808 WMI_SET_ADHOC_BSSID_CMD adhocBssid;
1809
1810 if (ar->arWmiReady == FALSE) {
1811 ret = -EIO;
1812 } else if (copy_from_user(&adhocBssid, userdata,
1813 sizeof(adhocBssid)))
1814 {
1815 ret = -EFAULT;
1816 } else if (A_MEMCMP(adhocBssid.bssid, bcast_mac,
1817 AR6000_ETH_ADDR_LEN) == 0)
1818 {
1819 ret = -EFAULT;
1820 } else {
1821
1822 A_MEMCPY(ar->arReqBssid, adhocBssid.bssid, sizeof(ar->arReqBssid));
1823 }
1824 break;
1825 }
1826
1827 case AR6000_XIOCTL_SET_OPT_MODE:
1828 {
1829 WMI_SET_OPT_MODE_CMD optModeCmd;
1830 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
1831
1832 if (ar->arWmiReady == FALSE) {
1833 ret = -EIO;
1834 } else if (copy_from_user(&optModeCmd, userdata,
1835 sizeof(optModeCmd)))
1836 {
1837 ret = -EFAULT;
1838 } else if (ar->arConnected && optModeCmd.optMode == SPECIAL_ON) {
1839 ret = -EFAULT;
1840
1841 } else if (wmi_set_opt_mode_cmd(ar->arWmi, optModeCmd.optMode)
1842 != A_OK)
1843 {
1844 ret = -EIO;
1845 }
1846 break;
1847 }
1848
1849 case AR6000_XIOCTL_OPT_SEND_FRAME:
1850 {
1851 WMI_OPT_TX_FRAME_CMD optTxFrmCmd;
1852 A_UINT8 data[MAX_OPT_DATA_LEN];
1853
1854 if (ar->arWmiReady == FALSE) {
1855 ret = -EIO;
1856 } else if (copy_from_user(&optTxFrmCmd, userdata,
1857 sizeof(optTxFrmCmd)))
1858 {
1859 ret = -EFAULT;
1860 } else if (copy_from_user(data,
1861 userdata+sizeof(WMI_OPT_TX_FRAME_CMD)-1,
1862 optTxFrmCmd.optIEDataLen))
1863 {
1864 ret = -EFAULT;
1865 } else {
1866 ret = wmi_opt_tx_frame_cmd(ar->arWmi,
1867 optTxFrmCmd.frmType,
1868 optTxFrmCmd.dstAddr,
1869 optTxFrmCmd.bssid,
1870 optTxFrmCmd.optIEDataLen,
1871 data);
1872 }
1873
1874 break;
1875 }
1876 case AR6000_XIOCTL_WMI_SETRETRYLIMITS:
1877 {
1878 WMI_SET_RETRY_LIMITS_CMD setRetryParams;
1879
1880 if (ar->arWmiReady == FALSE) {
1881 ret = -EIO;
1882 } else if (copy_from_user(&setRetryParams, userdata,
1883 sizeof(setRetryParams)))
1884 {
1885 ret = -EFAULT;
1886 } else {
1887 if (wmi_set_retry_limits_cmd(ar->arWmi, setRetryParams.frameType,
1888 setRetryParams.trafficClass,
1889 setRetryParams.maxRetries,
1890 setRetryParams.enableNotify) != A_OK)
1891 {
1892 ret = -EIO;
1893 }
1894 AR6000_SPIN_LOCK(&ar->arLock, 0);
1895 ar->arMaxRetries = setRetryParams.maxRetries;
1896 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1897 }
1898 break;
1899 }
1900
1901 case AR6000_XIOCTL_SET_ADHOC_BEACON_INTVAL:
1902 {
1903 WMI_BEACON_INT_CMD bIntvlCmd;
1904
1905 if (ar->arWmiReady == FALSE) {
1906 ret = -EIO;
1907 } else if (copy_from_user(&bIntvlCmd, userdata,
1908 sizeof(bIntvlCmd)))
1909 {
1910 ret = -EFAULT;
1911 } else if (wmi_set_adhoc_bconIntvl_cmd(ar->arWmi, bIntvlCmd.beaconInterval)
1912 != A_OK)
1913 {
1914 ret = -EIO;
1915 }
1916 break;
1917 }
1918 case IEEE80211_IOCTL_SETAUTHALG:
1919 {
1920 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
1921 struct ieee80211req_authalg req;
1922
1923 if (ar->arWmiReady == FALSE) {
1924 ret = -EIO;
1925 } else if (copy_from_user(&req, userdata,
1926 sizeof(struct ieee80211req_authalg)))
1927 {
1928 ret = -EFAULT;
1929 } else if (req.auth_alg == AUTH_ALG_OPEN_SYSTEM) {
1930 ar->arDot11AuthMode = OPEN_AUTH;
1931 ar->arPairwiseCrypto = NONE_CRYPT;
1932 ar->arGroupCrypto = NONE_CRYPT;
1933 } else if (req.auth_alg == AUTH_ALG_LEAP) {
1934 ar->arDot11AuthMode = LEAP_AUTH;
1935 } else {
1936 ret = -EIO;
1937 }
1938 break;
1939 }
1940
1941 case AR6000_XIOCTL_SET_VOICE_PKT_SIZE:
1942 ret = ar6000_xioctl_set_voice_pkt_size(dev, userdata);
1943 break;
1944
1945 case AR6000_XIOCTL_SET_MAX_SP:
1946 ret = ar6000_xioctl_set_max_sp_len(dev, userdata);
1947 break;
1948
1949 case AR6000_XIOCTL_WMI_GET_ROAM_TBL:
1950 ret = ar6000_ioctl_get_roam_tbl(dev, rq);
1951 break;
1952 case AR6000_XIOCTL_WMI_SET_ROAM_CTRL:
1953 ret = ar6000_ioctl_set_roam_ctrl(dev, userdata);
1954 break;
1955 case AR6000_XIOCTRL_WMI_SET_POWERSAVE_TIMERS:
1956 ret = ar6000_ioctl_set_powersave_timers(dev, userdata);
1957 break;
1958 case AR6000_XIOCTRL_WMI_GET_POWER_MODE:
1959 ret = ar6000_ioctl_get_power_mode(dev, rq);
1960 break;
1961 case AR6000_XIOCTRL_WMI_SET_WLAN_STATE:
1962 get_user(ar->arWlanState, (unsigned int *)userdata);
1963 if (ar->arWmiReady == FALSE) {
1964 ret = -EIO;
1965 break;
1966 }
1967
1968 if (ar->arWlanState == WLAN_ENABLED) {
1969 /* Enable foreground scanning */
1970 if (wmi_scanparams_cmd(ar->arWmi, scParams.fg_start_period,
1971 scParams.fg_end_period,
1972 scParams.bg_period,
1973 scParams.minact_chdwell_time,
1974 scParams.maxact_chdwell_time,
1975 scParams.pas_chdwell_time,
1976 scParams.shortScanRatio,
1977 scParams.scanCtrlFlags,
1978 scParams.max_dfsch_act_time) != A_OK)
1979 {
1980 ret = -EIO;
1981 }
1982 if (ar->arSsidLen) {
1983 ar->arConnectPending = TRUE;
1984 if (wmi_connect_cmd(ar->arWmi, ar->arNetworkType,
1985 ar->arDot11AuthMode, ar->arAuthMode,
1986 ar->arPairwiseCrypto,
1987 ar->arPairwiseCryptoLen,
1988 ar->arGroupCrypto, ar->arGroupCryptoLen,
1989 ar->arSsidLen, ar->arSsid,
1990 ar->arReqBssid, ar->arChannelHint,
1991 ar->arConnectCtrlFlags) != A_OK)
1992 {
1993 ret = -EIO;
1994 ar->arConnectPending = FALSE;
1995 }
1996 }
1997 } else {
1998 /* Disconnect from the AP and disable foreground scanning */
1999 AR6000_SPIN_LOCK(&ar->arLock, 0);
2000 if (ar->arConnected == TRUE || ar->arConnectPending == TRUE) {
2001 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2002 wmi_disconnect_cmd(ar->arWmi);
2003 } else {
2004 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2005 }
2006
2007 if (wmi_scanparams_cmd(ar->arWmi, 0xFFFF, 0, 0, 0, 0, 0, 0, 0xFF, 0) != A_OK)
2008 {
2009 ret = -EIO;
2010 }
2011 }
2012 break;
2013 case AR6000_XIOCTL_WMI_GET_ROAM_DATA:
2014 ret = ar6000_ioctl_get_roam_data(dev, rq);
2015 break;
2016 case AR6000_XIOCTL_WMI_SET_BT_STATUS:
2017 ret = ar6000_xioctl_set_bt_status_cmd(dev, userdata);
2018 break;
2019 case AR6000_XIOCTL_WMI_SET_BT_PARAMS:
2020 ret = ar6000_xioctl_set_bt_params_cmd(dev, userdata);
2021 break;
2022 case AR6000_XIOCTL_WMI_STARTSCAN:
2023 {
2024 WMI_START_SCAN_CMD setStartScanCmd;
2025
2026 if (ar->arWmiReady == FALSE) {
2027 ret = -EIO;
2028 } else if (copy_from_user(&setStartScanCmd, userdata,
2029 sizeof(setStartScanCmd)))
2030 {
2031 ret = -EFAULT;
2032 } else {
2033 if (wmi_startscan_cmd(ar->arWmi, setStartScanCmd.scanType,
2034 setStartScanCmd.forceFgScan,
2035 setStartScanCmd.isLegacy,
2036 setStartScanCmd.homeDwellTime,
2037 setStartScanCmd.forceScanInterval) != A_OK)
2038 {
2039 ret = -EIO;
2040 }
2041 }
2042 break;
2043 }
2044 case AR6000_XIOCTL_WMI_SETFIXRATES:
2045 {
2046 WMI_FIX_RATES_CMD setFixRatesCmd;
2047 A_STATUS returnStatus;
2048
2049 if (ar->arWmiReady == FALSE) {
2050 ret = -EIO;
2051 } else if (copy_from_user(&setFixRatesCmd, userdata,
2052 sizeof(setFixRatesCmd)))
2053 {
2054 ret = -EFAULT;
2055 } else {
2056 returnStatus = wmi_set_fixrates_cmd(ar->arWmi, setFixRatesCmd.fixRateMask);
2057 if (returnStatus == A_EINVAL)
2058 {
2059 ret = -EINVAL;
2060 }
2061 else if(returnStatus != A_OK) {
2062 ret = -EIO;
2063 }
2064 }
2065 break;
2066 }
2067
2068 case AR6000_XIOCTL_WMI_GETFIXRATES:
2069 {
2070 WMI_FIX_RATES_CMD getFixRatesCmd;
2071 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
2072 int ret = 0;
2073
2074 if (ar->arWmiReady == FALSE) {
2075 return -EIO;
2076 }
2077
2078 if (down_interruptible(&ar->arSem)) {
2079 return -ERESTARTSYS;
2080 }
2081 /* Used copy_from_user/copy_to_user to access user space data */
2082 if (copy_from_user(&getFixRatesCmd, userdata, sizeof(getFixRatesCmd))) {
2083 ret = -EFAULT;
2084 } else {
2085 ar->arRateMask = 0xFFFF;
2086
2087 if (wmi_get_ratemask_cmd(ar->arWmi) != A_OK) {
2088 up(&ar->arSem);
2089 return -EIO;
2090 }
2091
2092 wait_event_interruptible_timeout(arEvent, ar->arRateMask != 0xFFFF, wmitimeout * HZ);
2093
2094 if (signal_pending(current)) {
2095 ret = -EINTR;
2096 }
2097
2098 if (!ret) {
2099 getFixRatesCmd.fixRateMask = ar->arRateMask;
2100 }
2101
2102 if(copy_to_user(userdata, &getFixRatesCmd, sizeof(getFixRatesCmd))) {
2103 ret = -EFAULT;
2104 }
2105
2106 up(&ar->arSem);
2107 }
2108 break;
2109 }
2110 case AR6000_XIOCTL_WMI_SET_AUTHMODE:
2111 {
2112 WMI_SET_AUTH_MODE_CMD setAuthMode;
2113
2114 if (ar->arWmiReady == FALSE) {
2115 ret = -EIO;
2116 } else if (copy_from_user(&setAuthMode, userdata,
2117 sizeof(setAuthMode)))
2118 {
2119 ret = -EFAULT;
2120 } else {
2121 if (wmi_set_authmode_cmd(ar->arWmi, setAuthMode.mode) != A_OK)
2122 {
2123 ret = -EIO;
2124 }
2125 }
2126 break;
2127 }
2128 case AR6000_XIOCTL_WMI_SET_REASSOCMODE:
2129 {
2130 WMI_SET_REASSOC_MODE_CMD setReassocMode;
2131
2132 if (ar->arWmiReady == FALSE) {
2133 ret = -EIO;
2134 } else if (copy_from_user(&setReassocMode, userdata,
2135 sizeof(setReassocMode)))
2136 {
2137 ret = -EFAULT;
2138 } else {
2139 if (wmi_set_reassocmode_cmd(ar->arWmi, setReassocMode.mode) != A_OK)
2140 {
2141 ret = -EIO;
2142 }
2143 }
2144 break;
2145 }
2146 case AR6000_XIOCTL_DIAG_READ:
2147 {
2148 A_UINT32 addr, data;
2149 get_user(addr, (unsigned int *)userdata);
2150 if (ar6000_ReadRegDiag(ar->arHifDevice, &addr, &data) != A_OK) {
2151 ret = -EIO;
2152 }
2153 put_user(data, (unsigned int *)userdata + 1);
2154 break;
2155 }
2156 case AR6000_XIOCTL_DIAG_WRITE:
2157 {
2158 A_UINT32 addr, data;
2159 get_user(addr, (unsigned int *)userdata);
2160 get_user(data, (unsigned int *)userdata + 1);
2161 if (ar6000_WriteRegDiag(ar->arHifDevice, &addr, &data) != A_OK) {
2162 ret = -EIO;
2163 }
2164 break;
2165 }
2166 case AR6000_XIOCTL_WMI_SET_KEEPALIVE:
2167 {
2168 WMI_SET_KEEPALIVE_CMD setKeepAlive;
2169 if (ar->arWmiReady == FALSE) {
2170 return -EIO;
2171 } else if (copy_from_user(&setKeepAlive, userdata,
2172 sizeof(setKeepAlive))){
2173 ret = -EFAULT;
2174 } else {
2175 if (wmi_set_keepalive_cmd(ar->arWmi, setKeepAlive.keepaliveInterval) != A_OK) {
2176 ret = -EIO;
2177 }
2178 }
2179 break;
2180 }
2181 case AR6000_XIOCTL_WMI_GET_KEEPALIVE:
2182 {
2183 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
2184 WMI_GET_KEEPALIVE_CMD getKeepAlive;
2185 int ret = 0;
2186 if (ar->arWmiReady == FALSE) {
2187 return -EIO;
2188 }
2189 if (down_interruptible(&ar->arSem)) {
2190 return -ERESTARTSYS;
2191 }
2192 if (copy_from_user(&getKeepAlive, userdata,sizeof(getKeepAlive))) {
2193 ret = -EFAULT;
2194 } else {
2195 getKeepAlive.keepaliveInterval = wmi_get_keepalive_cmd(ar->arWmi);
2196 ar->arKeepaliveConfigured = 0xFF;
2197 if (wmi_get_keepalive_configured(ar->arWmi) != A_OK){
2198 up(&ar->arSem);
2199 return -EIO;
2200 }
2201 wait_event_interruptible_timeout(arEvent, ar->arKeepaliveConfigured != 0xFF, wmitimeout * HZ);
2202 if (signal_pending(current)) {
2203 ret = -EINTR;
2204 }
2205
2206 if (!ret) {
2207 getKeepAlive.configured = ar->arKeepaliveConfigured;
2208 }
2209 if (copy_to_user(userdata, &getKeepAlive, sizeof(getKeepAlive))) {
2210 ret = -EFAULT;
2211 }
2212 up(&ar->arSem);
2213 }
2214 break;
2215 }
2216 case AR6000_XIOCTL_WMI_SET_APPIE:
2217 {
2218 WMI_SET_APPIE_CMD appIEcmd;
2219 A_UINT8 appIeInfo[IEEE80211_APPIE_FRAME_MAX_LEN];
2220 A_UINT32 fType,ieLen;
2221
2222 if (ar->arWmiReady == FALSE) {
2223 return -EIO;
2224 }
2225 get_user(fType, (A_UINT32 *)userdata);
2226 appIEcmd.mgmtFrmType = fType;
2227 if (appIEcmd.mgmtFrmType >= IEEE80211_APPIE_NUM_OF_FRAME) {
2228 ret = -EIO;
2229 } else {
2230 get_user(ieLen, (A_UINT32 *)(userdata + 4));
2231 appIEcmd.ieLen = ieLen;
2232 if (appIEcmd.ieLen > IEEE80211_APPIE_FRAME_MAX_LEN) {
2233 ret = -EIO;
2234 break;
2235 }
2236 if (copy_from_user(appIeInfo, userdata + 8, appIEcmd.ieLen)) {
2237 ret = -EFAULT;
2238 } else {
2239 if (wmi_set_appie_cmd(ar->arWmi, appIEcmd.mgmtFrmType,
2240 appIEcmd.ieLen, appIeInfo) != A_OK)
2241 {
2242 ret = -EIO;
2243 }
2244 }
2245 }
2246 break;
2247 }
2248 case AR6000_XIOCTL_WMI_SET_MGMT_FRM_RX_FILTER:
2249 {
2250 WMI_BSS_FILTER_CMD cmd;
2251 A_UINT32 filterType;
2252
2253 if (copy_from_user(&filterType, userdata, sizeof(A_UINT32)))
2254 {
2255 return -EFAULT;
2256 }
2257 if (filterType & (IEEE80211_FILTER_TYPE_BEACON |
2258 IEEE80211_FILTER_TYPE_PROBE_RESP))
2259 {
2260 cmd.bssFilter = ALL_BSS_FILTER;
2261 } else {
2262 cmd.bssFilter = NONE_BSS_FILTER;
2263 }
2264 if (wmi_bssfilter_cmd(ar->arWmi, cmd.bssFilter, 0) != A_OK) {
2265 ret = -EIO;
2266 }
2267
2268 AR6000_SPIN_LOCK(&ar->arLock, 0);
2269 ar->arMgmtFilter = filterType;
2270 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2271 break;
2272 }
2273 case AR6000_XIOCTL_WMI_SET_WSC_STATUS:
2274 {
2275 A_UINT32 wsc_status;
2276
2277 if (copy_from_user(&wsc_status, userdata, sizeof(A_UINT32)))
2278 {
2279 return -EFAULT;
2280 }
2281 if (wmi_set_wsc_status_cmd(ar->arWmi, wsc_status) != A_OK) {
2282 ret = -EIO;
2283 }
2284 break;
2285 }
2286 case AR6000_XIOCTL_BMI_ROMPATCH_INSTALL:
2287 {
2288 A_UINT32 ROM_addr;
2289 A_UINT32 RAM_addr;
2290 A_UINT32 nbytes;
2291 A_UINT32 do_activate;
2292 A_UINT32 rompatch_id;
2293
2294 get_user(ROM_addr, (A_UINT32 *)userdata);
2295 get_user(RAM_addr, (A_UINT32 *)userdata + 1);
2296 get_user(nbytes, (A_UINT32 *)userdata + 2);
2297 get_user(do_activate, (A_UINT32 *)userdata + 3);
2298 AR_DEBUG_PRINTF("Install rompatch from ROM: 0x%x to RAM: 0x%x length: %d\n",
2299 ROM_addr, RAM_addr, nbytes);
2300 ret = BMIrompatchInstall(hifDevice, ROM_addr, RAM_addr,
2301 nbytes, do_activate, &rompatch_id);
2302 if (ret == A_OK) {
2303 put_user(rompatch_id, (unsigned int *)rq->ifr_data); /* return value */
2304 }
2305 break;
2306 }
2307
2308 case AR6000_XIOCTL_BMI_ROMPATCH_UNINSTALL:
2309 {
2310 A_UINT32 rompatch_id;
2311
2312 get_user(rompatch_id, (A_UINT32 *)userdata);
2313 AR_DEBUG_PRINTF("UNinstall rompatch_id %d\n", rompatch_id);
2314 ret = BMIrompatchUninstall(hifDevice, rompatch_id);
2315 break;
2316 }
2317
2318 case AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE:
2319 case AR6000_XIOCTL_BMI_ROMPATCH_DEACTIVATE:
2320 {
2321 A_UINT32 rompatch_count;
2322
2323 get_user(rompatch_count, (A_UINT32 *)userdata);
2324 AR_DEBUG_PRINTF("Change rompatch activation count=%d\n", rompatch_count);
2325 length = sizeof(A_UINT32) * rompatch_count;
2326 if ((buffer = (unsigned char *)A_MALLOC(length)) != NULL) {
2327 A_MEMZERO(buffer, length);
2328 if (copy_from_user(buffer, &userdata[sizeof(rompatch_count)], length))
2329 {
2330 ret = -EFAULT;
2331 } else {
2332 if (cmd == AR6000_XIOCTL_BMI_ROMPATCH_ACTIVATE) {
2333 ret = BMIrompatchActivate(hifDevice, rompatch_count, (A_UINT32 *)buffer);
2334 } else {
2335 ret = BMIrompatchDeactivate(hifDevice, rompatch_count, (A_UINT32 *)buffer);
2336 }
2337 }
2338 A_FREE(buffer);
2339 } else {
2340 ret = -ENOMEM;
2341 }
2342
2343 break;
2344 }
2345
2346 case AR6000_XIOCTL_WMI_SET_HOST_SLEEP_MODE:
2347 {
2348 WMI_SET_HOST_SLEEP_MODE_CMD setHostSleepMode;
2349
2350 if (ar->arWmiReady == FALSE) {
2351 ret = -EIO;
2352 } else if (copy_from_user(&setHostSleepMode, userdata,
2353 sizeof(setHostSleepMode)))
2354 {
2355 ret = -EFAULT;
2356 } else {
2357 if (wmi_set_host_sleep_mode_cmd(ar->arWmi,
2358 &setHostSleepMode) != A_OK)
2359 {
2360 ret = -EIO;
2361 }
2362 }
2363 break;
2364 }
2365 case AR6000_XIOCTL_WMI_SET_WOW_MODE:
2366 {
2367 WMI_SET_WOW_MODE_CMD setWowMode;
2368
2369 if (ar->arWmiReady == FALSE) {
2370 ret = -EIO;
2371 } else if (copy_from_user(&setWowMode, userdata,
2372 sizeof(setWowMode)))
2373 {
2374 ret = -EFAULT;
2375 } else {
2376 if (wmi_set_wow_mode_cmd(ar->arWmi,
2377 &setWowMode) != A_OK)
2378 {
2379 ret = -EIO;
2380 }
2381 }
2382 break;
2383 }
2384 case AR6000_XIOCTL_WMI_GET_WOW_LIST:
2385 {
2386 WMI_GET_WOW_LIST_CMD getWowList;
2387
2388 if (ar->arWmiReady == FALSE) {
2389 ret = -EIO;
2390 } else if (copy_from_user(&getWowList, userdata,
2391 sizeof(getWowList)))
2392 {
2393 ret = -EFAULT;
2394 } else {
2395 if (wmi_get_wow_list_cmd(ar->arWmi,
2396 &getWowList) != A_OK)
2397 {
2398 ret = -EIO;
2399 }
2400 }
2401 break;
2402 }
2403 case AR6000_XIOCTL_WMI_ADD_WOW_PATTERN:
2404 {
2405 #define WOW_PATTERN_SIZE 64
2406 #define WOW_MASK_SIZE 64
2407
2408 WMI_ADD_WOW_PATTERN_CMD cmd;
2409 A_UINT8 mask_data[WOW_PATTERN_SIZE]={0};
2410 A_UINT8 pattern_data[WOW_PATTERN_SIZE]={0};
2411
2412 if (ar->arWmiReady == FALSE) {
2413 ret = -EIO;
2414 } else {
2415
2416 if(copy_from_user(&cmd, userdata,
2417 sizeof(WMI_ADD_WOW_PATTERN_CMD)))
2418 return -EFAULT;
2419 if (copy_from_user(pattern_data,
2420 userdata + 3,
2421 cmd.filter_size)){
2422 ret = -EFAULT;
2423 break;
2424 }
2425 if (copy_from_user(mask_data,
2426 (userdata + 3 + cmd.filter_size),
2427 cmd.filter_size)){
2428 ret = -EFAULT;
2429 break;
2430 } else {
2431 if (wmi_add_wow_pattern_cmd(ar->arWmi,
2432 &cmd, pattern_data, mask_data, cmd.filter_size) != A_OK){
2433 ret = -EIO;
2434 }
2435 }
2436 }
2437 #undef WOW_PATTERN_SIZE
2438 #undef WOW_MASK_SIZE
2439 break;
2440 }
2441 case AR6000_XIOCTL_WMI_DEL_WOW_PATTERN:
2442 {
2443 WMI_DEL_WOW_PATTERN_CMD delWowPattern;
2444
2445 if (ar->arWmiReady == FALSE) {
2446 ret = -EIO;
2447 } else if (copy_from_user(&delWowPattern, userdata,
2448 sizeof(delWowPattern)))
2449 {
2450 ret = -EFAULT;
2451 } else {
2452 if (wmi_del_wow_pattern_cmd(ar->arWmi,
2453 &delWowPattern) != A_OK)
2454 {
2455 ret = -EIO;
2456 }
2457 }
2458 break;
2459 }
2460 case AR6000_XIOCTL_DUMP_HTC_CREDIT_STATE:
2461 if (ar->arHtcTarget != NULL) {
2462 HTCDumpCreditStates(ar->arHtcTarget);
2463 }
2464 break;
2465 case AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE:
2466 if (ar->arHtcTarget != NULL) {
2467 struct ar6000_traffic_activity_change data;
2468
2469 if (copy_from_user(&data, userdata, sizeof(data)))
2470 {
2471 return -EFAULT;
2472 }
2473 /* note, this is used for testing (mbox ping testing), indicate activity
2474 * change using the stream ID as the traffic class */
2475 ar6000_indicate_tx_activity(ar,
2476 (A_UINT8)data.StreamID,
2477 data.Active ? TRUE : FALSE);
2478 }
2479 break;
2480 case AR6000_XIOCTL_WMI_SET_CONNECT_CTRL_FLAGS:
2481 if (ar->arWmiReady == FALSE) {
2482 ret = -EIO;
2483 } else if (copy_from_user(&connectCtrlFlags, userdata,
2484 sizeof(connectCtrlFlags)))
2485 {
2486 ret = -EFAULT;
2487 } else {
2488 ar->arConnectCtrlFlags = connectCtrlFlags;
2489 }
2490 break;
2491 case AR6000_XIOCTL_WMI_SET_AKMP_PARAMS:
2492 if (ar->arWmiReady == FALSE) {
2493 ret = -EIO;
2494 } else if (copy_from_user(&akmpParams, userdata,
2495 sizeof(WMI_SET_AKMP_PARAMS_CMD)))
2496 {
2497 ret = -EFAULT;
2498 } else {
2499 if (wmi_set_akmp_params_cmd(ar->arWmi, &akmpParams) != A_OK) {
2500 ret = -EIO;
2501 }
2502 }
2503 break;
2504 case AR6000_XIOCTL_WMI_SET_PMKID_LIST:
2505 if (ar->arWmiReady == FALSE) {
2506 ret = -EIO;
2507 } else {
2508 if (copy_from_user(&pmkidInfo.numPMKID, userdata,
2509 sizeof(pmkidInfo.numPMKID)))
2510 {
2511 ret = -EFAULT;
2512 break;
2513 }
2514 if (copy_from_user(&pmkidInfo.pmkidList,
2515 userdata + sizeof(pmkidInfo.numPMKID),
2516 pmkidInfo.numPMKID * sizeof(WMI_PMKID)))
2517 {
2518 ret = -EFAULT;
2519 break;
2520 }
2521 if (wmi_set_pmkid_list_cmd(ar->arWmi, &pmkidInfo) != A_OK) {
2522 ret = -EIO;
2523 }
2524 }
2525 break;
2526 case AR6000_XIOCTL_WMI_GET_PMKID_LIST:
2527 if (ar->arWmiReady == FALSE) {
2528 ret = -EIO;
2529 } else {
2530 if (wmi_get_pmkid_list_cmd(ar->arWmi) != A_OK) {
2531 ret = -EIO;
2532 }
2533 }
2534 break;
2535 default:
2536 ret = -EOPNOTSUPP;
2537 }
2538 return ret;
2539 }
2540
OpenWrt SVN history