?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: rtl8192e: Remove unused members from r8192_priv
[wandboard.git] / drivers / staging / rtl8192e / r8192E_wx.c
blob15b08013aae0ad46478e54f4a91a139ac4cb0d23
1 /*
2 This file contains wireless extension handlers.
3
4 This is part of rtl8180 OpenSource driver.
5 Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
6 Released under the terms of GPL (General Public Licence)
7
8 Parts of this driver are based on the GPL part
9 of the official realtek driver.
10
11 Parts of this driver are based on the rtl8180 driver skeleton
12 from Patric Schenke & Andres Salomon.
13
14 Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver.
15
16 We want to tanks the Authors of those projects and the Ndiswrapper
17 project Authors.
18 */
19
20 #include <linux/string.h>
21 #include "r8192E.h"
22 #include "r8192E_hw.h"
23 #include "r8192E_wx.h"
24 #ifdef ENABLE_DOT11D
25 #include "ieee80211/dot11d.h"
26 #endif
27
28 #define RATE_COUNT 12
29 static const u32 rtl8180_rates[] = {1000000,2000000,5500000,11000000,
30 6000000,9000000,12000000,18000000,24000000,36000000,48000000,54000000};
31
32
33 #ifndef ENETDOWN
34 #define ENETDOWN 1
35 #endif
36 static int r8192_wx_get_freq(struct net_device *dev,
37 struct iw_request_info *a,
38 union iwreq_data *wrqu, char *b)
39 {
40 struct r8192_priv *priv = ieee80211_priv(dev);
41
42 return ieee80211_wx_get_freq(priv->ieee80211,a,wrqu,b);
43 }
44
45
46 static int r8192_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
47 union iwreq_data *wrqu, char *b)
48 {
49 struct r8192_priv *priv=ieee80211_priv(dev);
50
51 return ieee80211_wx_get_mode(priv->ieee80211,a,wrqu,b);
52 }
53
54
55
56 static int r8192_wx_get_rate(struct net_device *dev,
57 struct iw_request_info *info,
58 union iwreq_data *wrqu, char *extra)
59 {
60 struct r8192_priv *priv = ieee80211_priv(dev);
61 return ieee80211_wx_get_rate(priv->ieee80211,info,wrqu,extra);
62 }
63
64
65
66 static int r8192_wx_set_rate(struct net_device *dev,
67 struct iw_request_info *info,
68 union iwreq_data *wrqu, char *extra)
69 {
70 int ret;
71 struct r8192_priv *priv = ieee80211_priv(dev);
72
73 if (priv->bHwRadioOff)
74 return 0;
75
76 down(&priv->wx_sem);
77
78 ret = ieee80211_wx_set_rate(priv->ieee80211,info,wrqu,extra);
79
80 up(&priv->wx_sem);
81
82 return ret;
83 }
84
85
86 static int r8192_wx_set_rts(struct net_device *dev,
87 struct iw_request_info *info,
88 union iwreq_data *wrqu, char *extra)
89 {
90 int ret;
91 struct r8192_priv *priv = ieee80211_priv(dev);
92
93 if (priv->bHwRadioOff)
94 return 0;
95
96 down(&priv->wx_sem);
97
98 ret = ieee80211_wx_set_rts(priv->ieee80211,info,wrqu,extra);
99
100 up(&priv->wx_sem);
101
102 return ret;
103 }
104
105 static int r8192_wx_get_rts(struct net_device *dev,
106 struct iw_request_info *info,
107 union iwreq_data *wrqu, char *extra)
108 {
109 struct r8192_priv *priv = ieee80211_priv(dev);
110 return ieee80211_wx_get_rts(priv->ieee80211,info,wrqu,extra);
111 }
112
113 static int r8192_wx_set_power(struct net_device *dev,
114 struct iw_request_info *info,
115 union iwreq_data *wrqu, char *extra)
116 {
117 int ret;
118 struct r8192_priv *priv = ieee80211_priv(dev);
119
120 if (priv->bHwRadioOff)
121 return 0;
122
123 down(&priv->wx_sem);
124
125 ret = ieee80211_wx_set_power(priv->ieee80211,info,wrqu,extra);
126
127 up(&priv->wx_sem);
128
129 return ret;
130 }
131
132 static int r8192_wx_get_power(struct net_device *dev,
133 struct iw_request_info *info,
134 union iwreq_data *wrqu, char *extra)
135 {
136 struct r8192_priv *priv = ieee80211_priv(dev);
137 return ieee80211_wx_get_power(priv->ieee80211,info,wrqu,extra);
138 }
139
140 static int r8192_wx_set_rawtx(struct net_device *dev,
141 struct iw_request_info *info,
142 union iwreq_data *wrqu, char *extra)
143 {
144 struct r8192_priv *priv = ieee80211_priv(dev);
145 int ret;
146
147 if (priv->bHwRadioOff)
148 return 0;
149
150 down(&priv->wx_sem);
151
152 ret = ieee80211_wx_set_rawtx(priv->ieee80211, info, wrqu, extra);
153
154 up(&priv->wx_sem);
155
156 return ret;
157
158 }
159
160 static int r8192_wx_force_reset(struct net_device *dev,
161 struct iw_request_info *info,
162 union iwreq_data *wrqu, char *extra)
163 {
164 struct r8192_priv *priv = ieee80211_priv(dev);
165
166 down(&priv->wx_sem);
167
168 printk("%s(): force reset ! extra is %d\n",__FUNCTION__, *extra);
169 priv->force_reset = *extra;
170 up(&priv->wx_sem);
171 return 0;
172
173 }
174
175
176 static int r8192_wx_set_crcmon(struct net_device *dev,
177 struct iw_request_info *info,
178 union iwreq_data *wrqu, char *extra)
179 {
180 struct r8192_priv *priv = ieee80211_priv(dev);
181 int *parms = (int *)extra;
182 int enable = (parms[0] > 0);
183 short prev = priv->crcmon;
184
185 if (priv->bHwRadioOff)
186 return 0;
187
188 down(&priv->wx_sem);
189
190 if(enable)
191 priv->crcmon=1;
192 else
193 priv->crcmon=0;
194
195 DMESG("bad CRC in monitor mode are %s",
196 priv->crcmon ? "accepted" : "rejected");
197
198 if(prev != priv->crcmon && priv->up){
199 //rtl8180_down(dev);
200 //rtl8180_up(dev);
201 }
202
203 up(&priv->wx_sem);
204
205 return 0;
206 }
207
208 static int r8192_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
209 union iwreq_data *wrqu, char *b)
210 {
211 struct r8192_priv *priv = ieee80211_priv(dev);
212 RT_RF_POWER_STATE rtState;
213 int ret;
214
215 if (priv->bHwRadioOff)
216 return 0;
217
218 rtState = priv->ieee80211->eRFPowerState;
219 down(&priv->wx_sem);
220 #ifdef ENABLE_IPS
221 if(wrqu->mode == IW_MODE_ADHOC){
222
223 if(priv->ieee80211->PowerSaveControl.bInactivePs){
224 if(rtState == eRfOff){
225 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
226 {
227 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
228 up(&priv->wx_sem);
229 return -1;
230 }
231 else{
232 RT_TRACE(COMP_ERR, "%s(): IPSLeave\n",__FUNCTION__);
233 down(&priv->ieee80211->ips_sem);
234 IPSLeave(dev);
235 up(&priv->ieee80211->ips_sem);
236 }
237 }
238 }
239 }
240 #endif
241 ret = ieee80211_wx_set_mode(priv->ieee80211,a,wrqu,b);
242
243 //rtl8187_set_rxconf(dev);
244
245 up(&priv->wx_sem);
246 return ret;
247 }
248
249 struct iw_range_with_scan_capa
250 {
251 /* Informative stuff (to choose between different interface) */
252 __u32 throughput; /* To give an idea... */
253 /* In theory this value should be the maximum benchmarked
254 * TCP/IP throughput, because with most of these devices the
255 * bit rate is meaningless (overhead an co) to estimate how
256 * fast the connection will go and pick the fastest one.
257 * I suggest people to play with Netperf or any benchmark...
258 */
259
260 /* NWID (or domain id) */
261 __u32 min_nwid; /* Minimal NWID we are able to set */
262 __u32 max_nwid; /* Maximal NWID we are able to set */
263
264 /* Old Frequency (backward compat - moved lower ) */
265 __u16 old_num_channels;
266 __u8 old_num_frequency;
267
268 /* Scan capabilities */
269 __u8 scan_capa;
270 };
271 static int rtl8180_wx_get_range(struct net_device *dev,
272 struct iw_request_info *info,
273 union iwreq_data *wrqu, char *extra)
274 {
275 struct iw_range *range = (struct iw_range *)extra;
276 struct iw_range_with_scan_capa* tmp = (struct iw_range_with_scan_capa*)range;
277 struct r8192_priv *priv = ieee80211_priv(dev);
278 u16 val;
279 int i;
280
281 wrqu->data.length = sizeof(*range);
282 memset(range, 0, sizeof(*range));
283
284 /* Let's try to keep this struct in the same order as in
285 * linux/include/wireless.h
286 */
287
288 /* TODO: See what values we can set, and remove the ones we can't
289 * set, or fill them with some default data.
290 */
291
292 /* ~5 Mb/s real (802.11b) */
293 range->throughput = 130 * 1000 * 1000;
294
295 // TODO: Not used in 802.11b?
296 // range->min_nwid; /* Minimal NWID we are able to set */
297 // TODO: Not used in 802.11b?
298 // range->max_nwid; /* Maximal NWID we are able to set */
299
300 /* Old Frequency (backward compat - moved lower ) */
301 // range->old_num_channels;
302 // range->old_num_frequency;
303 // range->old_freq[6]; /* Filler to keep "version" at the same offset */
304
305 range->max_qual.qual = 100;
306 /* TODO: Find real max RSSI and stick here */
307 range->max_qual.level = 0;
308 range->max_qual.noise = -98;
309 range->max_qual.updated = 7; /* Updated all three */
310
311 range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
312 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
313 range->avg_qual.level = 20 + -98;
314 range->avg_qual.noise = 0;
315 range->avg_qual.updated = 7; /* Updated all three */
316
317 range->num_bitrates = RATE_COUNT;
318
319 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
320 range->bitrate[i] = rtl8180_rates[i];
321 }
322
323 range->min_frag = MIN_FRAG_THRESHOLD;
324 range->max_frag = MAX_FRAG_THRESHOLD;
325
326 range->min_pmp=0;
327 range->max_pmp = 5000000;
328 range->min_pmt = 0;
329 range->max_pmt = 65535*1000;
330 range->pmp_flags = IW_POWER_PERIOD;
331 range->pmt_flags = IW_POWER_TIMEOUT;
332 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
333 range->we_version_compiled = WIRELESS_EXT;
334 range->we_version_source = 18;
335
336 // range->retry_capa; /* What retry options are supported */
337 // range->retry_flags; /* How to decode max/min retry limit */
338 // range->r_time_flags; /* How to decode max/min retry life */
339 // range->min_retry; /* Minimal number of retries */
340 // range->max_retry; /* Maximal number of retries */
341 // range->min_r_time; /* Minimal retry lifetime */
342 // range->max_r_time; /* Maximal retry lifetime */
343
344
345 for (i = 0, val = 0; i < 14; i++) {
346
347 // Include only legal frequencies for some countries
348 #ifdef ENABLE_DOT11D
349 if ((GET_DOT11D_INFO(priv->ieee80211)->channel_map)[i+1]) {
350 #else
351 if ((priv->ieee80211->channel_map)[i+1]) {
352 #endif
353 range->freq[val].i = i + 1;
354 range->freq[val].m = ieee80211_wlan_frequencies[i] * 100000;
355 range->freq[val].e = 1;
356 val++;
357 } else {
358 // FIXME: do we need to set anything for channels
359 // we don't use ?
360 }
361
362 if (val == IW_MAX_FREQUENCIES)
363 break;
364 }
365 range->num_frequency = val;
366 range->num_channels = val;
367 #if WIRELESS_EXT > 17
368 range->enc_capa = IW_ENC_CAPA_WPA|IW_ENC_CAPA_WPA2|
369 IW_ENC_CAPA_CIPHER_TKIP|IW_ENC_CAPA_CIPHER_CCMP;
370 #endif
371 tmp->scan_capa = 0x01;
372 return 0;
373 }
374
375
376 static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
377 union iwreq_data *wrqu, char *b)
378 {
379 struct r8192_priv *priv = ieee80211_priv(dev);
380 struct ieee80211_device* ieee = priv->ieee80211;
381 RT_RF_POWER_STATE rtState;
382 int ret;
383
384 if (priv->bHwRadioOff)
385 return 0;
386
387 rtState = priv->ieee80211->eRFPowerState;
388
389 if(!priv->up) return -ENETDOWN;
390 if (priv->ieee80211->LinkDetectInfo.bBusyTraffic == true)
391 return -EAGAIN;
392
393 if (wrqu->data.flags & IW_SCAN_THIS_ESSID)
394 {
395 struct iw_scan_req* req = (struct iw_scan_req*)b;
396 if (req->essid_len)
397 {
398 //printk("==**&*&*&**===>scan set ssid:%s\n", req->essid);
399 ieee->current_network.ssid_len = req->essid_len;
400 memcpy(ieee->current_network.ssid, req->essid, req->essid_len);
401 //printk("=====>network ssid:%s\n", ieee->current_network.ssid);
402 }
403 }
404
405 down(&priv->wx_sem);
406 #ifdef ENABLE_IPS
407 priv->ieee80211->actscanning = true;
408 if(priv->ieee80211->state != IEEE80211_LINKED){
409 if(priv->ieee80211->PowerSaveControl.bInactivePs){
410 if(rtState == eRfOff){
411 if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
412 {
413 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
414 up(&priv->wx_sem);
415 return -1;
416 }
417 else{
418 //RT_TRACE(COMP_PS, "%s(): IPSLeave\n",__FUNCTION__);
419 down(&priv->ieee80211->ips_sem);
420 IPSLeave(dev);
421 up(&priv->ieee80211->ips_sem);
422 }
423 }
424 }
425 priv->ieee80211->scanning = 0;
426 ieee80211_softmac_scan_syncro(priv->ieee80211);
427 ret = 0;
428 }
429 else
430 #else
431
432 if(priv->ieee80211->state != IEEE80211_LINKED){
433 priv->ieee80211->scanning = 0;
434 ieee80211_softmac_scan_syncro(priv->ieee80211);
435 ret = 0;
436 }
437 else
438 #endif
439 ret = ieee80211_wx_set_scan(priv->ieee80211,a,wrqu,b);
440
441 up(&priv->wx_sem);
442 return ret;
443 }
444
445
446 static int r8192_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
447 union iwreq_data *wrqu, char *b)
448 {
449
450 int ret;
451 struct r8192_priv *priv = ieee80211_priv(dev);
452
453 if (priv->bHwRadioOff)
454 return 0;
455
456 if(!priv->up) return -ENETDOWN;
457
458 down(&priv->wx_sem);
459
460 ret = ieee80211_wx_get_scan(priv->ieee80211,a,wrqu,b);
461
462 up(&priv->wx_sem);
463
464 return ret;
465 }
466
467 static int r8192_wx_set_essid(struct net_device *dev,
468 struct iw_request_info *a,
469 union iwreq_data *wrqu, char *b)
470 {
471 struct r8192_priv *priv = ieee80211_priv(dev);
472 RT_RF_POWER_STATE rtState;
473 int ret;
474
475 if (priv->bHwRadioOff)
476 return 0;
477
478 rtState = priv->ieee80211->eRFPowerState;
479 down(&priv->wx_sem);
480
481 #ifdef ENABLE_IPS
482 down(&priv->ieee80211->ips_sem);
483 IPSLeave(dev);
484 up(&priv->ieee80211->ips_sem);
485 #endif
486 ret = ieee80211_wx_set_essid(priv->ieee80211,a,wrqu,b);
487
488 up(&priv->wx_sem);
489
490 return ret;
491 }
492
493
494
495
496 static int r8192_wx_get_essid(struct net_device *dev,
497 struct iw_request_info *a,
498 union iwreq_data *wrqu, char *b)
499 {
500 int ret;
501 struct r8192_priv *priv = ieee80211_priv(dev);
502
503 down(&priv->wx_sem);
504
505 ret = ieee80211_wx_get_essid(priv->ieee80211, a, wrqu, b);
506
507 up(&priv->wx_sem);
508
509 return ret;
510 }
511
512
513 static int r8192_wx_set_freq(struct net_device *dev, struct iw_request_info *a,
514 union iwreq_data *wrqu, char *b)
515 {
516 int ret;
517 struct r8192_priv *priv = ieee80211_priv(dev);
518
519 if (priv->bHwRadioOff)
520 return 0;
521
522 down(&priv->wx_sem);
523
524 ret = ieee80211_wx_set_freq(priv->ieee80211, a, wrqu, b);
525
526 up(&priv->wx_sem);
527 return ret;
528 }
529
530 static int r8192_wx_get_name(struct net_device *dev,
531 struct iw_request_info *info,
532 union iwreq_data *wrqu, char *extra)
533 {
534 struct r8192_priv *priv = ieee80211_priv(dev);
535 return ieee80211_wx_get_name(priv->ieee80211, info, wrqu, extra);
536 }
537
538
539 static int r8192_wx_set_frag(struct net_device *dev,
540 struct iw_request_info *info,
541 union iwreq_data *wrqu, char *extra)
542 {
543 struct r8192_priv *priv = ieee80211_priv(dev);
544
545 if (priv->bHwRadioOff)
546 return 0;
547
548 if (wrqu->frag.disabled)
549 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
550 else {
551 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
552 wrqu->frag.value > MAX_FRAG_THRESHOLD)
553 return -EINVAL;
554
555 priv->ieee80211->fts = wrqu->frag.value & ~0x1;
556 }
557
558 return 0;
559 }
560
561
562 static int r8192_wx_get_frag(struct net_device *dev,
563 struct iw_request_info *info,
564 union iwreq_data *wrqu, char *extra)
565 {
566 struct r8192_priv *priv = ieee80211_priv(dev);
567
568 wrqu->frag.value = priv->ieee80211->fts;
569 wrqu->frag.fixed = 0; /* no auto select */
570 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD);
571
572 return 0;
573 }
574
575
576 static int r8192_wx_set_wap(struct net_device *dev,
577 struct iw_request_info *info,
578 union iwreq_data *awrq,
579 char *extra)
580 {
581
582 int ret;
583 struct r8192_priv *priv = ieee80211_priv(dev);
584 // struct sockaddr *temp = (struct sockaddr *)awrq;
585
586 if (priv->bHwRadioOff)
587 return 0;
588
589 down(&priv->wx_sem);
590
591 #ifdef ENABLE_IPS
592 down(&priv->ieee80211->ips_sem);
593 IPSLeave(dev);
594 up(&priv->ieee80211->ips_sem);
595 #endif
596 ret = ieee80211_wx_set_wap(priv->ieee80211,info,awrq,extra);
597
598 up(&priv->wx_sem);
599
600 return ret;
601
602 }
603
604
605 static int r8192_wx_get_wap(struct net_device *dev,
606 struct iw_request_info *info,
607 union iwreq_data *wrqu, char *extra)
608 {
609 struct r8192_priv *priv = ieee80211_priv(dev);
610
611 return ieee80211_wx_get_wap(priv->ieee80211,info,wrqu,extra);
612 }
613
614
615 static int r8192_wx_get_enc(struct net_device *dev,
616 struct iw_request_info *info,
617 union iwreq_data *wrqu, char *key)
618 {
619 struct r8192_priv *priv = ieee80211_priv(dev);
620
621 return ieee80211_wx_get_encode(priv->ieee80211, info, wrqu, key);
622 }
623
624 static int r8192_wx_set_enc(struct net_device *dev,
625 struct iw_request_info *info,
626 union iwreq_data *wrqu, char *key)
627 {
628 struct r8192_priv *priv = ieee80211_priv(dev);
629 int ret;
630
631 struct ieee80211_device *ieee = priv->ieee80211;
632 //u32 TargetContent;
633 u32 hwkey[4]={0,0,0,0};
634 u8 mask=0xff;
635 u32 key_idx=0;
636 u8 zero_addr[4][6] ={{0x00,0x00,0x00,0x00,0x00,0x00},
637 {0x00,0x00,0x00,0x00,0x00,0x01},
638 {0x00,0x00,0x00,0x00,0x00,0x02},
639 {0x00,0x00,0x00,0x00,0x00,0x03} };
640 int i;
641
642 if (priv->bHwRadioOff)
643 return 0;
644
645 if(!priv->up) return -ENETDOWN;
646
647 priv->ieee80211->wx_set_enc = 1;
648 #ifdef ENABLE_IPS
649 down(&priv->ieee80211->ips_sem);
650 IPSLeave(dev);
651 up(&priv->ieee80211->ips_sem);
652 #endif
653
654 down(&priv->wx_sem);
655
656 RT_TRACE(COMP_SEC, "Setting SW wep key");
657 ret = ieee80211_wx_set_encode(priv->ieee80211,info,wrqu,key);
658
659 up(&priv->wx_sem);
660
661 //sometimes, the length is zero while we do not type key value
662 if(wrqu->encoding.length!=0){
663
664 for(i=0 ; i<4 ; i++){
665 hwkey[i] |= key[4*i+0]&mask;
666 if(i==1&&(4*i+1)==wrqu->encoding.length) mask=0x00;
667 if(i==3&&(4*i+1)==wrqu->encoding.length) mask=0x00;
668 hwkey[i] |= (key[4*i+1]&mask)<<8;
669 hwkey[i] |= (key[4*i+2]&mask)<<16;
670 hwkey[i] |= (key[4*i+3]&mask)<<24;
671 }
672
673 #define CONF_WEP40 0x4
674 #define CONF_WEP104 0x14
675
676 switch(wrqu->encoding.flags & IW_ENCODE_INDEX){
677 case 0: key_idx = ieee->tx_keyidx; break;
678 case 1: key_idx = 0; break;
679 case 2: key_idx = 1; break;
680 case 3: key_idx = 2; break;
681 case 4: key_idx = 3; break;
682 default: break;
683 }
684
685 //printk("-------====>length:%d, key_idx:%d, flag:%x\n", wrqu->encoding.length, key_idx, wrqu->encoding.flags);
686 if(wrqu->encoding.length==0x5){
687 ieee->pairwise_key_type = KEY_TYPE_WEP40;
688 EnableHWSecurityConfig8192(dev);
689 setKey( dev,
690 key_idx, //EntryNo
691 key_idx, //KeyIndex
692 KEY_TYPE_WEP40, //KeyType
693 zero_addr[key_idx],
694 0, //DefaultKey
695 hwkey); //KeyContent
696
697 #if 0
698 if(key_idx == 0){
699
700 //write_nic_byte(dev, SECR, 7);
701 setKey( dev,
702 4, //EntryNo
703 key_idx, //KeyIndex
704 KEY_TYPE_WEP40, //KeyType
705 broadcast_addr, //addr
706 0, //DefaultKey
707 hwkey); //KeyContent
708 }
709 #endif
710 }
711
712 else if(wrqu->encoding.length==0xd){
713 ieee->pairwise_key_type = KEY_TYPE_WEP104;
714 EnableHWSecurityConfig8192(dev);
715 setKey( dev,
716 key_idx, //EntryNo
717 key_idx, //KeyIndex
718 KEY_TYPE_WEP104, //KeyType
719 zero_addr[key_idx],
720 0, //DefaultKey
721 hwkey); //KeyContent
722 #if 0
723 if(key_idx == 0){
724
725 //write_nic_byte(dev, SECR, 7);
726 setKey( dev,
727 4, //EntryNo
728 key_idx, //KeyIndex
729 KEY_TYPE_WEP104, //KeyType
730 broadcast_addr, //addr
731 0, //DefaultKey
732 hwkey); //KeyContent
733 }
734 #endif
735 }
736 else printk("wrong type in WEP, not WEP40 and WEP104\n");
737
738
739 }
740
741 #if 0
742 //consider the setting different key index situation
743 //wrqu->encoding.flags = 801 means that we set key with index "1"
744 if(wrqu->encoding.length==0 && (wrqu->encoding.flags >>8) == 0x8 ){
745 printk("===>1\n");
746 //write_nic_byte(dev, SECR, 7);
747 EnableHWSecurityConfig8192(dev);
748 //copy wpa config from default key(key0~key3) to broadcast key(key5)
749 //
750 key_idx = (wrqu->encoding.flags & 0xf)-1 ;
751 write_cam(dev, (4*6), 0xffff0000|read_cam(dev, key_idx*6) );
752 write_cam(dev, (4*6)+1, 0xffffffff);
753 write_cam(dev, (4*6)+2, read_cam(dev, (key_idx*6)+2) );
754 write_cam(dev, (4*6)+3, read_cam(dev, (key_idx*6)+3) );
755 write_cam(dev, (4*6)+4, read_cam(dev, (key_idx*6)+4) );
756 write_cam(dev, (4*6)+5, read_cam(dev, (key_idx*6)+5) );
757 }
758 #endif
759
760 priv->ieee80211->wx_set_enc = 0;
761
762 return ret;
763 }
764
765
766 static int r8192_wx_set_scan_type(struct net_device *dev, struct iw_request_info *aa, union
767 iwreq_data *wrqu, char *p){
768
769 struct r8192_priv *priv = ieee80211_priv(dev);
770 int *parms=(int*)p;
771 int mode=parms[0];
772
773 priv->ieee80211->active_scan = mode;
774
775 return 1;
776 }
777
778
779
780 static int r8192_wx_set_retry(struct net_device *dev,
781 struct iw_request_info *info,
782 union iwreq_data *wrqu, char *extra)
783 {
784 struct r8192_priv *priv = ieee80211_priv(dev);
785 int err = 0;
786
787 if (priv->bHwRadioOff)
788 return 0;
789
790 down(&priv->wx_sem);
791
792 if (wrqu->retry.flags & IW_RETRY_LIFETIME ||
793 wrqu->retry.disabled){
794 err = -EINVAL;
795 goto exit;
796 }
797 if (!(wrqu->retry.flags & IW_RETRY_LIMIT)){
798 err = -EINVAL;
799 goto exit;
800 }
801
802 if(wrqu->retry.value > R8180_MAX_RETRY){
803 err= -EINVAL;
804 goto exit;
805 }
806 if (wrqu->retry.flags & IW_RETRY_MAX) {
807 priv->retry_rts = wrqu->retry.value;
808 DMESG("Setting retry for RTS/CTS data to %d", wrqu->retry.value);
809
810 }else {
811 priv->retry_data = wrqu->retry.value;
812 DMESG("Setting retry for non RTS/CTS data to %d", wrqu->retry.value);
813 }
814
815 /* FIXME !
816 * We might try to write directly the TX config register
817 * or to restart just the (R)TX process.
818 * I'm unsure if whole reset is really needed
819 */
820
821 rtl8192_commit(dev);
822 /*
823 if(priv->up){
824 rtl8180_rtx_disable(dev);
825 rtl8180_rx_enable(dev);
826 rtl8180_tx_enable(dev);
827
828 }
829 */
830 exit:
831 up(&priv->wx_sem);
832
833 return err;
834 }
835
836 static int r8192_wx_get_retry(struct net_device *dev,
837 struct iw_request_info *info,
838 union iwreq_data *wrqu, char *extra)
839 {
840 struct r8192_priv *priv = ieee80211_priv(dev);
841
842
843 wrqu->retry.disabled = 0; /* can't be disabled */
844
845 if ((wrqu->retry.flags & IW_RETRY_TYPE) ==
846 IW_RETRY_LIFETIME)
847 return -EINVAL;
848
849 if (wrqu->retry.flags & IW_RETRY_MAX) {
850 wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MAX;
851 wrqu->retry.value = priv->retry_rts;
852 } else {
853 wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MIN;
854 wrqu->retry.value = priv->retry_data;
855 }
856 //DMESG("returning %d",wrqu->retry.value);
857
858
859 return 0;
860 }
861
862 static int r8192_wx_get_sens(struct net_device *dev,
863 struct iw_request_info *info,
864 union iwreq_data *wrqu, char *extra)
865 {
866 struct r8192_priv *priv = ieee80211_priv(dev);
867 if(priv->rf_set_sens == NULL)
868 return -1; /* we have not this support for this radio */
869 wrqu->sens.value = priv->sens;
870 return 0;
871 }
872
873
874 static int r8192_wx_set_sens(struct net_device *dev,
875 struct iw_request_info *info,
876 union iwreq_data *wrqu, char *extra)
877 {
878
879 struct r8192_priv *priv = ieee80211_priv(dev);
880
881 short err = 0;
882
883 if (priv->bHwRadioOff)
884 return 0;
885
886 down(&priv->wx_sem);
887 //DMESG("attempt to set sensivity to %ddb",wrqu->sens.value);
888 if(priv->rf_set_sens == NULL) {
889 err= -1; /* we have not this support for this radio */
890 goto exit;
891 }
892 if(priv->rf_set_sens(dev, wrqu->sens.value) == 0)
893 priv->sens = wrqu->sens.value;
894 else
895 err= -EINVAL;
896
897 exit:
898 up(&priv->wx_sem);
899
900 return err;
901 }
902
903 #if (WIRELESS_EXT >= 18)
904 static int r8192_wx_set_enc_ext(struct net_device *dev,
905 struct iw_request_info *info,
906 union iwreq_data *wrqu, char *extra)
907 {
908 int ret=0;
909 struct r8192_priv *priv = ieee80211_priv(dev);
910 struct ieee80211_device* ieee = priv->ieee80211;
911
912 if (priv->bHwRadioOff)
913 return 0;
914
915 down(&priv->wx_sem);
916
917 priv->ieee80211->wx_set_enc = 1;
918
919 #ifdef ENABLE_IPS
920 down(&priv->ieee80211->ips_sem);
921 IPSLeave(dev);
922 up(&priv->ieee80211->ips_sem);
923 #endif
924
925 ret = ieee80211_wx_set_encode_ext(ieee, info, wrqu, extra);
926
927 {
928 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
929 u8 zero[6] = {0};
930 u32 key[4] = {0};
931 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
932 struct iw_point *encoding = &wrqu->encoding;
933 #if 0
934 static u8 CAM_CONST_ADDR[4][6] = {
935 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
936 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
937 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
938 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
939 #endif
940 u8 idx = 0, alg = 0, group = 0;
941 if ((encoding->flags & IW_ENCODE_DISABLED) ||
942 ext->alg == IW_ENCODE_ALG_NONE) //none is not allowed to use hwsec WB 2008.07.01
943 {
944 ieee->pairwise_key_type = ieee->group_key_type = KEY_TYPE_NA;
945 CamResetAllEntry(dev);
946 goto end_hw_sec;
947 }
948 alg = (ext->alg == IW_ENCODE_ALG_CCMP)?KEY_TYPE_CCMP:ext->alg; // as IW_ENCODE_ALG_CCMP is defined to be 3 and KEY_TYPE_CCMP is defined to 4;
949 idx = encoding->flags & IW_ENCODE_INDEX;
950 if (idx)
951 idx --;
952 group = ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY;
953
954 if ((!group) || (IW_MODE_ADHOC == ieee->iw_mode) || (alg == KEY_TYPE_WEP40))
955 {
956 if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40) )
957 alg = KEY_TYPE_WEP104;
958 ieee->pairwise_key_type = alg;
959 EnableHWSecurityConfig8192(dev);
960 }
961 memcpy((u8*)key, ext->key, 16); //we only get 16 bytes key.why? WB 2008.7.1
962
963 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode !=2) )
964 {
965 if (ext->key_len == 13)
966 ieee->pairwise_key_type = alg = KEY_TYPE_WEP104;
967 setKey( dev,
968 idx,//EntryNo
969 idx, //KeyIndex
970 alg, //KeyType
971 zero, //MacAddr
972 0, //DefaultKey
973 key); //KeyContent
974 }
975 else if (group)
976 {
977 ieee->group_key_type = alg;
978 setKey( dev,
979 idx,//EntryNo
980 idx, //KeyIndex
981 alg, //KeyType
982 broadcast_addr, //MacAddr
983 0, //DefaultKey
984 key); //KeyContent
985 }
986 else //pairwise key
987 {
988 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
989 write_nic_byte(dev, 0x173, 1); //fix aes bug
990 }
991 setKey( dev,
992 4,//EntryNo
993 idx, //KeyIndex
994 alg, //KeyType
995 (u8*)ieee->ap_mac_addr, //MacAddr
996 0, //DefaultKey
997 key); //KeyContent
998 }
999
1000
1001 }
1002
1003 end_hw_sec:
1004 priv->ieee80211->wx_set_enc = 0;
1005 up(&priv->wx_sem);
1006 return ret;
1007
1008 }
1009 static int r8192_wx_set_auth(struct net_device *dev,
1010 struct iw_request_info *info,
1011 union iwreq_data *data, char *extra)
1012 {
1013 int ret=0;
1014 //printk("====>%s()\n", __FUNCTION__);
1015 struct r8192_priv *priv = ieee80211_priv(dev);
1016
1017 if (priv->bHwRadioOff)
1018 return 0;
1019
1020 down(&priv->wx_sem);
1021 ret = ieee80211_wx_set_auth(priv->ieee80211, info, &(data->param), extra);
1022 up(&priv->wx_sem);
1023 return ret;
1024 }
1025
1026 static int r8192_wx_set_mlme(struct net_device *dev,
1027 struct iw_request_info *info,
1028 union iwreq_data *wrqu, char *extra)
1029 {
1030 //printk("====>%s()\n", __FUNCTION__);
1031
1032 int ret=0;
1033 struct r8192_priv *priv = ieee80211_priv(dev);
1034
1035 if (priv->bHwRadioOff)
1036 return 0;
1037
1038 down(&priv->wx_sem);
1039 ret = ieee80211_wx_set_mlme(priv->ieee80211, info, wrqu, extra);
1040 up(&priv->wx_sem);
1041 return ret;
1042 }
1043 #endif
1044 static int r8192_wx_set_gen_ie(struct net_device *dev,
1045 struct iw_request_info *info,
1046 union iwreq_data *data, char *extra)
1047 {
1048 //printk("====>%s(), len:%d\n", __FUNCTION__, data->length);
1049 int ret=0;
1050 struct r8192_priv *priv = ieee80211_priv(dev);
1051
1052 if (priv->bHwRadioOff)
1053 return 0;
1054
1055 down(&priv->wx_sem);
1056 ret = ieee80211_wx_set_gen_ie(priv->ieee80211, extra, data->data.length);
1057 up(&priv->wx_sem);
1058 //printk("<======%s(), ret:%d\n", __FUNCTION__, ret);
1059 return ret;
1060 }
1061
1062 static int dummy(struct net_device *dev, struct iw_request_info *a,
1063 union iwreq_data *wrqu,char *b)
1064 {
1065 return -1;
1066 }
1067
1068 // check ac/dc status with the help of user space application */
1069 static int r8192_wx_adapter_power_status(struct net_device *dev,
1070 struct iw_request_info *info,
1071 union iwreq_data *wrqu, char *extra)
1072 {
1073 struct r8192_priv *priv = ieee80211_priv(dev);
1074 #ifdef ENABLE_LPS
1075 PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
1076 struct ieee80211_device* ieee = priv->ieee80211;
1077 #endif
1078 down(&priv->wx_sem);
1079
1080 #ifdef ENABLE_LPS
1081 RT_TRACE(COMP_POWER, "%s(): %s\n",__FUNCTION__, (*extra == 6)?"DC power":"AC power");
1082 // ieee->ps shall not be set under DC mode, otherwise it conflict
1083 // with Leisure power save mode setting.
1084 //
1085 if(*extra || priv->force_lps) {
1086 priv->ps_force = false;
1087 pPSC->bLeisurePs = true;
1088 } else {
1089 //LZM for PS-Poll AID issue. 090429
1090 if(priv->ieee80211->state == IEEE80211_LINKED)
1091 LeisurePSLeave(dev);
1092
1093 priv->ps_force = true;
1094 pPSC->bLeisurePs = false;
1095 ieee->ps = *extra;
1096 }
1097
1098 #endif
1099 up(&priv->wx_sem);
1100 return 0;
1101
1102 }
1103
1104
1105 static iw_handler r8192_wx_handlers[] =
1106 {
1107 NULL, /* SIOCSIWCOMMIT */
1108 r8192_wx_get_name, /* SIOCGIWNAME */
1109 dummy, /* SIOCSIWNWID */
1110 dummy, /* SIOCGIWNWID */
1111 r8192_wx_set_freq, /* SIOCSIWFREQ */
1112 r8192_wx_get_freq, /* SIOCGIWFREQ */
1113 r8192_wx_set_mode, /* SIOCSIWMODE */
1114 r8192_wx_get_mode, /* SIOCGIWMODE */
1115 r8192_wx_set_sens, /* SIOCSIWSENS */
1116 r8192_wx_get_sens, /* SIOCGIWSENS */
1117 NULL, /* SIOCSIWRANGE */
1118 rtl8180_wx_get_range, /* SIOCGIWRANGE */
1119 NULL, /* SIOCSIWPRIV */
1120 NULL, /* SIOCGIWPRIV */
1121 NULL, /* SIOCSIWSTATS */
1122 NULL, /* SIOCGIWSTATS */
1123 dummy, /* SIOCSIWSPY */
1124 dummy, /* SIOCGIWSPY */
1125 NULL, /* SIOCGIWTHRSPY */
1126 NULL, /* SIOCWIWTHRSPY */
1127 r8192_wx_set_wap, /* SIOCSIWAP */
1128 r8192_wx_get_wap, /* SIOCGIWAP */
1129 #if (WIRELESS_EXT >= 18)
1130 r8192_wx_set_mlme, /* MLME-- */
1131 #else
1132 NULL,
1133 #endif
1134 dummy, /* SIOCGIWAPLIST -- depricated */
1135 r8192_wx_set_scan, /* SIOCSIWSCAN */
1136 r8192_wx_get_scan, /* SIOCGIWSCAN */
1137 r8192_wx_set_essid, /* SIOCSIWESSID */
1138 r8192_wx_get_essid, /* SIOCGIWESSID */
1139 dummy, /* SIOCSIWNICKN */
1140 dummy, /* SIOCGIWNICKN */
1141 NULL, /* -- hole -- */
1142 NULL, /* -- hole -- */
1143 r8192_wx_set_rate, /* SIOCSIWRATE */
1144 r8192_wx_get_rate, /* SIOCGIWRATE */
1145 r8192_wx_set_rts, /* SIOCSIWRTS */
1146 r8192_wx_get_rts, /* SIOCGIWRTS */
1147 r8192_wx_set_frag, /* SIOCSIWFRAG */
1148 r8192_wx_get_frag, /* SIOCGIWFRAG */
1149 dummy, /* SIOCSIWTXPOW */
1150 dummy, /* SIOCGIWTXPOW */
1151 r8192_wx_set_retry, /* SIOCSIWRETRY */
1152 r8192_wx_get_retry, /* SIOCGIWRETRY */
1153 r8192_wx_set_enc, /* SIOCSIWENCODE */
1154 r8192_wx_get_enc, /* SIOCGIWENCODE */
1155 r8192_wx_set_power, /* SIOCSIWPOWER */
1156 r8192_wx_get_power, /* SIOCGIWPOWER */
1157 NULL, /*---hole---*/
1158 NULL, /*---hole---*/
1159 r8192_wx_set_gen_ie,//NULL, /* SIOCSIWGENIE */
1160 NULL, /* SIOCSIWGENIE */
1161 #if (WIRELESS_EXT >= 18)
1162 r8192_wx_set_auth,//NULL, /* SIOCSIWAUTH */
1163 NULL,//r8192_wx_get_auth,//NULL, /* SIOCSIWAUTH */
1164 r8192_wx_set_enc_ext, /* SIOCSIWENCODEEXT */
1165 #else
1166 NULL,
1167 NULL,
1168 NULL,
1169 #endif
1170 NULL,//r8192_wx_get_enc_ext,//NULL, /* SIOCSIWENCODEEXT */
1171 NULL, /* SIOCSIWPMKSA */
1172 NULL, /*---hole---*/
1173
1174 };
1175
1176
1177 static const struct iw_priv_args r8192_private_args[] = {
1178
1179 {
1180 SIOCIWFIRSTPRIV + 0x0,
1181 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "badcrc"
1182 },
1183
1184 {
1185 SIOCIWFIRSTPRIV + 0x1,
1186 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "activescan"
1187
1188 },
1189 {
1190 SIOCIWFIRSTPRIV + 0x2,
1191 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "rawtx"
1192 }
1193 ,
1194 {
1195 SIOCIWFIRSTPRIV + 0x3,
1196 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "forcereset"
1197
1198 }
1199 ,
1200 {
1201 SIOCIWFIRSTPRIV + 0x4,
1202 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED|1, IW_PRIV_TYPE_NONE,
1203 "set_power"
1204 }
1205
1206 };
1207
1208
1209 static iw_handler r8192_private_handler[] = {
1210 r8192_wx_set_crcmon, /*SIOCIWSECONDPRIV*/
1211 r8192_wx_set_scan_type,
1212 r8192_wx_set_rawtx,
1213 r8192_wx_force_reset,
1214 r8192_wx_adapter_power_status,
1215 };
1216
1217 //#if WIRELESS_EXT >= 17
1218 struct iw_statistics *r8192_get_wireless_stats(struct net_device *dev)
1219 {
1220 struct r8192_priv *priv = ieee80211_priv(dev);
1221 struct ieee80211_device* ieee = priv->ieee80211;
1222 struct iw_statistics* wstats = &priv->wstats;
1223 int tmp_level = 0;
1224 int tmp_qual = 0;
1225 int tmp_noise = 0;
1226 if(ieee->state < IEEE80211_LINKED)
1227 {
1228 wstats->qual.qual = 0;
1229 wstats->qual.level = 0;
1230 wstats->qual.noise = 0;
1231 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1232 return wstats;
1233 }
1234
1235 tmp_level = (&ieee->current_network)->stats.rssi;
1236 tmp_qual = (&ieee->current_network)->stats.signal;
1237 tmp_noise = (&ieee->current_network)->stats.noise;
1238 //printk("level:%d, qual:%d, noise:%d\n", tmp_level, tmp_qual, tmp_noise);
1239
1240 wstats->qual.level = tmp_level;
1241 wstats->qual.qual = tmp_qual;
1242 wstats->qual.noise = tmp_noise;
1243 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1244 return wstats;
1245 }
1246 //#endif
1247
1248
1249 struct iw_handler_def r8192_wx_handlers_def={
1250 .standard = r8192_wx_handlers,
1251 .num_standard = sizeof(r8192_wx_handlers) / sizeof(iw_handler),
1252 .private = r8192_private_handler,
1253 .num_private = sizeof(r8192_private_handler) / sizeof(iw_handler),
1254 .num_private_args = sizeof(r8192_private_args) / sizeof(struct iw_priv_args),
1255 #if WIRELESS_EXT >= 17
1256 .get_wireless_stats = r8192_get_wireless_stats,
1257 #endif
1258 .private_args = (struct iw_priv_args *)r8192_private_args,
1259 };
WandBoard kernel