?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fix/oss-header-fix' into for-linus
[linux-2.6/mini2440.git] / drivers / staging / otus / ioctl.c
blob7a5c1e876b01c9e923d695541f1763f712e76ec6
1 /*
2 * Copyright (c) 2007-2008 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16 /* */
17 /* Module Name : ioctl.c */
18 /* */
19 /* Abstract */
20 /* This module contains Linux wireless extension related functons. */
21 /* */
22 /* NOTES */
23 /* Platform dependent. */
24 /* */
25 /************************************************************************/
26 #include <linux/module.h>
27 #include <linux/if_arp.h>
28 #include <asm/uaccess.h>
29
30 #include "usbdrv.h"
31
32 #define ZD_IOCTL_WPA (SIOCDEVPRIVATE + 1)
33 #define ZD_IOCTL_PARAM (SIOCDEVPRIVATE + 2)
34 #define ZD_IOCTL_GETWPAIE (SIOCDEVPRIVATE + 3)
35 #ifdef ZM_ENABLE_CENC
36 #define ZM_IOCTL_CENC (SIOCDEVPRIVATE + 4)
37 #endif //ZM_ENABLE_CENC
38 #define ZD_PARAM_ROAMING 0x0001
39 #define ZD_PARAM_PRIVACY 0x0002
40 #define ZD_PARAM_WPA 0x0003
41 #define ZD_PARAM_COUNTERMEASURES 0x0004
42 #define ZD_PARAM_DROPUNENCRYPTED 0x0005
43 #define ZD_PARAM_AUTH_ALGS 0x0006
44 #define ZD_PARAM_WPS_FILTER 0x0007
45
46 #ifdef ZM_ENABLE_CENC
47 #define P80211_PACKET_CENCFLAG 0x0001
48 #endif //ZM_ENABLE_CENC
49 #define P80211_PACKET_SETKEY 0x0003
50
51 #define ZD_CMD_SET_ENCRYPT_KEY 0x0001
52 #define ZD_CMD_SET_MLME 0x0002
53 #define ZD_CMD_SCAN_REQ 0x0003
54 #define ZD_CMD_SET_GENERIC_ELEMENT 0x0004
55 #define ZD_CMD_GET_TSC 0x0005
56
57 #define ZD_CRYPT_ALG_NAME_LEN 16
58 #define ZD_MAX_KEY_SIZE 32
59 #define ZD_MAX_GENERIC_SIZE 64
60
61 #if WIRELESS_EXT > 12
62 #include <net/iw_handler.h>
63 #endif
64
65 extern u16_t zfLnxGetVapId(zdev_t* dev);
66
67 static const u32_t channel_frequency_11A[] =
68 {
69 //Even element for Channel Number, Odd for Frequency
70 36,5180,
71 40,5200,
72 44,5220,
73 48,5240,
74 52,5260,
75 56,5280,
76 60,5300,
77 64,5320,
78 100,5500,
79 104,5520,
80 108,5540,
81 112,5560,
82 116,5580,
83 120,5600,
84 124,5620,
85 128,5640,
86 132,5660,
87 136,5680,
88 140,5700,
89 //
90 184,4920,
91 188,4940,
92 192,4960,
93 196,4980,
94 8,5040,
95 12,5060,
96 16,5080,
97 34,5170,
98 38,5190,
99 42,5210,
100 46,5230,
101 //
102 149,5745,
103 153,5765,
104 157,5785,
105 161,5805,
106 165,5825
107 //
108 };
109
110 int usbdrv_freq2chan(u32_t freq)
111 {
112 /* 2.4G Hz */
113 if (freq > 2400 && freq < 3000)
114 {
115 return ((freq-2412)/5) + 1;
116 }
117 else
118 {
119 u16_t ii;
120 u16_t num_chan = sizeof(channel_frequency_11A)/sizeof(u32_t);
121
122 for(ii = 1; ii < num_chan; ii += 2)
123 {
124 if (channel_frequency_11A[ii] == freq)
125 return channel_frequency_11A[ii-1];
126 }
127 }
128
129 return 0;
130 }
131
132 int usbdrv_chan2freq(int chan)
133 {
134 int freq;
135
136 /* If channel number is out of range */
137 if (chan > 165 || chan <= 0)
138 return -1;
139
140 /* 2.4G band */
141 if (chan >= 1 && chan <= 13)
142 {
143 freq = (2412 + (chan - 1) * 5);
144 return freq;
145 }
146 else if (chan >= 36 && chan <= 165)
147 {
148 u16_t ii;
149 u16_t num_chan = sizeof(channel_frequency_11A)/sizeof(u32_t);
150
151 for(ii = 0; ii < num_chan; ii += 2)
152 {
153 if (channel_frequency_11A[ii] == chan)
154 return channel_frequency_11A[ii+1];
155 }
156
157 /* Can't find desired frequency */
158 if (ii == num_chan)
159 return -1;
160 }
161
162 /* Can't find deisred frequency */
163 return -1;
164 }
165
166 int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq)
167 {
168 #ifdef ZM_HOSTAPD_SUPPORT
169 //struct usbdrv_private *macp = dev->ml_priv;
170 char essidbuf[IW_ESSID_MAX_SIZE+1];
171 int i;
172
173 if(!netif_running(dev))
174 return -EINVAL;
175
176 memset(essidbuf, 0, sizeof(essidbuf));
177
178 printk(KERN_ERR "usbdrv_ioctl_setessid\n");
179
180 //printk("ssidlen=%d\n", erq->length); //for any, it is 1.
181 if (erq->flags) {
182 if (erq->length > (IW_ESSID_MAX_SIZE+1))
183 return -E2BIG;
184
185 if (copy_from_user(essidbuf, erq->pointer, erq->length))
186 return -EFAULT;
187 }
188
189 //zd_DisasocAll(2);
190 //wait_ms(100);
191
192 printk(KERN_ERR "essidbuf: ");
193
194 for(i = 0; i < erq->length; i++)
195 {
196 printk(KERN_ERR "%02x ", essidbuf[i]);
197 }
198
199 printk(KERN_ERR "\n");
200
201 essidbuf[erq->length] = '\0';
202 //memcpy(macp->wd.ws.ssid, essidbuf, erq->length);
203 //macp->wd.ws.ssidLen = strlen(essidbuf)+2;
204 //macp->wd.ws.ssid[1] = strlen(essidbuf); // Update ssid length
205
206 zfiWlanSetSSID(dev, essidbuf, erq->length);
207 #if 0
208 printk(KERN_ERR "macp->wd.ws.ssid: ");
209
210 for(i = 0; i < macp->wd.ws.ssidLen; i++)
211 {
212 printk(KERN_ERR "%02x ", macp->wd.ws.ssid[i]);
213 }
214
215 printk(KERN_ERR "\n");
216 #endif
217 zfiWlanDisable(dev, 0);
218 zfiWlanEnable(dev);
219
220 #endif
221
222 return 0;
223 }
224
225 int usbdrv_ioctl_getessid(struct net_device *dev, struct iw_point *erq)
226 {
227 //struct usbdrv_private *macp = dev->ml_priv;
228 u8_t essidbuf[IW_ESSID_MAX_SIZE+1];
229 u8_t len;
230 u8_t i;
231
232
233 //len = macp->wd.ws.ssidLen;
234 //memcpy(essidbuf, macp->wd.ws.ssid, macp->wd.ws.ssidLen);
235 zfiWlanQuerySSID(dev, essidbuf, &len);
236
237 essidbuf[len] = 0;
238
239 printk(KERN_ERR "ESSID: ");
240
241 for(i = 0; i < len; i++)
242 {
243 printk(KERN_ERR "%c", essidbuf[i]);
244 }
245
246 printk(KERN_ERR "\n");
247
248 erq->flags= 1;
249 erq->length = strlen(essidbuf) + 1;
250
251 if (erq->pointer)
252 if (copy_to_user(erq->pointer, essidbuf, erq->length))
253 return -EFAULT;
254
255 return 0;
256 }
257
258
259 int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq)
260 {
261
262 return 0;
263 }
264
265 #if WIRELESS_EXT > 14
266 /*
267 * Encode a WPA or RSN information element as a custom
268 * element using the hostap format.
269 */
270 u32 encode_ie(void *buf, u32 bufsize, const u8 *ie, u32 ielen, const u8 *leader, u32 leader_len)
271 {
272 u8 *p;
273 u32 i;
274
275 if (bufsize < leader_len)
276 return 0;
277 p = buf;
278 memcpy(p, leader, leader_len);
279 bufsize -= leader_len;
280 p += leader_len;
281 for (i = 0; i < ielen && bufsize > 2; i++)
282 p += sprintf(p, "%02x", ie[i]);
283 return (i == ielen ? p - (u8 *)buf : 0);
284 }
285 #endif /* WIRELESS_EXT > 14 */
286
287 /*------------------------------------------------------------------*/
288 /*
289 * Translate scan data returned from the card to a card independent
290 * format that the Wireless Tools will understand
291 */
292 char *usbdrv_translate_scan(struct net_device *dev,
293 struct iw_request_info *info, char *current_ev,
294 char *end_buf, struct zsBssInfo *list)
295 {
296 struct iw_event iwe; /* Temporary buffer */
297 u16_t capabilities;
298 char *current_val; /* For rates */
299 char *last_ev;
300 int i;
301 #if WIRELESS_EXT > 14
302 char buf[64*2 + 30];
303 #endif
304
305 last_ev = current_ev;
306
307 /* First entry *MUST* be the AP MAC address */
308 iwe.cmd = SIOCGIWAP;
309 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
310 memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
311 current_ev = iwe_stream_add_event(
312 info,
313 current_ev,
314 end_buf, &iwe, IW_EV_ADDR_LEN);
315
316 /* Ran out of buffer */
317 if (last_ev == current_ev)
318 {
319 return end_buf;
320 }
321
322 last_ev = current_ev;
323
324 /* Other entries will be displayed in the order we give them */
325
326 /* Add the ESSID */
327 iwe.u.data.length = list->ssid[1];
328 if(iwe.u.data.length > 32)
329 iwe.u.data.length = 32;
330 iwe.cmd = SIOCGIWESSID;
331 iwe.u.data.flags = 1;
332 current_ev = iwe_stream_add_point(
333 info,
334 current_ev, end_buf, &iwe, &list->ssid[2]);
335
336 /* Ran out of buffer */
337 if (last_ev == current_ev)
338 {
339 return end_buf;
340 }
341
342 last_ev = current_ev;
343
344 /* Add mode */
345 iwe.cmd = SIOCGIWMODE;
346 capabilities = (list->capability[1] << 8) + list->capability[0];
347 if(capabilities & (0x01 | 0x02))
348 {
349 if(capabilities & 0x01)
350 iwe.u.mode = IW_MODE_MASTER;
351 else
352 iwe.u.mode = IW_MODE_ADHOC;
353 current_ev = iwe_stream_add_event(
354 info,
355 current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
356 }
357
358 /* Ran out of buffer */
359 if (last_ev == current_ev)
360 {
361 return end_buf;
362 }
363
364 last_ev = current_ev;
365
366 /* Add frequency */
367 iwe.cmd = SIOCGIWFREQ;
368 iwe.u.freq.m = list->channel;
369 /* Channel frequency in KHz */
370 if (iwe.u.freq.m > 14)
371 {
372 if ((184 <= iwe.u.freq.m) && (iwe.u.freq.m<=196))
373 iwe.u.freq.m = 4000 + iwe.u.freq.m * 5;
374 else
375 iwe.u.freq.m = 5000 + iwe.u.freq.m * 5;
376 }
377 else
378 {
379 if (iwe.u.freq.m == 14)
380 iwe.u.freq.m = 2484;
381 else
382 iwe.u.freq.m = 2412 + (iwe.u.freq.m - 1) * 5;
383 }
384 iwe.u.freq.e = 6;
385 current_ev = iwe_stream_add_event(
386 info,
387 current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
388
389 /* Ran out of buffer */
390 if (last_ev == current_ev)
391 {
392 return end_buf;
393 }
394
395 last_ev = current_ev;
396
397 /* Add quality statistics */
398 iwe.cmd = IWEVQUAL;
399 #if WIRELESS_EXT > 18
400 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED
401 |IW_QUAL_NOISE_UPDATED;
402 #endif
403 iwe.u.qual.level = list->signalStrength;
404 iwe.u.qual.noise = 0;
405 iwe.u.qual.qual = list->signalQuality;
406 current_ev = iwe_stream_add_event(
407 info,
408 current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
409
410 /* Ran out of buffer */
411 if (last_ev == current_ev)
412 {
413 return end_buf;
414 }
415
416 last_ev = current_ev;
417
418 /* Add encryption capability */
419
420 iwe.cmd = SIOCGIWENCODE;
421 if(capabilities & 0x10)
422 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
423 else
424 iwe.u.data.flags = IW_ENCODE_DISABLED;
425
426 iwe.u.data.length = 0;
427 current_ev = iwe_stream_add_point(
428 info,
429 current_ev, end_buf, &iwe, list->ssid);
430
431 /* Ran out of buffer */
432 if (last_ev == current_ev)
433 {
434 return end_buf;
435 }
436
437 last_ev = current_ev;
438
439 /* Rate : stuffing multiple values in a single event require a bit
440 * more of magic */
441 current_val = current_ev + IW_EV_LCP_LEN;
442
443 iwe.cmd = SIOCGIWRATE;
444 /* Those two flags are ignored... */
445 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
446
447 for(i = 0 ; i < list->supportedRates[1] ; i++)
448 {
449 /* Bit rate given in 500 kb/s units (+ 0x80) */
450 iwe.u.bitrate.value = ((list->supportedRates[i+2] & 0x7f) * 500000);
451 /* Add new value to event */
452 current_val = iwe_stream_add_value(
453 info,
454 current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
455
456 /* Ran out of buffer */
457 if (last_ev == current_val)
458 {
459 return end_buf;
460 }
461
462 last_ev = current_val;
463 }
464
465 for (i = 0 ; i < list->extSupportedRates[1] ; i++)
466 {
467 /* Bit rate given in 500 kb/s units (+ 0x80) */
468 iwe.u.bitrate.value = ((list->extSupportedRates[i+2] & 0x7f) * 500000);
469 /* Add new value to event */
470 current_val = iwe_stream_add_value(
471 info,
472 current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
473
474 /* Ran out of buffer */
475 if (last_ev == current_val)
476 {
477 return end_buf;
478 }
479
480 last_ev = current_ev;
481 }
482
483 /* Check if we added any event */
484 if((current_val - current_ev) > IW_EV_LCP_LEN)
485 current_ev = current_val;
486 #if WIRELESS_EXT > 14
487 #define IEEE80211_ELEMID_RSN 0x30
488 memset(&iwe, 0, sizeof(iwe));
489 iwe.cmd = IWEVCUSTOM;
490 snprintf(buf, sizeof(buf), "bcn_int=%d", (list->beaconInterval[1] << 8) + list->beaconInterval[0]);
491 iwe.u.data.length = strlen(buf);
492 current_ev = iwe_stream_add_point(
493 info,
494 current_ev, end_buf, &iwe, buf);
495
496 /* Ran out of buffer */
497 if (last_ev == current_ev)
498 {
499 return end_buf;
500 }
501
502 last_ev = current_ev;
503
504 if (list->wpaIe[1] != 0)
505 {
506 static const char rsn_leader[] = "rsn_ie=";
507 static const char wpa_leader[] = "wpa_ie=";
508
509 memset(&iwe, 0, sizeof(iwe));
510 iwe.cmd = IWEVCUSTOM;
511 if (list->wpaIe[0] == IEEE80211_ELEMID_RSN)
512 iwe.u.data.length = encode_ie(buf, sizeof(buf),
513 list->wpaIe, list->wpaIe[1]+2,
514 rsn_leader, sizeof(rsn_leader)-1);
515 else
516 iwe.u.data.length = encode_ie(buf, sizeof(buf),
517 list->wpaIe, list->wpaIe[1]+2,
518 wpa_leader, sizeof(wpa_leader)-1);
519
520 if (iwe.u.data.length != 0)
521 current_ev = iwe_stream_add_point(
522 info,
523 current_ev, end_buf, &iwe, buf);
524
525 /* Ran out of buffer */
526 if (last_ev == current_ev)
527 {
528 return end_buf;
529 }
530
531 last_ev = current_ev;
532 }
533 if (list->rsnIe[1] != 0)
534 {
535 static const char rsn_leader[] = "rsn_ie=";
536 memset(&iwe, 0, sizeof(iwe));
537 iwe.cmd = IWEVCUSTOM;
538
539 if (list->rsnIe[0] == IEEE80211_ELEMID_RSN)
540 {
541 iwe.u.data.length = encode_ie(buf, sizeof(buf),
542 list->rsnIe, list->rsnIe[1]+2,
543 rsn_leader, sizeof(rsn_leader)-1);
544 if (iwe.u.data.length != 0)
545 current_ev = iwe_stream_add_point(
546 info,
547 current_ev, end_buf, &iwe, buf);
548
549 /* Ran out of buffer */
550 if (last_ev == current_ev)
551 {
552 return end_buf;
553 }
554
555 last_ev = current_ev;
556 }
557 }
558 #endif
559 /* The other data in the scan result are not really
560 * interesting, so for now drop it */
561 return current_ev;
562 }
563
564 int usbdrvwext_giwname(struct net_device *dev,
565 struct iw_request_info *info,
566 union iwreq_data *wrq, char *extra)
567 {
568 //struct usbdrv_private *macp = dev->ml_priv;
569
570 strcpy(wrq->name, "IEEE 802.11-MIMO");
571
572 return 0;
573 }
574
575 int usbdrvwext_siwfreq(struct net_device *dev,
576 struct iw_request_info *info,
577 struct iw_freq *freq, char *extra)
578 {
579 u32_t FreqKHz;
580 struct usbdrv_private *macp = dev->ml_priv;
581
582 if(!netif_running(dev))
583 return -EINVAL;
584
585 if (freq->e > 1)
586 return -EINVAL;
587
588 if (freq->e == 1)
589 {
590 FreqKHz = (freq->m / 100000);
591
592 if (FreqKHz > 4000000)
593 {
594 if (FreqKHz > 5825000)
595 FreqKHz = 5825000;
596 else if (FreqKHz < 4920000)
597 FreqKHz = 4920000;
598 else if (FreqKHz < 5000000)
599 FreqKHz = (((FreqKHz - 4000000) / 5000) * 5000) + 4000000;
600 else
601 FreqKHz = (((FreqKHz - 5000000) / 5000) * 5000) + 5000000;
602 }
603 else
604 {
605 if (FreqKHz > 2484000)
606 FreqKHz = 2484000;
607 else if (FreqKHz < 2412000)
608 FreqKHz = 2412000;
609 else
610 FreqKHz = (((FreqKHz - 2412000) / 5000) * 5000) + 2412000;
611 }
612
613 }
614 else
615 {
616 FreqKHz = usbdrv_chan2freq(freq->m);
617
618 if (FreqKHz != -1)
619 FreqKHz *= 1000;
620 else
621 FreqKHz = 2412000;
622 }
623
624 //printk("freq->m: %d, freq->e: %d\n", freq->m, freq->e);
625 //printk("FreqKHz: %d\n", FreqKHz);
626
627 if (macp->DeviceOpened == 1)
628 {
629 zfiWlanSetFrequency(dev, FreqKHz, 0); // Immediate
630 //u8_t wpaieLen,wpaie[50];
631 //zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen);
632 zfiWlanDisable(dev, 0);
633 zfiWlanEnable(dev);
634 //if (wpaieLen > 2)
635 // zfiWlanSetWpaIe(dev, wpaie, wpaieLen);
636 }
637
638 return 0;
639 }
640
641 int usbdrvwext_giwfreq(struct net_device *dev,
642 struct iw_request_info *info,
643 struct iw_freq *freq, char *extra)
644 {
645 struct usbdrv_private *macp = dev->ml_priv;
646
647 if (macp->DeviceOpened != 1)
648 return 0;
649
650 freq->m = zfiWlanQueryFrequency(dev);
651 freq->e = 3;
652
653 return 0;
654 }
655
656 int usbdrvwext_siwmode(struct net_device *dev,
657 struct iw_request_info *info,
658 union iwreq_data *wrq, char *extra)
659 {
660 struct usbdrv_private *macp = dev->ml_priv;
661 u8_t WlanMode;
662
663 if(!netif_running(dev))
664 return -EINVAL;
665
666 if (macp->DeviceOpened != 1)
667 return 0;
668
669 switch(wrq->mode)
670 {
671 case IW_MODE_MASTER:
672 WlanMode = ZM_MODE_AP;
673 break;
674 case IW_MODE_INFRA:
675 WlanMode = ZM_MODE_INFRASTRUCTURE;
676 break;
677 case IW_MODE_ADHOC:
678 WlanMode = ZM_MODE_IBSS;
679 break;
680 default:
681 WlanMode = ZM_MODE_IBSS;
682 break;
683 }
684
685 zfiWlanSetWlanMode(dev,WlanMode);
686 zfiWlanDisable(dev, 1);
687 zfiWlanEnable(dev);
688
689 return 0;
690 }
691
692 int usbdrvwext_giwmode(struct net_device *dev,
693 struct iw_request_info *info,
694 __u32 *mode, char *extra)
695 {
696 unsigned long irqFlag;
697 struct usbdrv_private *macp = dev->ml_priv;
698
699 if(!netif_running(dev))
700 return -EINVAL;
701
702 if (macp->DeviceOpened != 1)
703 return 0;
704
705 spin_lock_irqsave(&macp->cs_lock, irqFlag);
706
707 switch(zfiWlanQueryWlanMode(dev))
708 {
709 case ZM_MODE_AP:
710 *mode = IW_MODE_MASTER;
711 break;
712 case ZM_MODE_INFRASTRUCTURE:
713 *mode = IW_MODE_INFRA;
714 break;
715 case ZM_MODE_IBSS:
716 *mode = IW_MODE_ADHOC;
717 break;
718 default:
719 *mode = IW_MODE_ADHOC;
720 break;
721 }
722
723 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
724
725 return 0;
726 }
727
728 int usbdrvwext_siwsens(struct net_device *dev,
729 struct iw_request_info *info,
730 struct iw_param *sens, char *extra)
731 {
732 return 0;
733 }
734
735 int usbdrvwext_giwsens(struct net_device *dev,
736 struct iw_request_info *info,
737 struct iw_param *sens, char *extra)
738 {
739 sens->value = 0;
740 sens->fixed = 1;
741
742 return 0;
743 }
744
745 int usbdrvwext_giwrange(struct net_device *dev,
746 struct iw_request_info *info,
747 struct iw_point *data, char *extra)
748 {
749 struct iw_range *range = (struct iw_range *) extra;
750 int i, val;
751 //int num_band_a;
752 u16_t channels[60];
753 u16_t channel_num;
754
755 if(!netif_running(dev))
756 return -EINVAL;
757
758 #if WIRELESS_EXT > 9
759 range->txpower_capa = IW_TXPOW_DBM;
760 // XXX what about min/max_pmp, min/max_pmt, etc.
761 #endif
762
763 #if WIRELESS_EXT > 10
764 range->we_version_compiled = WIRELESS_EXT;
765 range->we_version_source = 13;
766
767 range->retry_capa = IW_RETRY_LIMIT;
768 range->retry_flags = IW_RETRY_LIMIT;
769 range->min_retry = 0;
770 range->max_retry = 255;
771 #endif /* WIRELESS_EXT > 10 */
772
773 channel_num = zfiWlanQueryAllowChannels(dev, channels);
774
775 /* Gurantee reported channel numbers is less or equal to IW_MAX_FREQUENCIES */
776 if (channel_num > IW_MAX_FREQUENCIES)
777 channel_num = IW_MAX_FREQUENCIES;
778
779 val = 0;
780
781 for (i = 0; i < channel_num; i++)
782 {
783 range->freq[val].i = usbdrv_freq2chan(channels[i]);
784 range->freq[val].m = channels[i];
785 range->freq[val].e = 6;
786 val++;
787 }
788
789 range->num_channels = channel_num;
790 range->num_frequency = channel_num;
791
792 #if 0
793 range->num_channels = 14; // Only 2.4G
794
795 /* XXX need to filter against the regulatory domain &| active set */
796 val = 0;
797 for (i = 1; i <= 14; i++) // B,G Bands
798 {
799 range->freq[val].i = i;
800 if (i == 14)
801 range->freq[val].m = 2484000;
802 else
803 range->freq[val].m = (2412+(i-1)*5)*1000;
804 range->freq[val].e = 3;
805 val++;
806 }
807
808 num_band_a = (IW_MAX_FREQUENCIES - val);
809
810 for (i = 0; i < num_band_a; i++) // A Bands
811 {
812 range->freq[val].i = channel_frequency_11A[2 * i];
813 range->freq[val].m = channel_frequency_11A[2 * i + 1] * 1000;
814 range->freq[val].e = 3;
815 val++;
816 }
817 // MIMO Rate Not Defined Now
818 //For 802.11a, there are too more frequency. We can't return them all
819 range->num_frequency = val;
820 #endif
821
822 /* Max of /proc/net/wireless */
823 range->max_qual.qual = 100; //?? //92;
824 range->max_qual.level = 154; //??
825 range->max_qual.noise = 154; //??
826 range->sensitivity = 3; //??
827
828 // XXX these need to be nsd-specific!
829 range->min_rts = 0;
830 range->max_rts = 2347;
831 range->min_frag = 256;
832 range->max_frag = 2346;
833 range->max_encoding_tokens = 4/*NUM_WEPKEYS*/; //??
834 range->num_encoding_sizes = 2; //??
835
836 range->encoding_size[0] = 5; //?? //WEP Key Encoding Size
837 range->encoding_size[1] = 13;//??
838
839 // XXX what about num_bitrates/throughput?
840 range->num_bitrates = 0; //??
841
842 /* estimated max throughput */
843 // XXX need to cap it if we're running at ~2Mbps..
844
845 range->throughput = 300000000;
846
847 return 0;
848 }
849
850 int usbdrvwext_siwap(struct net_device *dev, struct iw_request_info *info,
851 struct sockaddr *MacAddr, char *extra)
852 {
853 struct usbdrv_private *macp = dev->ml_priv;
854
855 if(!netif_running(dev))
856 return -EINVAL;
857
858 if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) // AP Mode
859 zfiWlanSetMacAddress(dev,(u16_t *)&MacAddr->sa_data[0]);
860 else //STA Mode
861 zfiWlanSetBssid(dev,&MacAddr->sa_data[0]);
862
863 if (macp->DeviceOpened == 1)
864 {
865 //u8_t wpaieLen,wpaie[80];
866 //zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen);
867 zfiWlanDisable(dev, 0);
868 zfiWlanEnable(dev);
869 //if (wpaieLen > 2)
870 // zfiWlanSetWpaIe(dev, wpaie, wpaieLen);
871 }
872
873 return 0;
874 }
875
876 int usbdrvwext_giwap(struct net_device *dev,
877 struct iw_request_info *info,
878 struct sockaddr *MacAddr, char *extra)
879 {
880 struct usbdrv_private *macp = dev->ml_priv;
881
882 if (macp->DeviceOpened != 1)
883 return 0;
884
885 if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) // AP Mode
886 zfiWlanQueryMacAddress(dev, &MacAddr->sa_data[0]);
887 else //STA Mode
888 {
889 if (macp->adapterState == ZM_STATUS_MEDIA_CONNECT)
890 {
891 zfiWlanQueryBssid(dev, &MacAddr->sa_data[0]);
892 }
893 else
894 {
895 u8_t zero_addr[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
896 memcpy(&MacAddr->sa_data[0], zero_addr, sizeof(zero_addr));
897 }
898 }
899
900 return 0;
901 }
902
903 int usbdrvwext_iwaplist(struct net_device *dev,
904 struct iw_request_info *info,
905 struct iw_point *data, char *extra)
906 {
907 //Don't know how to do yet--CWYang(+)
908 return 0;
909
910 }
911
912 int usbdrvwext_siwscan(struct net_device *dev, struct iw_request_info *info,
913 struct iw_point *data, char *extra)
914 {
915 struct usbdrv_private *macp = dev->ml_priv;
916
917 if (macp->DeviceOpened != 1)
918 return 0;
919
920 printk("CWY - usbdrvwext_siwscan\n");
921
922 zfiWlanScan(dev);
923
924 return 0;
925 }
926
927 int usbdrvwext_giwscan(struct net_device *dev,
928 struct iw_request_info *info,
929 struct iw_point *data, char *extra)
930 {
931 struct usbdrv_private *macp = dev->ml_priv;
932 //struct zsWlanDev* wd = (struct zsWlanDev*) zmw_wlan_dev(dev);
933 char *current_ev = extra;
934 char *end_buf;
935 int i;
936 //struct zsBssList BssList;
937 struct zsBssListV1 *pBssList = kmalloc(sizeof(struct zsBssListV1), GFP_KERNEL);
938 //BssList = wd->sta.pBssList;
939 //zmw_get_wlan_dev(dev);
940
941 if (macp->DeviceOpened != 1)
942 return 0;
943
944 if (data->length == 0)
945 {
946 end_buf = extra + IW_SCAN_MAX_DATA;
947 }
948 else
949 {
950 end_buf = extra + data->length;
951 }
952
953 printk("giwscan - Report Scan Results\n");
954 //printk("giwscan - BssList Sreucture Len : %d\n", sizeof(BssList));
955 //printk("giwscan - BssList Count : %d\n", wd->sta.pBssList->bssCount);
956 //printk("giwscan - UpdateBssList Count : %d\n", wd->sta.pUpdateBssList->bssCount);
957 zfiWlanQueryBssListV1(dev, pBssList);
958 //zfiWlanQueryBssList(dev, &BssList);
959
960 /* Read and parse all entries */
961 printk("giwscan - pBssList->bssCount : %d\n", pBssList->bssCount);
962 //printk("giwscan - BssList.bssCount : %d\n", BssList.bssCount);
963
964 for (i = 0; i < pBssList->bssCount; i++)
965 {
966 /* Translate to WE format this entry */
967 //current_ev = usbdrv_translate_scan(dev, info, current_ev,
968 // extra + IW_SCAN_MAX_DATA, &pBssList->bssInfo[i]);
969 current_ev = usbdrv_translate_scan(dev, info, current_ev,
970 end_buf, &pBssList->bssInfo[i]);
971
972 #if WIRELESS_EXT > 16
973 if (current_ev == end_buf)
974 {
975 kfree(pBssList);
976 data->length = current_ev - extra;
977 return -E2BIG;
978 }
979 #endif
980 }
981
982 /* Length of data */
983 data->length = (current_ev - extra);
984 data->flags = 0; /* todo */
985
986 kfree(pBssList);
987
988 return 0;
989 }
990
991 int usbdrvwext_siwessid(struct net_device *dev,
992 struct iw_request_info *info,
993 struct iw_point *essid, char *extra)
994 {
995 char EssidBuf[IW_ESSID_MAX_SIZE+1];
996 struct usbdrv_private *macp = dev->ml_priv;
997
998 if(!netif_running(dev))
999 return -EINVAL;
1000
1001 if (essid->flags == 1)
1002 {
1003 if (essid->length > (IW_ESSID_MAX_SIZE+1))
1004 return -E2BIG;
1005
1006 if (copy_from_user(&EssidBuf, essid->pointer, essid->length))
1007 return -EFAULT;
1008
1009 EssidBuf[essid->length] = '\0';
1010 //printk("siwessid - Set Essid : %s\n",EssidBuf);
1011 //printk("siwessid - Essid Len : %d\n",essid->length);
1012 //printk("siwessid - Essid Flag : %x\n",essid->flags);
1013 if (macp->DeviceOpened == 1)
1014 {
1015 zfiWlanSetSSID(dev, EssidBuf, strlen(EssidBuf));
1016 zfiWlanSetFrequency(dev, zfiWlanQueryFrequency(dev), FALSE);
1017 zfiWlanSetEncryMode(dev, zfiWlanQueryEncryMode(dev));
1018 //u8_t wpaieLen,wpaie[50];
1019 //zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen);
1020 zfiWlanDisable(dev, 0);
1021 zfiWlanEnable(dev);
1022 //if (wpaieLen > 2)
1023 // zfiWlanSetWpaIe(dev, wpaie, wpaieLen);
1024 }
1025 }
1026
1027 return 0;
1028 }
1029
1030 int usbdrvwext_giwessid(struct net_device *dev,
1031 struct iw_request_info *info,
1032 struct iw_point *essid, char *extra)
1033 {
1034 struct usbdrv_private *macp = dev->ml_priv;
1035 u8_t EssidLen;
1036 char EssidBuf[IW_ESSID_MAX_SIZE+1];
1037 int ssid_len;
1038
1039 if(!netif_running(dev))
1040 return -EINVAL;
1041
1042 if (macp->DeviceOpened != 1)
1043 return 0;
1044
1045 zfiWlanQuerySSID(dev, &EssidBuf[0], &EssidLen);
1046
1047 /* Convert type from unsigned char to char */
1048 ssid_len = (int)EssidLen;
1049
1050 /* Make sure the essid length is not greater than IW_ESSID_MAX_SIZE */
1051 if (ssid_len > IW_ESSID_MAX_SIZE)
1052 ssid_len = IW_ESSID_MAX_SIZE;
1053
1054 EssidBuf[ssid_len] = '\0';
1055
1056 essid->flags = 1;
1057 essid->length = strlen(EssidBuf);
1058
1059 memcpy(extra, EssidBuf, essid->length);
1060 // wireless.c in Kernel would handle copy_to_user -- line 679
1061 /*if (essid->pointer)
1062 {
1063 if ( copy_to_user(essid->pointer, EssidBuf, essid->length) )
1064 {
1065 printk("giwessid - copy_to_user Fail\n");
1066 return -EFAULT;
1067 }
1068 }*/
1069
1070 return 0;
1071 }
1072
1073 int usbdrvwext_siwnickn(struct net_device *dev,
1074 struct iw_request_info *info,
1075 struct iw_point *data, char *nickname)
1076 {
1077 //Exist but junk--CWYang(+)
1078 return 0;
1079 }
1080
1081 int usbdrvwext_giwnickn(struct net_device *dev,
1082 struct iw_request_info *info,
1083 struct iw_point *data, char *nickname)
1084 {
1085 struct usbdrv_private *macp = dev->ml_priv;
1086 u8_t EssidLen;
1087 char EssidBuf[IW_ESSID_MAX_SIZE+1];
1088
1089 if (macp->DeviceOpened != 1)
1090 return 0;
1091
1092 zfiWlanQuerySSID(dev, &EssidBuf[0], &EssidLen);
1093 EssidBuf[EssidLen] = 0;
1094
1095 data->flags = 1;
1096 data->length = strlen(EssidBuf);
1097
1098 memcpy(nickname, EssidBuf, data->length);
1099
1100 return 0;
1101 }
1102
1103 int usbdrvwext_siwrate(struct net_device *dev,
1104 struct iw_request_info *info,
1105 struct iw_param *frq, char *extra)
1106 {
1107 struct usbdrv_private *macp = dev->ml_priv;
1108 //Array to Define Rate Number that Send to Driver
1109 u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0, 48000,
1110 24000, 12000, 6000, 54000, 36000, 18000, 9000};
1111 u16_t zcRateToMCS[] = {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd,
1112 0x8, 0xc};
1113 u8_t i,RateIndex = 4;
1114 u16_t RateKbps;
1115
1116 //printk("frq->disabled : 0x%x\n",frq->disabled);
1117 //printk("frq->value : 0x%x\n",frq->value);
1118
1119 RateKbps = frq->value / 1000;
1120 //printk("RateKbps : %d\n", RateKbps);
1121 for (i = 0; i < 16; i++)
1122 {
1123 if (RateKbps == zcIndextoRateBG[i])
1124 RateIndex = i;
1125 }
1126 if (zcIndextoRateBG[RateIndex] == 0)
1127 RateIndex = 0xff;
1128 //printk("RateIndex : %x\n", RateIndex);
1129 for (i = 0; i < 13; i++)
1130 if (RateIndex == zcRateToMCS[i])
1131 break;
1132 //printk("Index : %x\n", i);
1133 if (RateKbps == 65000)
1134 {
1135 RateIndex = 20;
1136 printk("RateIndex : %d\n", RateIndex);
1137 }
1138 if (macp->DeviceOpened == 1)
1139 {
1140 zfiWlanSetTxRate(dev, i);
1141 //zfiWlanDisable(dev);
1142 //zfiWlanEnable(dev);
1143 }
1144
1145 return 0;
1146 }
1147
1148 int usbdrvwext_giwrate(struct net_device *dev,
1149 struct iw_request_info *info,
1150 struct iw_param *frq, char *extra)
1151 {
1152 struct usbdrv_private *macp = dev->ml_priv;
1153
1154 if(!netif_running(dev))
1155 return -EINVAL;
1156
1157 if (macp->DeviceOpened != 1)
1158 return 0;
1159
1160 frq->fixed = 0;
1161 frq->disabled = 0;
1162 frq->value = zfiWlanQueryRxRate(dev) * 1000;
1163
1164 return 0;
1165 }
1166
1167 int usbdrvwext_siwrts(struct net_device *dev,
1168 struct iw_request_info *info,
1169 struct iw_param *rts, char *extra)
1170 {
1171 struct usbdrv_private *macp = dev->ml_priv;
1172 int val = rts->value;
1173
1174 if (macp->DeviceOpened != 1)
1175 return 0;
1176
1177 if (rts->disabled)
1178 val = 2347;
1179
1180 if ((val < 0) || (val > 2347))
1181 return -EINVAL;
1182
1183 zfiWlanSetRtsThreshold(dev,val);
1184
1185 return 0;
1186 }
1187
1188 int usbdrvwext_giwrts(struct net_device *dev,
1189 struct iw_request_info *info,
1190 struct iw_param *rts, char *extra)
1191 {
1192 struct usbdrv_private *macp = dev->ml_priv;
1193
1194 if(!netif_running(dev))
1195 return -EINVAL;
1196
1197 if (macp->DeviceOpened != 1)
1198 return 0;
1199
1200 rts->value = zfiWlanQueryRtsThreshold(dev);
1201 rts->disabled = (rts->value >= 2347);
1202 rts->fixed = 1;
1203
1204 return 0;
1205
1206 }
1207
1208 int usbdrvwext_siwfrag(struct net_device *dev,
1209 struct iw_request_info *info,
1210 struct iw_param *frag, char *extra)
1211 {
1212 struct usbdrv_private *macp = dev->ml_priv;
1213 u16_t fragThreshold;
1214
1215 if (macp->DeviceOpened != 1)
1216 return 0;
1217
1218 if (frag->disabled)
1219 fragThreshold = 0;
1220 else
1221 fragThreshold = frag->value;
1222
1223 zfiWlanSetFragThreshold(dev,fragThreshold);
1224
1225 return 0;
1226 }
1227
1228 int usbdrvwext_giwfrag(struct net_device *dev,
1229 struct iw_request_info *info,
1230 struct iw_param *frag, char *extra)
1231 {
1232 struct usbdrv_private *macp = dev->ml_priv;
1233 u16 val;
1234 unsigned long irqFlag;
1235
1236 if(!netif_running(dev))
1237 return -EINVAL;
1238
1239 if (macp->DeviceOpened != 1)
1240 return 0;
1241
1242 spin_lock_irqsave(&macp->cs_lock, irqFlag);
1243
1244 val = zfiWlanQueryFragThreshold(dev);
1245
1246 frag->value = val;
1247
1248 frag->disabled = (val >= 2346);
1249 frag->fixed = 1;
1250
1251 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
1252
1253 return 0;
1254 }
1255
1256 int usbdrvwext_siwtxpow(struct net_device *dev,
1257 struct iw_request_info *info,
1258 struct iw_param *rrq, char *extra)
1259 {
1260 //Not support yet--CWYng(+)
1261 return 0;
1262 }
1263
1264 int usbdrvwext_giwtxpow(struct net_device *dev,
1265 struct iw_request_info *info,
1266 struct iw_param *rrq, char *extra)
1267 {
1268 //Not support yet--CWYng(+)
1269 return 0;
1270 }
1271
1272 int usbdrvwext_siwretry(struct net_device *dev,
1273 struct iw_request_info *info,
1274 struct iw_param *rrq, char *extra)
1275 {
1276 //Do nothing--CWYang(+)
1277 return 0;
1278 }
1279
1280 int usbdrvwext_giwretry(struct net_device *dev,
1281 struct iw_request_info *info,
1282 struct iw_param *rrq, char *extra)
1283 {
1284 //Do nothing--CWYang(+)
1285 return 0;
1286 }
1287
1288 int usbdrvwext_siwencode(struct net_device *dev,
1289 struct iw_request_info *info,
1290 struct iw_point *erq, char *key)
1291 {
1292 struct zsKeyInfo keyInfo;
1293 int i, WepState = ZM_ENCRYPTION_WEP_DISABLED;
1294 struct usbdrv_private *macp = dev->ml_priv;
1295
1296 if(!netif_running(dev))
1297 return -EINVAL;
1298
1299 if ((erq->flags & IW_ENCODE_DISABLED) == 0)
1300 {
1301 keyInfo.key = key;
1302 keyInfo.keyLength = erq->length;
1303 keyInfo.keyIndex = (erq->flags & IW_ENCODE_INDEX) - 1;
1304 if (keyInfo.keyIndex >= 4)
1305 keyInfo.keyIndex = 0;
1306 keyInfo.flag = ZM_KEY_FLAG_DEFAULT_KEY;
1307
1308 zfiWlanSetKey(dev, keyInfo);
1309 WepState = ZM_ENCRYPTION_WEP_ENABLED;
1310 }
1311 else
1312 {
1313 for (i = 1; i < 4; i++)
1314 zfiWlanRemoveKey(dev, 0, i);
1315 WepState = ZM_ENCRYPTION_WEP_DISABLED;
1316 //zfiWlanSetEncryMode(dev, ZM_NO_WEP);
1317 }
1318
1319 if (macp->DeviceOpened == 1)
1320 {
1321 zfiWlanSetWepStatus(dev, WepState);
1322 zfiWlanSetFrequency(dev, zfiWlanQueryFrequency(dev), FALSE);
1323 //zfiWlanSetEncryMode(dev, zfiWlanQueryEncryMode(dev));
1324 //u8_t wpaieLen,wpaie[50];
1325 //zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen);
1326 zfiWlanDisable(dev, 0);
1327 zfiWlanEnable(dev);
1328 //if (wpaieLen > 2)
1329 // zfiWlanSetWpaIe(dev, wpaie, wpaieLen);
1330 }
1331
1332 return 0;
1333 }
1334
1335 int usbdrvwext_giwencode(struct net_device *dev,
1336 struct iw_request_info *info,
1337 struct iw_point *erq, char *key)
1338 {
1339 struct usbdrv_private *macp = dev->ml_priv;
1340 u8_t EncryptionMode;
1341 u8_t keyLen = 0;
1342
1343 if (macp->DeviceOpened != 1)
1344 return 0;
1345
1346 EncryptionMode = zfiWlanQueryEncryMode(dev);
1347
1348 if (EncryptionMode)
1349 {
1350 erq->flags = IW_ENCODE_ENABLED;
1351 }
1352 else
1353 {
1354 erq->flags = IW_ENCODE_DISABLED;
1355 }
1356
1357 /* We can't return the key, so set the proper flag and return zero */
1358 erq->flags |= IW_ENCODE_NOKEY;
1359 memset(key, 0, 16);
1360
1361 /* Copy the key to the user buffer */
1362 switch(EncryptionMode)
1363 {
1364 case ZM_WEP64:
1365 keyLen = 5;
1366 break;
1367 case ZM_WEP128:
1368 keyLen = 13;
1369 break;
1370 case ZM_WEP256:
1371 keyLen = 29;
1372 break;
1373 case ZM_AES:
1374 keyLen = 16;
1375 break;
1376 case ZM_TKIP:
1377 keyLen = 32;
1378 break;
1379 #ifdef ZM_ENABLE_CENC
1380 case ZM_CENC:
1381 keyLen = 32;
1382 break;
1383 #endif //ZM_ENABLE_CENC
1384 case ZM_NO_WEP:
1385 keyLen = 0;
1386 break;
1387 default :
1388 keyLen = 0;
1389 printk("Unknown EncryMode\n");
1390 break;
1391
1392 }
1393 erq->length = keyLen;
1394
1395 return 0;
1396 }
1397
1398 int usbdrvwext_siwpower(struct net_device *dev,
1399 struct iw_request_info *info,
1400 struct iw_param *frq, char *extra)
1401 {
1402 struct usbdrv_private *macp = dev->ml_priv;
1403 u8_t PSMode;
1404
1405 if (macp->DeviceOpened != 1)
1406 return 0;
1407
1408 if (frq->disabled)
1409 PSMode = ZM_STA_PS_NONE;
1410 else
1411 PSMode = ZM_STA_PS_MAX;
1412
1413 zfiWlanSetPowerSaveMode(dev,PSMode);
1414
1415 return 0;
1416 }
1417
1418 int usbdrvwext_giwpower(struct net_device *dev,
1419 struct iw_request_info *info,
1420 struct iw_param *frq, char *extra)
1421 {
1422 unsigned long irqFlag;
1423 struct usbdrv_private *macp = dev->ml_priv;
1424
1425 if (macp->DeviceOpened != 1)
1426 return 0;
1427
1428 spin_lock_irqsave(&macp->cs_lock, irqFlag);
1429
1430 if (zfiWlanQueryPowerSaveMode(dev) == ZM_STA_PS_NONE)
1431 frq->disabled = 1;
1432 else
1433 frq->disabled = 0;
1434
1435 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
1436
1437 return 0;
1438 }
1439
1440 //int usbdrvwext_setparam(struct net_device *dev, struct iw_request_info *info,
1441 // void *w, char *extra)
1442 //{
1443 // struct ieee80211vap *vap = dev->ml_priv;
1444 // struct ieee80211com *ic = vap->iv_ic;
1445 // struct ieee80211_rsnparms *rsn = &vap->iv_bss->ni_rsn;
1446 // int *i = (int *) extra;
1447 // int param = i[0]; /* parameter id is 1st */
1448 // int value = i[1]; /* NB: most values are TYPE_INT */
1449 // int retv = 0;
1450 // int j, caps;
1451 // const struct ieee80211_authenticator *auth;
1452 // const struct ieee80211_aclator *acl;
1453 //
1454 // switch (param) {
1455 // case IEEE80211_PARAM_AUTHMODE:
1456 // switch (value) {
1457 // case IEEE80211_AUTH_WPA: /* WPA */
1458 // case IEEE80211_AUTH_8021X: /* 802.1x */
1459 // case IEEE80211_AUTH_OPEN: /* open */
1460 // case IEEE80211_AUTH_SHARED: /* shared-key */
1461 // case IEEE80211_AUTH_AUTO: /* auto */
1462 // auth = ieee80211_authenticator_get(value);
1463 // if (auth == NULL)
1464 // return -EINVAL;
1465 // break;
1466 // default:
1467 // return -EINVAL;
1468 // }
1469 // switch (value) {
1470 // case IEEE80211_AUTH_WPA: /* WPA w/ 802.1x */
1471 // vap->iv_flags |= IEEE80211_F_PRIVACY;
1472 // value = IEEE80211_AUTH_8021X;
1473 // break;
1474 // case IEEE80211_AUTH_OPEN: /* open */
1475 // vap->iv_flags &= ~(IEEE80211_F_WPA|IEEE80211_F_PRIVACY);
1476 // break;
1477 // case IEEE80211_AUTH_SHARED: /* shared-key */
1478 // case IEEE80211_AUTH_AUTO: /* auto */
1479 // case IEEE80211_AUTH_8021X: /* 802.1x */
1480 // vap->iv_flags &= ~IEEE80211_F_WPA;
1481 // /* both require a key so mark the PRIVACY capability */
1482 // vap->iv_flags |= IEEE80211_F_PRIVACY;
1483 // break;
1484 // }
1485 // /* NB: authenticator attach/detach happens on state change */
1486 // vap->iv_bss->ni_authmode = value;
1487 // /* XXX mixed/mode/usage? */
1488 // vap->iv_auth = auth;
1489 // retv = ENETRESET;
1490 // break;
1491 // case IEEE80211_PARAM_PROTMODE:
1492 // if (value > IEEE80211_PROT_RTSCTS)
1493 // return -EINVAL;
1494 // ic->ic_protmode = value;
1495 // /* NB: if not operating in 11g this can wait */
1496 // if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
1497 // IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan))
1498 // retv = ENETRESET;
1499 // break;
1500 // case IEEE80211_PARAM_MCASTCIPHER:
1501 // if ((vap->iv_caps & cipher2cap(value)) == 0 &&
1502 // !ieee80211_crypto_available(value))
1503 // return -EINVAL;
1504 // rsn->rsn_mcastcipher = value;
1505 // if (vap->iv_flags & IEEE80211_F_WPA)
1506 // retv = ENETRESET;
1507 // break;
1508 // case IEEE80211_PARAM_MCASTKEYLEN:
1509 // if (!(0 < value && value < IEEE80211_KEYBUF_SIZE))
1510 // return -EINVAL;
1511 // /* XXX no way to verify driver capability */
1512 // rsn->rsn_mcastkeylen = value;
1513 // if (vap->iv_flags & IEEE80211_F_WPA)
1514 // retv = ENETRESET;
1515 // break;
1516 // case IEEE80211_PARAM_UCASTCIPHERS:
1517 // /*
1518 // * Convert cipher set to equivalent capabilities.
1519 // * NB: this logic intentionally ignores unknown and
1520 // * unsupported ciphers so folks can specify 0xff or
1521 // * similar and get all available ciphers.
1522 // */
1523 // caps = 0;
1524 // for (j = 1; j < 32; j++) /* NB: skip WEP */
1525 // if ((value & (1<<j)) &&
1526 // ((vap->iv_caps & cipher2cap(j)) ||
1527 // ieee80211_crypto_available(j)))
1528 // caps |= 1<<j;
1529 // if (caps == 0) /* nothing available */
1530 // return -EINVAL;
1531 // /* XXX verify ciphers ok for unicast use? */
1532 // /* XXX disallow if running as it'll have no effect */
1533 // rsn->rsn_ucastcipherset = caps;
1534 // if (vap->iv_flags & IEEE80211_F_WPA)
1535 // retv = ENETRESET;
1536 // break;
1537 // case IEEE80211_PARAM_UCASTCIPHER:
1538 // if ((rsn->rsn_ucastcipherset & cipher2cap(value)) == 0)
1539 // return -EINVAL;
1540 // rsn->rsn_ucastcipher = value;
1541 // break;
1542 // case IEEE80211_PARAM_UCASTKEYLEN:
1543 // if (!(0 < value && value < IEEE80211_KEYBUF_SIZE))
1544 // return -EINVAL;
1545 // /* XXX no way to verify driver capability */
1546 // rsn->rsn_ucastkeylen = value;
1547 // break;
1548 // case IEEE80211_PARAM_KEYMGTALGS:
1549 // /* XXX check */
1550 // rsn->rsn_keymgmtset = value;
1551 // if (vap->iv_flags & IEEE80211_F_WPA)
1552 // retv = ENETRESET;
1553 // break;
1554 // case IEEE80211_PARAM_RSNCAPS:
1555 // /* XXX check */
1556 // rsn->rsn_caps = value;
1557 // if (vap->iv_flags & IEEE80211_F_WPA)
1558 // retv = ENETRESET;
1559 // break;
1560 // case IEEE80211_PARAM_WPA:
1561 // if (value > 3)
1562 // return -EINVAL;
1563 // /* XXX verify ciphers available */
1564 // vap->iv_flags &= ~IEEE80211_F_WPA;
1565 // switch (value) {
1566 // case 1:
1567 // vap->iv_flags |= IEEE80211_F_WPA1;
1568 // break;
1569 // case 2:
1570 // vap->iv_flags |= IEEE80211_F_WPA2;
1571 // break;
1572 // case 3:
1573 // vap->iv_flags |= IEEE80211_F_WPA1 | IEEE80211_F_WPA2;
1574 // break;
1575 // }
1576 // retv = ENETRESET; /* XXX? */
1577 // break;
1578 // case IEEE80211_PARAM_ROAMING:
1579 // if (!(IEEE80211_ROAMING_DEVICE <= value &&
1580 // value <= IEEE80211_ROAMING_MANUAL))
1581 // return -EINVAL;
1582 // ic->ic_roaming = value;
1583 // break;
1584 // case IEEE80211_PARAM_PRIVACY:
1585 // if (value) {
1586 // /* XXX check for key state? */
1587 // vap->iv_flags |= IEEE80211_F_PRIVACY;
1588 // } else
1589 // vap->iv_flags &= ~IEEE80211_F_PRIVACY;
1590 // break;
1591 // case IEEE80211_PARAM_DROPUNENCRYPTED:
1592 // if (value)
1593 // vap->iv_flags |= IEEE80211_F_DROPUNENC;
1594 // else
1595 // vap->iv_flags &= ~IEEE80211_F_DROPUNENC;
1596 // break;
1597 // case IEEE80211_PARAM_COUNTERMEASURES:
1598 // if (value) {
1599 // if ((vap->iv_flags & IEEE80211_F_WPA) == 0)
1600 // return -EINVAL;
1601 // vap->iv_flags |= IEEE80211_F_COUNTERM;
1602 // } else
1603 // vap->iv_flags &= ~IEEE80211_F_COUNTERM;
1604 // break;
1605 // case IEEE80211_PARAM_DRIVER_CAPS:
1606 // vap->iv_caps = value; /* NB: for testing */
1607 // break;
1608 // case IEEE80211_PARAM_MACCMD:
1609 // acl = vap->iv_acl;
1610 // switch (value) {
1611 // case IEEE80211_MACCMD_POLICY_OPEN:
1612 // case IEEE80211_MACCMD_POLICY_ALLOW:
1613 // case IEEE80211_MACCMD_POLICY_DENY:
1614 // if (acl == NULL) {
1615 // acl = ieee80211_aclator_get("mac");
1616 // if (acl == NULL || !acl->iac_attach(vap))
1617 // return -EINVAL;
1618 // vap->iv_acl = acl;
1619 // }
1620 // acl->iac_setpolicy(vap, value);
1621 // break;
1622 // case IEEE80211_MACCMD_FLUSH:
1623 // if (acl != NULL)
1624 // acl->iac_flush(vap);
1625 // /* NB: silently ignore when not in use */
1626 // break;
1627 // case IEEE80211_MACCMD_DETACH:
1628 // if (acl != NULL) {
1629 // vap->iv_acl = NULL;
1630 // acl->iac_detach(vap);
1631 // }
1632 // break;
1633 // }
1634 // break;
1635 // case IEEE80211_PARAM_WMM:
1636 // if (ic->ic_caps & IEEE80211_C_WME){
1637 // if (value) {
1638 // vap->iv_flags |= IEEE80211_F_WME;
1639 // vap->iv_ic->ic_flags |= IEEE80211_F_WME; /* XXX needed by ic_reset */
1640 // }
1641 // else {
1642 // vap->iv_flags &= ~IEEE80211_F_WME;
1643 // vap->iv_ic->ic_flags &= ~IEEE80211_F_WME; /* XXX needed by ic_reset */
1644 // }
1645 // retv = ENETRESET; /* Renegotiate for capabilities */
1646 // }
1647 // break;
1648 // case IEEE80211_PARAM_HIDESSID:
1649 // if (value)
1650 // vap->iv_flags |= IEEE80211_F_HIDESSID;
1651 // else
1652 // vap->iv_flags &= ~IEEE80211_F_HIDESSID;
1653 // retv = ENETRESET;
1654 // break;
1655 // case IEEE80211_PARAM_APBRIDGE:
1656 // if (value == 0)
1657 // vap->iv_flags |= IEEE80211_F_NOBRIDGE;
1658 // else
1659 // vap->iv_flags &= ~IEEE80211_F_NOBRIDGE;
1660 // break;
1661 // case IEEE80211_PARAM_INACT:
1662 // vap->iv_inact_run = value / IEEE80211_INACT_WAIT;
1663 // break;
1664 // case IEEE80211_PARAM_INACT_AUTH:
1665 // vap->iv_inact_auth = value / IEEE80211_INACT_WAIT;
1666 // break;
1667 // case IEEE80211_PARAM_INACT_INIT:
1668 // vap->iv_inact_init = value / IEEE80211_INACT_WAIT;
1669 // break;
1670 // case IEEE80211_PARAM_ABOLT:
1671 // caps = 0;
1672 // /*
1673 // * Map abolt settings to capability bits;
1674 // * this also strips unknown/unwanted bits.
1675 // */
1676 // if (value & IEEE80211_ABOLT_TURBO_PRIME)
1677 // caps |= IEEE80211_ATHC_TURBOP;
1678 // if (value & IEEE80211_ABOLT_COMPRESSION)
1679 // caps |= IEEE80211_ATHC_COMP;
1680 // if (value & IEEE80211_ABOLT_FAST_FRAME)
1681 // caps |= IEEE80211_ATHC_FF;
1682 // if (value & IEEE80211_ABOLT_XR)
1683 // caps |= IEEE80211_ATHC_XR;
1684 // if (value & IEEE80211_ABOLT_AR)
1685 // caps |= IEEE80211_ATHC_AR;
1686 // if (value & IEEE80211_ABOLT_BURST)
1687 // caps |= IEEE80211_ATHC_BURST;
1688 // if (value & IEEE80211_ABOLT_WME_ELE)
1689 // caps |= IEEE80211_ATHC_WME;
1690 // /* verify requested capabilities are supported */
1691 // if ((caps & ic->ic_ath_cap) != caps)
1692 // return -EINVAL;
1693 // if (vap->iv_ath_cap != caps) {
1694 // if ((vap->iv_ath_cap ^ caps) & IEEE80211_ATHC_TURBOP) {
1695 // if (ieee80211_set_turbo(dev, caps & IEEE80211_ATHC_TURBOP))
1696 // return -EINVAL;
1697 // ieee80211_scan_flush(ic);
1698 // }
1699 // vap->iv_ath_cap = caps;
1700 // ic->ic_athcapsetup(vap->iv_ic, vap->iv_ath_cap);
1701 // retv = ENETRESET;
1702 // }
1703 // break;
1704 // case IEEE80211_PARAM_DTIM_PERIOD:
1705 // if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
1706 // vap->iv_opmode != IEEE80211_M_IBSS)
1707 // return -EINVAL;
1708 // if (IEEE80211_DTIM_MIN <= value &&
1709 // value <= IEEE80211_DTIM_MAX) {
1710 // vap->iv_dtim_period = value;
1711 // retv = ENETRESET; /* requires restart */
1712 // } else
1713 // retv = EINVAL;
1714 // break;
1715 // case IEEE80211_PARAM_BEACON_INTERVAL:
1716 // if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
1717 // vap->iv_opmode != IEEE80211_M_IBSS)
1718 // return -EINVAL;
1719 // if (IEEE80211_BINTVAL_MIN <= value &&
1720 // value <= IEEE80211_BINTVAL_MAX) {
1721 // ic->ic_lintval = value; /* XXX multi-bss */
1722 // retv = ENETRESET; /* requires restart */
1723 // } else
1724 // retv = EINVAL;
1725 // break;
1726 // case IEEE80211_PARAM_DOTH:
1727 // if (value) {
1728 // ic->ic_flags |= IEEE80211_F_DOTH;
1729 // }
1730 // else
1731 // ic->ic_flags &= ~IEEE80211_F_DOTH;
1732 // retv = ENETRESET; /* XXX: need something this drastic? */
1733 // break;
1734 // case IEEE80211_PARAM_PWRTARGET:
1735 // ic->ic_curchanmaxpwr = value;
1736 // break;
1737 // case IEEE80211_PARAM_GENREASSOC:
1738 // IEEE80211_SEND_MGMT(vap->iv_bss, IEEE80211_FC0_SUBTYPE_REASSOC_REQ, 0);
1739 // break;
1740 // case IEEE80211_PARAM_COMPRESSION:
1741 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_COMP, value);
1742 // break;
1743 // case IEEE80211_PARAM_WMM_AGGRMODE:
1744 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_WME, value);
1745 // break;
1746 // case IEEE80211_PARAM_FF:
1747 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_FF, value);
1748 // break;
1749 // case IEEE80211_PARAM_TURBO:
1750 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_TURBOP, value);
1751 // if (retv == ENETRESET) {
1752 // if(ieee80211_set_turbo(dev,value))
1753 // return -EINVAL;
1754 // ieee80211_scan_flush(ic);
1755 // }
1756 // break;
1757 // case IEEE80211_PARAM_XR:
1758 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_XR, value);
1759 // break;
1760 // case IEEE80211_PARAM_BURST:
1761 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_BURST, value);
1762 // break;
1763 // case IEEE80211_PARAM_AR:
1764 // retv = ieee80211_setathcap(vap, IEEE80211_ATHC_AR, value);
1765 // break;
1766 // case IEEE80211_PARAM_PUREG:
1767 // if (value)
1768 // vap->iv_flags |= IEEE80211_F_PUREG;
1769 // else
1770 // vap->iv_flags &= ~IEEE80211_F_PUREG;
1771 // /* NB: reset only if we're operating on an 11g channel */
1772 // if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
1773 // IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan))
1774 // retv = ENETRESET;
1775 // break;
1776 // case IEEE80211_PARAM_WDS:
1777 // if (value)
1778 // vap->iv_flags_ext |= IEEE80211_FEXT_WDS;
1779 // else
1780 // vap->iv_flags_ext &= ~IEEE80211_FEXT_WDS;
1781 // break;
1782 // case IEEE80211_PARAM_BGSCAN:
1783 // if (value) {
1784 // if ((vap->iv_caps & IEEE80211_C_BGSCAN) == 0)
1785 // return -EINVAL;
1786 // vap->iv_flags |= IEEE80211_F_BGSCAN;
1787 // } else {
1788 // /* XXX racey? */
1789 // vap->iv_flags &= ~IEEE80211_F_BGSCAN;
1790 // ieee80211_cancel_scan(vap); /* anything current */
1791 // }
1792 // break;
1793 // case IEEE80211_PARAM_BGSCAN_IDLE:
1794 // if (value >= IEEE80211_BGSCAN_IDLE_MIN)
1795 // vap->iv_bgscanidle = value*HZ/1000;
1796 // else
1797 // retv = EINVAL;
1798 // break;
1799 // case IEEE80211_PARAM_BGSCAN_INTERVAL:
1800 // if (value >= IEEE80211_BGSCAN_INTVAL_MIN)
1801 // vap->iv_bgscanintvl = value*HZ;
1802 // else
1803 // retv = EINVAL;
1804 // break;
1805 // case IEEE80211_PARAM_MCAST_RATE:
1806 // /* units are in KILObits per second */
1807 // if (value >= 256 && value <= 54000)
1808 // vap->iv_mcast_rate = value;
1809 // else
1810 // retv = EINVAL;
1811 // break;
1812 // case IEEE80211_PARAM_COVERAGE_CLASS:
1813 // if (value >= 0 && value <= IEEE80211_COVERAGE_CLASS_MAX) {
1814 // ic->ic_coverageclass = value;
1815 // if (IS_UP_AUTO(vap))
1816 // ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
1817 // retv = 0;
1818 // }
1819 // else
1820 // retv = EINVAL;
1821 // break;
1822 // case IEEE80211_PARAM_COUNTRY_IE:
1823 // if (value)
1824 // ic->ic_flags_ext |= IEEE80211_FEXT_COUNTRYIE;
1825 // else
1826 // ic->ic_flags_ext &= ~IEEE80211_FEXT_COUNTRYIE;
1827 // retv = ENETRESET;
1828 // break;
1829 // case IEEE80211_PARAM_REGCLASS:
1830 // if (value)
1831 // ic->ic_flags_ext |= IEEE80211_FEXT_REGCLASS;
1832 // else
1833 // ic->ic_flags_ext &= ~IEEE80211_FEXT_REGCLASS;
1834 // retv = ENETRESET;
1835 // break;
1836 // case IEEE80211_PARAM_SCANVALID:
1837 // vap->iv_scanvalid = value*HZ;
1838 // break;
1839 // case IEEE80211_PARAM_ROAM_RSSI_11A:
1840 // vap->iv_roam.rssi11a = value;
1841 // break;
1842 // case IEEE80211_PARAM_ROAM_RSSI_11B:
1843 // vap->iv_roam.rssi11bOnly = value;
1844 // break;
1845 // case IEEE80211_PARAM_ROAM_RSSI_11G:
1846 // vap->iv_roam.rssi11b = value;
1847 // break;
1848 // case IEEE80211_PARAM_ROAM_RATE_11A:
1849 // vap->iv_roam.rate11a = value;
1850 // break;
1851 // case IEEE80211_PARAM_ROAM_RATE_11B:
1852 // vap->iv_roam.rate11bOnly = value;
1853 // break;
1854 // case IEEE80211_PARAM_ROAM_RATE_11G:
1855 // vap->iv_roam.rate11b = value;
1856 // break;
1857 // case IEEE80211_PARAM_UAPSDINFO:
1858 // if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
1859 // if (ic->ic_caps & IEEE80211_C_UAPSD) {
1860 // if (value)
1861 // IEEE80211_VAP_UAPSD_ENABLE(vap);
1862 // else
1863 // IEEE80211_VAP_UAPSD_DISABLE(vap);
1864 // retv = ENETRESET;
1865 // }
1866 // }
1867 // else if (vap->iv_opmode == IEEE80211_M_STA) {
1868 // vap->iv_uapsdinfo = value;
1869 // IEEE80211_VAP_UAPSD_ENABLE(vap);
1870 // retv = ENETRESET;
1871 // }
1872 // break;
1873 // case IEEE80211_PARAM_SLEEP:
1874 // /* XXX: Forced sleep for testing. Does not actually place the
1875 // * HW in sleep mode yet. this only makes sense for STAs.
1876 // */
1877 // if (value) {
1878 // /* goto sleep */
1879 // IEEE80211_VAP_GOTOSLEEP(vap);
1880 // }
1881 // else {
1882 // /* wakeup */
1883 // IEEE80211_VAP_WAKEUP(vap);
1884 // }
1885 // ieee80211_send_nulldata(ieee80211_ref_node(vap->iv_bss));
1886 // break;
1887 // case IEEE80211_PARAM_QOSNULL:
1888 // /* Force a QoS Null for testing. */
1889 // ieee80211_send_qosnulldata(vap->iv_bss, value);
1890 // break;
1891 // case IEEE80211_PARAM_PSPOLL:
1892 // /* Force a PS-POLL for testing. */
1893 // ieee80211_send_pspoll(vap->iv_bss);
1894 // break;
1895 // case IEEE80211_PARAM_EOSPDROP:
1896 // if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
1897 // if (value) IEEE80211_VAP_EOSPDROP_ENABLE(vap);
1898 // else IEEE80211_VAP_EOSPDROP_DISABLE(vap);
1899 // }
1900 // break;
1901 // case IEEE80211_PARAM_MARKDFS:
1902 // if (value)
1903 // ic->ic_flags_ext |= IEEE80211_FEXT_MARKDFS;
1904 // else
1905 // ic->ic_flags_ext &= ~IEEE80211_FEXT_MARKDFS;
1906 // break;
1907 // case IEEE80211_PARAM_CHANBW:
1908 // switch (value) {
1909 // case 0:
1910 // ic->ic_chanbwflag = 0;
1911 // break;
1912 // case 1:
1913 // ic->ic_chanbwflag = IEEE80211_CHAN_HALF;
1914 // break;
1915 // case 2:
1916 // ic->ic_chanbwflag = IEEE80211_CHAN_QUARTER;
1917 // break;
1918 // default:
1919 // retv = EINVAL;
1920 // break;
1921 // }
1922 // break;
1923 // case IEEE80211_PARAM_SHORTPREAMBLE:
1924 // if (value) {
1925 // ic->ic_caps |= IEEE80211_C_SHPREAMBLE;
1926 // } else {
1927 // ic->ic_caps &= ~IEEE80211_C_SHPREAMBLE;
1928 // }
1929 // retv = ENETRESET;
1930 // break;
1931 // default:
1932 // retv = EOPNOTSUPP;
1933 // break;
1934 // }
1935 // /* XXX should any of these cause a rescan? */
1936 // if (retv == ENETRESET)
1937 // retv = IS_UP_AUTO(vap) ? ieee80211_open(vap->iv_dev) : 0;
1938 // return -retv;
1939 //}
1940
1941 int usbdrvwext_setmode(struct net_device *dev, struct iw_request_info *info,
1942 void *w, char *extra)
1943 {
1944 return 0;
1945 }
1946
1947 int usbdrvwext_getmode(struct net_device *dev, struct iw_request_info *info,
1948 void *w, char *extra)
1949 {
1950 //struct usbdrv_private *macp = dev->ml_priv;
1951 struct iw_point *wri = (struct iw_point *)extra;
1952 char mode[8];
1953
1954 strcpy(mode,"11g");
1955 return (copy_to_user(wri->pointer, mode, 6) ? -EFAULT : 0);
1956 }
1957
1958 int zfLnxPrivateIoctl(struct net_device *dev, struct zdap_ioctl* zdreq)
1959 {
1960 //void* regp = macp->regp;
1961 u16_t cmd;
1962 //u32_t temp;
1963 u32_t* p;
1964 u32_t i;
1965
1966 cmd = zdreq->cmd;
1967 switch(cmd)
1968 {
1969 case ZM_IOCTL_REG_READ:
1970 zfiDbgReadReg(dev, zdreq->addr);
1971 break;
1972
1973 case ZM_IOCTL_REG_WRITE:
1974 zfiDbgWriteReg(dev, zdreq->addr, zdreq->value);
1975 break;
1976
1977 case ZM_IOCTL_MEM_READ:
1978 p = (u32_t *) bus_to_virt(zdreq->addr);
1979 printk(KERN_DEBUG "usbdrv: read memory addr: 0x%08x value: 0x%08x\n", zdreq->addr, *p);
1980 break;
1981
1982 case ZM_IOCTL_MEM_WRITE:
1983 p = (u32_t *) bus_to_virt(zdreq->addr);
1984 *p = zdreq->value;
1985 printk(KERN_DEBUG "usbdrv: write value: 0x%08x to memory addr: 0x%08x\n", zdreq->value, zdreq->addr);
1986 break;
1987
1988 case ZM_IOCTL_TALLY :
1989 zfiWlanShowTally(dev);
1990 if (zdreq->addr)
1991 zfiWlanResetTally(dev);
1992 break;
1993
1994 case ZM_IOCTL_TEST :
1995 printk(KERN_DEBUG "ZM_IOCTL_TEST:len=%d\n", zdreq->addr);
1996 //zfiWlanReadReg(dev, 0x10f400);
1997 //zfiWlanReadReg(dev, 0x10f404);
1998 printk("IOCTL TEST\n");
1999 #if 1
2000 //print packet
2001 for (i=0; i<zdreq->addr; i++)
2002 {
2003 if ((i&0x7) == 0)
2004 {
2005 printk("\n");
2006 }
2007 printk("%02X ", (unsigned char)zdreq->data[i]);
2008 }
2009 printk("\n");
2010 #endif
2011
2012
2013 #if 0 //For Test?? 1 to 0 by CWYang(-)
2014 {
2015 struct sk_buff* s;
2016
2017 /* Allocate a skb */
2018 s = alloc_skb(2000, GFP_ATOMIC);
2019
2020 /* Copy data to skb */
2021 for (i=0; i<zdreq->addr; i++)
2022 {
2023 s->data[i] = zdreq->data[i];
2024 }
2025 s->len = zdreq->addr;
2026
2027 /* Call zfIdlRecv() */
2028 zfiRecv80211(dev, s, NULL);
2029 }
2030 #endif
2031
2032 break;
2033
2034
2035 /****************************** ZDCONFIG ******************************/
2036 case ZM_IOCTL_FRAG :
2037 zfiWlanSetFragThreshold(dev, zdreq->addr);
2038 break;
2039
2040 case ZM_IOCTL_RTS :
2041 zfiWlanSetRtsThreshold(dev, zdreq->addr);
2042 break;
2043
2044 case ZM_IOCTL_SCAN :
2045 zfiWlanScan(dev);
2046 break;
2047
2048 case ZM_IOCTL_KEY :
2049 {
2050 u8_t key[29];
2051 struct zsKeyInfo keyInfo;
2052 u32_t i;
2053
2054 for (i=0; i<29; i++)
2055 {
2056 key[i] = 0;
2057 }
2058
2059 for (i=0; i<zdreq->addr; i++)
2060 {
2061 key[i] = zdreq->data[i];
2062 }
2063
2064 printk("key len=%d, key=%02x%02x%02x%02x%02x...\n",
2065 zdreq->addr, key[0], key[1], key[2], key[3], key[4]);
2066
2067 keyInfo.keyLength = zdreq->addr;
2068 keyInfo.keyIndex = 0;
2069 keyInfo.flag = 0;
2070 keyInfo.key = key;
2071 zfiWlanSetKey(dev, keyInfo);
2072 }
2073 break;
2074
2075 case ZM_IOCTL_RATE :
2076 zfiWlanSetTxRate(dev, zdreq->addr);
2077 break;
2078
2079 case ZM_IOCTL_ENCRYPTION_MODE :
2080 zfiWlanSetEncryMode(dev, zdreq->addr);
2081
2082 zfiWlanDisable(dev, 0);
2083 zfiWlanEnable(dev);
2084 break;
2085 //CWYang(+)
2086 case ZM_IOCTL_SIGNAL_STRENGTH :
2087 {
2088 u8_t buffer[2];
2089 zfiWlanQuerySignalInfo(dev, &buffer[0]);
2090 printk("Current Signal Strength : %02d\n", buffer[0]);
2091 }
2092 break;
2093 //CWYang(+)
2094 case ZM_IOCTL_SIGNAL_QUALITY :
2095 {
2096 u8_t buffer[2];
2097 zfiWlanQuerySignalInfo(dev, &buffer[0]);
2098 printk("Current Signal Quality : %02d\n", buffer[1]);
2099 }
2100 break;
2101
2102 case ZM_IOCTL_SET_PIBSS_MODE:
2103 if (zdreq->addr == 1)
2104 zfiWlanSetWlanMode(dev, ZM_MODE_PSEUDO);
2105 else
2106 zfiWlanSetWlanMode(dev, ZM_MODE_INFRASTRUCTURE);
2107
2108 zfiWlanDisable(dev, 0);
2109 zfiWlanEnable(dev);
2110
2111 break;
2112 /****************************** ZDCONFIG ******************************/
2113
2114 default :
2115 printk(KERN_ERR "usbdrv: error command = %x\n", cmd);
2116 break;
2117 }
2118
2119 return 0;
2120 }
2121
2122 int usbdrv_wpa_ioctl(struct net_device *dev, struct athr_wlan_param *zdparm)
2123 {
2124 int ret = 0;
2125 u8_t bc_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2126 u8_t mac_addr[80];
2127 struct zsKeyInfo keyInfo;
2128 struct usbdrv_private *macp = dev->ml_priv;
2129 u16_t vapId = 0;
2130
2131 //zmw_get_wlan_dev(dev);
2132
2133 switch(zdparm->cmd)
2134 {
2135 case ZD_CMD_SET_ENCRYPT_KEY:
2136
2137 /* Set up key information */
2138 keyInfo.keyLength = zdparm->u.crypt.key_len;
2139 keyInfo.keyIndex = zdparm->u.crypt.idx;
2140 if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) // AP Mode
2141 keyInfo.flag = ZM_KEY_FLAG_AUTHENTICATOR;
2142 else
2143 keyInfo.flag = 0;
2144 keyInfo.key = zdparm->u.crypt.key;
2145 keyInfo.initIv = zdparm->u.crypt.seq;
2146 keyInfo.macAddr = (u16_t *)zdparm->sta_addr;
2147
2148 /* Identify the MAC address information */
2149 if (memcmp(zdparm->sta_addr, bc_addr, sizeof(bc_addr)) == 0)
2150 {
2151 keyInfo.flag |= ZM_KEY_FLAG_GK;
2152 }
2153 else
2154 {
2155 keyInfo.flag |= ZM_KEY_FLAG_PK;
2156 }
2157
2158 if (!strcmp(zdparm->u.crypt.alg, "NONE"))
2159 {
2160 //u8_t zero_mac[]={0,0,0,0,0,0};
2161
2162 /* Set key length to zero */
2163 keyInfo.keyLength = 0;
2164
2165 if (zdparm->sta_addr[0] & 1)//del group key
2166 {
2167 //if (macp->cardSetting.WPAIeLen==0)
2168 //{//802.1x dynamic WEP
2169 // mDynKeyMode = 0;
2170 // mKeyFormat[0] = 0;
2171 // mPrivacyInvoked[0]=FALSE;
2172 // mCap[0] &= ~CAP_PRIVACY;
2173 // macp->cardSetting.EncryOnOff[0]=0;
2174 //}
2175 //mWpaBcKeyLen = mGkInstalled = 0;
2176 }
2177 else
2178 {
2179 //if (memcmp(zero_mac,zdparm->sta_addr, 6)==0)
2180 //{
2181 // mDynKeyMode=0;
2182 // mKeyFormat[0]=0;
2183 // pSetting->DynKeyMode=0;
2184 // pSetting->EncryMode[0]=0;
2185 // mDynKeyMode=0;
2186 //}
2187 }
2188
2189 printk(KERN_ERR "Set Encryption Type NONE\n");
2190 return ret;
2191 }
2192 else if (!strcmp(zdparm->u.crypt.alg, "TKIP"))
2193 {
2194 zfiWlanSetEncryMode(dev, ZM_TKIP);
2195 //Linux Supplicant will inverse Tx/Rx key
2196 //So we inverse it back //CWYang(+)
2197 //zfMemoryCopy(&temp[0], &keyInfo.key[16], 8);
2198 //zfMemoryCopy(&keyInfo.key[16], keyInfo.key[24], 8);
2199 //zfMemoryCopy(&keyInfo.key[24], &temp[0], 8);
2200 //u8_t temp;
2201 //int k;
2202 //for (k = 0; k < 8; k++)
2203 //{
2204 // temp = keyInfo.key[16 + k];
2205 // keyInfo.key[16 + k] = keyInfo.key[24 + k];
2206 // keyInfo.key[24 + k] = temp;
2207 //}
2208 //CamEncryType = ZM_TKIP;
2209 ////if (idx == 0)
2210 //{// Pairwise key
2211 // mKeyFormat[0] = CamEncryType;
2212 // mDynKeyMode = pSetting->DynKeyMode = DYN_KEY_TKIP;
2213 //}
2214 }
2215 else if (!strcmp(zdparm->u.crypt.alg, "CCMP"))
2216 {
2217 zfiWlanSetEncryMode(dev, ZM_AES);
2218 //CamEncryType = ZM_AES;
2219 ////if (idx == 0)
2220 //{// Pairwise key
2221 // mKeyFormat[0] = CamEncryType;
2222 // mDynKeyMode = pSetting->DynKeyMode = DYN_KEY_AES;
2223 //}
2224 }
2225 else if (!strcmp(zdparm->u.crypt.alg, "WEP"))
2226 {
2227 if (keyInfo.keyLength == 5)
2228 { // WEP 64
2229 zfiWlanSetEncryMode(dev, ZM_WEP64);
2230 // CamEncryType = ZM_WEP64;
2231 // tmpDynKeyMode=DYN_KEY_WEP64;
2232 }
2233 else if (keyInfo.keyLength == 13)
2234 {//keylen=13, WEP 128
2235 zfiWlanSetEncryMode(dev, ZM_WEP128);
2236 // CamEncryType = ZM_WEP128;
2237 // tmpDynKeyMode=DYN_KEY_WEP128;
2238 }
2239 else
2240 {
2241 zfiWlanSetEncryMode(dev, ZM_WEP256);
2242 }
2243
2244 // For Dynamic WEP key (Non-WPA Radius), the key ID range: 0-3
2245 // In WPA/RSN mode, the key ID range: 1-3, usually, a broadcast key.
2246 // For WEP key setting: we set mDynKeyMode and mKeyFormat in following case:
2247 // 1. For 802.1x dynamically generated WEP key method.
2248 // 2. For WPA/RSN mode, but key id == 0. (But this is an impossible case)
2249 // So, only check case 1.
2250 //if (macp->cardSetting.WPAIeLen==0)
2251 //{
2252 // mKeyFormat[0] = CamEncryType;
2253 // mDynKeyMode = pSetting->DynKeyMode = tmpDynKeyMode;
2254 // mPrivacyInvoked[0]=TRUE;
2255 // mCap[0] |= CAP_PRIVACY;
2256 // macp->cardSetting.EncryOnOff[0]=1;
2257 //}
2258 }
2259
2260 /* DUMP key context */
2261 //#ifdef WPA_DEBUG
2262 if (keyInfo.keyLength > 0)
2263 {
2264 int ii;
2265 printk("Otus: Key Context:\n");
2266 for(ii = 0; ii < keyInfo.keyLength;)
2267 {
2268 printk("0x%02x ", keyInfo.key[ii]);
2269 if((++ii % 16) == 0)
2270 printk("\n");
2271 }
2272 printk("\n");
2273 }
2274 //#endif
2275
2276 /* Set encrypt mode */
2277 //zfiWlanSetEncryMode(dev, CamEncryType);
2278 vapId = zfLnxGetVapId(dev);
2279 if (vapId == 0xffff)
2280 keyInfo.vapId = 0;
2281 else
2282 keyInfo.vapId = vapId + 1;
2283 keyInfo.vapAddr[0] = keyInfo.macAddr[0];
2284 keyInfo.vapAddr[1] = keyInfo.macAddr[1];
2285 keyInfo.vapAddr[2] = keyInfo.macAddr[2];
2286
2287 zfiWlanSetKey(dev, keyInfo);
2288
2289 //zfiWlanDisable(dev);
2290 //zfiWlanEnable(dev);
2291 break;
2292
2293 case ZD_CMD_SET_MLME:
2294 printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SET_MLME\n");
2295
2296 /* Translate STA's address */
2297 sprintf(mac_addr, "%02x:%02x:%02x:%02x:%02x:%02x", zdparm->sta_addr[0], zdparm->sta_addr[1],
2298 zdparm->sta_addr[2], zdparm->sta_addr[3], zdparm->sta_addr[4], zdparm->sta_addr[5]);
2299
2300 switch(zdparm->u.mlme.cmd)
2301 {
2302 case MLME_STA_DEAUTH:
2303 printk(" -------Call zfiWlanDeauth, reason:%d\n",zdparm->u.mlme.reason_code);
2304 if(zfiWlanDeauth(dev, (u16_t*) zdparm->sta_addr, zdparm->u.mlme.reason_code) != 0)
2305 printk(KERN_ERR "Can't deauthencate STA: %s\n", mac_addr);
2306 else
2307 printk(KERN_ERR "Deauthenticate STA: %s with reason code: %d\n", mac_addr, zdparm->u.mlme.reason_code);
2308 break;
2309
2310 case MLME_STA_DISASSOC:
2311 printk(" -------Call zfiWlanDeauth, reason:%d\n",zdparm->u.mlme.reason_code);
2312 if(zfiWlanDeauth(dev, (u16_t*) zdparm->sta_addr, zdparm->u.mlme.reason_code) != 0)
2313 printk(KERN_ERR "Can't disassociate STA: %s\n", mac_addr);
2314 else
2315 printk(KERN_ERR "Disassociate STA: %s with reason code: %d\n", mac_addr, zdparm->u.mlme.reason_code);
2316 break;
2317
2318 default:
2319 printk(KERN_ERR "MLME command: 0x%04x not support\n", zdparm->u.mlme.cmd);
2320 break;
2321 }
2322
2323 break;
2324
2325 case ZD_CMD_SCAN_REQ:
2326 printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SCAN_REQ\n");
2327 break;
2328
2329 case ZD_CMD_SET_GENERIC_ELEMENT:
2330 printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SET_GENERIC_ELEMENT\n");
2331
2332 /* Copy the WPA IE */
2333 //zm_msg1_mm(ZM_LV_0, "CWY - wpaie Length : ", zdparm->u.generic_elem.len);
2334 printk(KERN_ERR "wpaie Length : %d\n", zdparm->u.generic_elem.len);
2335 if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) // AP Mode
2336 {
2337 zfiWlanSetWpaIe(dev, zdparm->u.generic_elem.data, zdparm->u.generic_elem.len);
2338 }
2339 else
2340 {
2341 macp->supLen = zdparm->u.generic_elem.len;
2342 memcpy(macp->supIe, zdparm->u.generic_elem.data, zdparm->u.generic_elem.len);
2343 }
2344 zfiWlanSetWpaSupport(dev, 1);
2345 //zfiWlanSetWpaIe(dev, zdparm->u.generic_elem.data, zdparm->u.generic_elem.len);
2346 {
2347 int ii;
2348 u8_t len = zdparm->u.generic_elem.len;
2349 u8_t *wpaie = (u8_t *)zdparm->u.generic_elem.data;
2350
2351 printk(KERN_ERR "wd->ap.wpaLen: %d\n", len);
2352
2353 /* DUMP WPA IE */
2354 for(ii = 0; ii < len;)
2355 {
2356 printk(KERN_ERR "0x%02x ", wpaie[ii]);
2357
2358 if((++ii % 16) == 0)
2359 printk(KERN_ERR "\n");
2360 }
2361 printk(KERN_ERR "\n");
2362 }
2363
2364 // #ifdef ZM_HOSTAPD_SUPPORT
2365 //if (wd->wlanMode == ZM_MODE_AP)
2366 //{// Update Beacon FIFO in the next TBTT.
2367 // memcpy(&mWPAIe, pSetting->WPAIe, pSetting->WPAIeLen);
2368 // printk(KERN_ERR "Copy WPA IE into mWPAIe\n");
2369 //}
2370 // #endif
2371 break;
2372
2373 // #ifdef ZM_HOSTAPD_SUPPORT
2374 case ZD_CMD_GET_TSC:
2375 printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_GET_TSC\n");
2376 break;
2377 // #endif
2378
2379 default:
2380 printk(KERN_ERR "usbdrv_wpa_ioctl default: 0x%04x\n", zdparm->cmd);
2381 ret = -EINVAL;
2382 break;
2383 }
2384
2385 return ret;
2386 }
2387
2388 #ifdef ZM_ENABLE_CENC
2389 int usbdrv_cenc_ioctl(struct net_device *dev, struct zydas_cenc_param *zdparm)
2390 {
2391 //struct usbdrv_private *macp = dev->ml_priv;
2392 struct zsKeyInfo keyInfo;
2393 u16_t apId;
2394 u8_t bc_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2395 int ret = 0;
2396 int ii;
2397
2398 /* Get the AP Id */
2399 apId = zfLnxGetVapId(dev);
2400
2401 if (apId == 0xffff)
2402 {
2403 apId = 0;
2404 }
2405 else
2406 {
2407 apId = apId+1;
2408 }
2409
2410 switch (zdparm->cmd)
2411 {
2412 case ZM_CMD_CENC_SETCENC:
2413 printk(KERN_ERR "ZM_CMD_CENC_SETCENC\n");
2414 printk(KERN_ERR "length: %d\n", zdparm->len);
2415 printk(KERN_ERR "policy: %d\n", zdparm->u.info.cenc_policy);
2416 break;
2417 case ZM_CMD_CENC_SETKEY:
2418 //ret = wai_ioctl_setkey(vap, ioctl_msg);
2419 printk(KERN_ERR "ZM_CMD_CENC_SETKEY\n");
2420
2421 printk(KERN_ERR "MAC address= ");
2422 for(ii = 0; ii < 6; ii++)
2423 {
2424 printk(KERN_ERR "0x%02x ", zdparm->u.crypt.sta_addr[ii]);
2425 }
2426 printk(KERN_ERR "\n");
2427
2428 printk(KERN_ERR "Key Index: %d\n", zdparm->u.crypt.keyid);
2429 printk(KERN_ERR "Encryption key= ");
2430 for(ii = 0; ii < 16; ii++)
2431 {
2432 printk(KERN_ERR "0x%02x ", zdparm->u.crypt.key[ii]);
2433 }
2434 printk(KERN_ERR "\n");
2435
2436 printk(KERN_ERR "MIC key= ");
2437 for(ii = 16; ii < ZM_CENC_KEY_SIZE; ii++)
2438 {
2439 printk(KERN_ERR "0x%02x ", zdparm->u.crypt.key[ii]);
2440 }
2441 printk(KERN_ERR "\n");
2442
2443 /* Set up key information */
2444 keyInfo.keyLength = ZM_CENC_KEY_SIZE;
2445 keyInfo.keyIndex = zdparm->u.crypt.keyid;
2446 keyInfo.flag = ZM_KEY_FLAG_AUTHENTICATOR | ZM_KEY_FLAG_CENC;
2447 keyInfo.key = zdparm->u.crypt.key;
2448 keyInfo.macAddr = (u16_t *)zdparm->u.crypt.sta_addr;
2449
2450 /* Identify the MAC address information */
2451 if (memcmp(zdparm->u.crypt.sta_addr, bc_addr, sizeof(bc_addr)) == 0)
2452 {
2453 keyInfo.flag |= ZM_KEY_FLAG_GK;
2454 keyInfo.vapId = apId;
2455 memcpy(keyInfo.vapAddr, dev->dev_addr, ETH_ALEN);
2456 }
2457 else
2458 {
2459 keyInfo.flag |= ZM_KEY_FLAG_PK;
2460 }
2461
2462 zfiWlanSetKey(dev, keyInfo);
2463
2464 break;
2465 case ZM_CMD_CENC_REKEY:
2466 //ret = wai_ioctl_rekey(vap, ioctl_msg);
2467 printk(KERN_ERR "ZM_CMD_CENC_REKEY\n");
2468 break;
2469 default:
2470 ret = -EOPNOTSUPP;
2471 break;
2472
2473 }
2474
2475 //if (retv == ENETRESET)
2476 // retv = IS_UP_AUTO(vap) ? ieee80211_open(vap->iv_dev) : 0;
2477
2478 return ret;
2479 }
2480 #endif //ZM_ENABLE_CENC
2481 /////////////////////////////////////////
2482 int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2483 {
2484 // struct usbdrv_private *macp;
2485 // void *regp;
2486 struct zdap_ioctl zdreq;
2487 struct iwreq *wrq = (struct iwreq *)ifr;
2488 struct athr_wlan_param zdparm;
2489 struct usbdrv_private *macp = dev->ml_priv;
2490
2491 int err = 0;
2492 int changed = 0;
2493
2494 // regp = macp->regp;
2495
2496 if(!netif_running(dev))
2497 return -EINVAL;
2498
2499 switch (cmd)
2500 {
2501 case SIOCGIWNAME:
2502 strcpy(wrq->u.name, "IEEE 802.11-DS");
2503 break;
2504
2505 case SIOCGIWAP:
2506 err = usbdrvwext_giwap(dev, NULL, &wrq->u.ap_addr, NULL);
2507 break;
2508
2509
2510 case SIOCSIWAP:
2511 err = usbdrvwext_siwap(dev, NULL, &wrq->u.ap_addr, NULL);
2512 break;
2513
2514
2515 case SIOCGIWMODE:
2516 err = usbdrvwext_giwmode(dev, NULL, &wrq->u.mode, NULL);
2517 break;
2518
2519
2520 case SIOCSIWESSID:
2521 printk(KERN_ERR "CWY - usbdrvwext_siwessid\n");
2522 //err = usbdrv_ioctl_setessid(dev, &wrq->u.essid);
2523 err = usbdrvwext_siwessid(dev, NULL, &wrq->u.essid, NULL);
2524
2525 if (! err)
2526 changed = 1;
2527 break;
2528
2529
2530 case SIOCGIWESSID:
2531 err = usbdrvwext_giwessid(dev, NULL, &wrq->u.essid, NULL);
2532 break;
2533
2534
2535 case SIOCSIWRTS:
2536
2537 err = usbdrv_ioctl_setrts(dev, &wrq->u.rts);
2538 if (! err)
2539 changed = 1;
2540 break;
2541
2542
2543 case SIOCIWFIRSTPRIV + 0x2: /* set_auth */
2544 {
2545 //printk("CWY - SIOCIWFIRSTPRIV + 0x2 (set_auth)\n");
2546 if (! capable(CAP_NET_ADMIN))
2547 {
2548 err = -EPERM;
2549 break;
2550 }
2551 {
2552 int val = *( (int *) wrq->u.name );
2553 if ((val < 0) || (val > 2))
2554 {
2555 err = -EINVAL;
2556 break;
2557 }
2558 else
2559 {
2560 zfiWlanSetAuthenticationMode(dev, val);
2561
2562 if (macp->DeviceOpened == 1)
2563 {
2564 zfiWlanDisable(dev, 0);
2565 zfiWlanEnable(dev);
2566 }
2567
2568 err = 0;
2569 changed = 1;
2570 }
2571 }
2572 }
2573 break;
2574
2575 case SIOCIWFIRSTPRIV + 0x3: /* get_auth */
2576 {
2577 int AuthMode = ZM_AUTH_MODE_OPEN;
2578
2579 //printk("CWY - SIOCIWFIRSTPRIV + 0x3 (get_auth)\n");
2580
2581 if (wrq->u.data.pointer)
2582 {
2583 wrq->u.data.flags = 1;
2584
2585 AuthMode = zfiWlanQueryAuthenticationMode(dev, 0);
2586 if (AuthMode == ZM_AUTH_MODE_OPEN)
2587 {
2588 wrq->u.data.length = 12;
2589
2590 if (copy_to_user(wrq->u.data.pointer, "open system", 12))
2591 {
2592 return -EFAULT;
2593 }
2594 }
2595 else if (AuthMode == ZM_AUTH_MODE_SHARED_KEY)
2596 {
2597 wrq->u.data.length = 11;
2598
2599 if (copy_to_user(wrq->u.data.pointer, "shared key", 11))
2600 {
2601 return -EFAULT;
2602 }
2603 }
2604 else if (AuthMode == ZM_AUTH_MODE_AUTO)
2605 {
2606 wrq->u.data.length = 10;
2607
2608 if (copy_to_user(wrq->u.data.pointer, "auto mode", 10))
2609 {
2610 return -EFAULT;
2611 }
2612 }
2613 else
2614 {
2615 return -EFAULT;
2616 }
2617 }
2618 }
2619 break;
2620
2621
2622 case ZDAPIOCTL: //debug command
2623 if (copy_from_user(&zdreq, ifr->ifr_data, sizeof (zdreq)))
2624 {
2625 printk(KERN_ERR "usbdrv: copy_from_user error\n");
2626 return -EFAULT;
2627 }
2628
2629 //printk(KERN_DEBUG "usbdrv: cmd=%2x, reg=0x%04lx, value=0x%08lx\n",
2630 // zdreq.cmd, zdreq.addr, zdreq.value);
2631
2632 zfLnxPrivateIoctl(dev, &zdreq);
2633
2634 err = 0;
2635 break;
2636
2637 case ZD_IOCTL_WPA:
2638 if (copy_from_user(&zdparm, ifr->ifr_data, sizeof(struct athr_wlan_param)))
2639 {
2640 printk(KERN_ERR "usbdrv: copy_from_user error\n");
2641 return -EFAULT;
2642 }
2643
2644 usbdrv_wpa_ioctl(dev, &zdparm);
2645 err = 0;
2646 break;
2647
2648 case ZD_IOCTL_PARAM:
2649 {
2650 int *p;
2651 int op;
2652 int arg;
2653
2654 /* Point to the name field and retrieve the
2655 * op and arg elements. */
2656 p = (int *)wrq->u.name;
2657 op = *p++;
2658 arg = *p;
2659
2660 if(op == ZD_PARAM_ROAMING)
2661 {
2662 printk(KERN_ERR "************* ZD_PARAM_ROAMING: %d\n", arg);
2663 //macp->cardSetting.ap_scan=(U8)arg;
2664 }
2665 if(op == ZD_PARAM_PRIVACY)
2666 {
2667 printk(KERN_ERR "ZD_IOCTL_PRIVACY: ");
2668
2669 /* Turn on the privacy invoke flag */
2670 if(arg)
2671 {
2672 // mCap[0] |= CAP_PRIVACY;
2673 // macp->cardSetting.EncryOnOff[0] = 1;
2674 printk(KERN_ERR "enable\n");
2675
2676 }
2677 else
2678 {
2679 // mCap[0] &= ~CAP_PRIVACY;
2680 // macp->cardSetting.EncryOnOff[0] = 0;
2681 printk(KERN_ERR "disable\n");
2682 }
2683 //changed=1;
2684 }
2685 if(op == ZD_PARAM_WPA)
2686 {
2687 printk(KERN_ERR "ZD_PARAM_WPA: ");
2688
2689 if(arg)
2690 {
2691 printk(KERN_ERR "enable\n");
2692
2693 if (zfiWlanQueryWlanMode(dev) != ZM_MODE_AP)
2694 {
2695 printk(KERN_ERR "Station Mode\n");
2696 //zfiWlanQueryWpaIe(dev, (u8_t *)&wpaIe, &wpalen);
2697 //printk("wpaIe : %2x,%2x,%2x\n", wpaIe[21], wpaIe[22], wpaIe[23]);
2698 //printk("rsnIe : %2x,%2x,%2x\n", wpaIe[17], wpaIe[18], wpaIe[19]);
2699 if ((macp->supIe[21] == 0x50) &&
2700 (macp->supIe[22] == 0xf2) &&
2701 (macp->supIe[23] == 0x2))
2702 {
2703 printk(KERN_ERR "wd->sta.authMode = ZM_AUTH_MODE_WPAPSK\n");
2704 //wd->sta.authMode = ZM_AUTH_MODE_WPAPSK;
2705 //wd->ws.authMode = ZM_AUTH_MODE_WPAPSK;
2706 zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_WPAPSK);
2707 }
2708 else if ((macp->supIe[21] == 0x50) &&
2709 (macp->supIe[22] == 0xf2) &&
2710 (macp->supIe[23] == 0x1))
2711 {
2712 printk(KERN_ERR "wd->sta.authMode = ZM_AUTH_MODE_WPA\n");
2713 //wd->sta.authMode = ZM_AUTH_MODE_WPA;
2714 //wd->ws.authMode = ZM_AUTH_MODE_WPA;
2715 zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_WPA);
2716 }
2717 else if ((macp->supIe[17] == 0xf) &&
2718 (macp->supIe[18] == 0xac) &&
2719 (macp->supIe[19] == 0x2))
2720 {
2721 printk(KERN_ERR "wd->sta.authMode = ZM_AUTH_MODE_WPA2PSK\n");
2722 //wd->sta.authMode = ZM_AUTH_MODE_WPA2PSK;
2723 //wd->ws.authMode = ZM_AUTH_MODE_WPA2PSK;
2724 zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_WPA2PSK);
2725 }
2726 else if ((macp->supIe[17] == 0xf) &&
2727 (macp->supIe[18] == 0xac) &&
2728 (macp->supIe[19] == 0x1))
2729 {
2730 printk(KERN_ERR "wd->sta.authMode = ZM_AUTH_MODE_WPA2\n");
2731 //wd->sta.authMode = ZM_AUTH_MODE_WPA2;
2732 //wd->ws.authMode = ZM_AUTH_MODE_WPA2;
2733 zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_WPA2);
2734 }
2735 if ((macp->supIe[21] == 0x50) || (macp->supIe[22] == 0xf2))//WPA or WPAPSK
2736 {
2737 if (macp->supIe[11] == 0x2)
2738 {
2739 printk(KERN_ERR "wd->sta.wepStatus = ZM_ENCRYPTION_TKIP\n");
2740 //wd->sta.wepStatus = ZM_ENCRYPTION_TKIP;
2741 //wd->ws.wepStatus = ZM_ENCRYPTION_TKIP;
2742 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_TKIP);
2743 }
2744 else
2745 {
2746 printk(KERN_ERR "wd->sta.wepStatus = ZM_ENCRYPTION_AES\n");
2747 //wd->sta.wepStatus = ZM_ENCRYPTION_AES;
2748 //wd->ws.wepStatus = ZM_ENCRYPTION_AES;
2749 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_AES);
2750 }
2751 }
2752 if ((macp->supIe[17] == 0xf) || (macp->supIe[18] == 0xac)) //WPA2 or WPA2PSK
2753 {
2754 if (macp->supIe[13] == 0x2)
2755 {
2756 printk(KERN_ERR "wd->sta.wepStatus = ZM_ENCRYPTION_TKIP\n");
2757 //wd->sta.wepStatus = ZM_ENCRYPTION_TKIP;
2758 //wd->ws.wepStatus = ZM_ENCRYPTION_TKIP;
2759 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_TKIP);
2760 }
2761 else
2762 {
2763 printk(KERN_ERR "wd->sta.wepStatus = ZM_ENCRYPTION_AES\n");
2764 //wd->sta.wepStatus = ZM_ENCRYPTION_AES;
2765 //wd->ws.wepStatus = ZM_ENCRYPTION_AES;
2766 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_AES);
2767 }
2768 }
2769 }
2770 zfiWlanSetWpaSupport(dev, 1);
2771 }
2772 else
2773 {
2774 /* Reset the WPA related variables */
2775 printk(KERN_ERR "disable\n");
2776
2777 zfiWlanSetWpaSupport(dev, 0);
2778 zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_OPEN);
2779 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_WEP_DISABLED);
2780
2781 /* Now we only set the length in the WPA IE
2782 * field to zero. */
2783 //macp->cardSetting.WPAIe[1] = 0;
2784 }
2785 }
2786 if(op == ZD_PARAM_COUNTERMEASURES)
2787 {
2788 printk(KERN_ERR "================ZD_PARAM_COUNTERMEASURES: ");
2789
2790 if(arg)
2791 {
2792 // mCounterMeasureState=1;
2793 printk(KERN_ERR "enable\n");
2794 }
2795 else
2796 {
2797 // mCounterMeasureState=0;
2798 printk(KERN_ERR "disable\n");
2799 }
2800 }
2801 if(op == ZD_PARAM_DROPUNENCRYPTED)
2802 {
2803 printk(KERN_ERR "ZD_PARAM_DROPUNENCRYPTED: ");
2804
2805 if(arg)
2806 {
2807 printk(KERN_ERR "enable\n");
2808 }
2809 else
2810 {
2811 printk(KERN_ERR "disable\n");
2812 }
2813 }
2814 if(op == ZD_PARAM_AUTH_ALGS)
2815 {
2816 printk(KERN_ERR "ZD_PARAM_AUTH_ALGS: ");
2817
2818 if(arg == 0)
2819 {
2820 printk(KERN_ERR "OPEN_SYSTEM\n");
2821 }
2822 else
2823 {
2824 printk(KERN_ERR "SHARED_KEY\n");
2825 }
2826 }
2827 if(op == ZD_PARAM_WPS_FILTER)
2828 {
2829 printk(KERN_ERR "ZD_PARAM_WPS_FILTER: ");
2830
2831 if(arg)
2832 {
2833 // mCounterMeasureState=1;
2834 macp->forwardMgmt = 1;
2835 printk(KERN_ERR "enable\n");
2836 }
2837 else
2838 {
2839 // mCounterMeasureState=0;
2840 macp->forwardMgmt = 0;
2841 printk(KERN_ERR "disable\n");
2842 }
2843 }
2844 }
2845 err = 0;
2846 break;
2847
2848 case ZD_IOCTL_GETWPAIE:
2849 {
2850 struct ieee80211req_wpaie req_wpaie;
2851 u16_t apId, i, j;
2852
2853 /* Get the AP Id */
2854 apId = zfLnxGetVapId(dev);
2855
2856 if (apId == 0xffff)
2857 {
2858 apId = 0;
2859 }
2860 else
2861 {
2862 apId = apId+1;
2863 }
2864
2865 if (copy_from_user(&req_wpaie, ifr->ifr_data, sizeof(struct ieee80211req_wpaie))){
2866 printk(KERN_ERR "usbdrv: copy_from_user error\n");
2867 return -EFAULT;
2868 }
2869
2870 for(i = 0; i < ZM_OAL_MAX_STA_SUPPORT; i++)
2871 {
2872 for(j = 0; j < IEEE80211_ADDR_LEN; j++)
2873 {
2874 if (macp->stawpaie[i].wpa_macaddr[j] != req_wpaie.wpa_macaddr[j])
2875 break;
2876 }
2877 if (j == 6)
2878 break;
2879 }
2880 if (i < ZM_OAL_MAX_STA_SUPPORT)
2881 {
2882 //printk("ZD_IOCTL_GETWPAIE - sta index = %d\n", i);
2883 memcpy(req_wpaie.wpa_ie, macp->stawpaie[i].wpa_ie, IEEE80211_MAX_IE_SIZE);
2884 }
2885
2886 if (copy_to_user(wrq->u.data.pointer, &req_wpaie, sizeof(struct ieee80211req_wpaie)))
2887 {
2888 return -EFAULT;
2889 }
2890 }
2891
2892 err = 0;
2893 break;
2894 #ifdef ZM_ENABLE_CENC
2895 case ZM_IOCTL_CENC:
2896 if (copy_from_user(&macp->zd_wpa_req, ifr->ifr_data, sizeof(struct athr_wlan_param)))
2897 {
2898 printk(KERN_ERR "usbdrv: copy_from_user error\n");
2899 return -EFAULT;
2900 }
2901
2902 usbdrv_cenc_ioctl(dev, (struct zydas_cenc_param *)&macp->zd_wpa_req);
2903 err = 0;
2904 break;
2905 #endif //ZM_ENABLE_CENC
2906 default:
2907 err = -EOPNOTSUPP;
2908 break;
2909 }
2910
2911
2912 return err;
2913 }
Support for the Chinese Samsung S3C2440 based development boards