1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#ifndef CONFIG_FORCE_HARD_FLOAT
28double __floatsidf (int i) { return i; }
29unsigned int __fixunsdfsi (double d) { return d; }
30double __adddf3(double a, double b) { return a+b; }
31double __addsf3(float a, float b) { return a+b; }
32double __subdf3(double a, double b) { return a-b; }
33double __extendsfdf2(float a) {return a;}
34#endif
35
36#undef LOOP_TEST
37#undef DUMP_RX
38#undef DUMP_TX
39#undef DEBUG_TX_DESC2
40#undef RX_DONT_PASS_UL
41#undef DEBUG_EPROM
42#undef DEBUG_RX_VERBOSE
43#undef DUMMY_RX
44#undef DEBUG_ZERO_RX
45#undef DEBUG_RX_SKB
46#undef DEBUG_TX_FRAG
47#undef DEBUG_RX_FRAG
48#undef DEBUG_TX_FILLDESC
49#undef DEBUG_TX
50#undef DEBUG_IRQ
51#undef DEBUG_RX
52#undef DEBUG_RXALLOC
53#undef DEBUG_REGISTERS
54#undef DEBUG_RING
55#undef DEBUG_IRQ_TASKLET
56#undef DEBUG_TX_ALLOC
57#undef DEBUG_TX_DESC
58
59#define CONFIG_RTL8192_IO_MAP
60
61#include <asm/uaccess.h>
62#include "r8192U_hw.h"
63#include "r8192U.h"
64#include "r8190_rtl8256.h"
65#include "r8180_93cx6.h"
66#include "r8192U_wx.h"
67#include "r819xU_phy.h"
68#include "r819xU_phyreg.h"
69#include "r819xU_cmdpkt.h"
70#include "r8192U_dm.h"
71
72#include <linux/usb.h>
73#include <linux/slab.h>
74
75
76#ifdef CONFIG_RTL8192_PM
77#include "r8192_pm.h"
78#endif
79
80#include "dot11d.h"
81
82u32 rt_global_debug_component = \
83
84
85
86
87
88
89
90
91
92
93
94 COMP_DOWN |
95
96
97 COMP_SEC |
98
99
100
101 COMP_ERR ;
102
103#define TOTAL_CAM_ENTRY 32
104#define CAM_CONTENT_COUNT 8
105
106static const struct usb_device_id rtl8192_usb_id_tbl[] = {
107
108 {USB_DEVICE(0x0bda, 0x8192)},
109 {USB_DEVICE(0x0bda, 0x8709)},
110
111 {USB_DEVICE(0x07aa, 0x0043)},
112
113 {USB_DEVICE(0x050d, 0x805E)},
114
115 {USB_DEVICE(0x0df6, 0x0031)},
116
117 {USB_DEVICE(0x1740, 0x9201)},
118
119 {USB_DEVICE(0x2001, 0x3301)},
120
121 {USB_DEVICE(0x5a57, 0x0290)},
122
123 {USB_DEVICE(0x043e, 0x7a01)},
124 {}
125};
126
127MODULE_LICENSE("GPL");
128MODULE_VERSION("V 1.1");
129MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
130MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
131
132static char* ifname = "wlan%d";
133static int hwwep = 1;
134static int channels = 0x3fff;
135
136
137
138module_param(ifname, charp, S_IRUGO|S_IWUSR );
139
140module_param(hwwep,int, S_IRUGO|S_IWUSR);
141module_param(channels,int, S_IRUGO|S_IWUSR);
142
143MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
144
145MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
146MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
147
148static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
149 const struct usb_device_id *id);
150static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
151
152
153static struct usb_driver rtl8192_usb_driver = {
154 .name = RTL819xU_MODULE_NAME,
155 .id_table = rtl8192_usb_id_tbl,
156 .probe = rtl8192_usb_probe,
157 .disconnect = rtl8192_usb_disconnect,
158#ifdef CONFIG_RTL8192_PM
159 .suspend = rtl8192_suspend,
160 .resume = rtl8192_resume,
161#else
162 .suspend = NULL,
163 .resume = NULL,
164#endif
165};
166
167
168typedef struct _CHANNEL_LIST
169{
170 u8 Channel[32];
171 u8 Len;
172}CHANNEL_LIST, *PCHANNEL_LIST;
173
174static CHANNEL_LIST ChannelPlan[] = {
175 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24},
176 {{1,2,3,4,5,6,7,8,9,10,11},11},
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21},
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},
183 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},
184 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22},
185 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14}
186};
187
188static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
189{
190 int i, max_chan=-1, min_chan=-1;
191 struct ieee80211_device* ieee = priv->ieee80211;
192 switch (channel_plan)
193 {
194 case COUNTRY_CODE_FCC:
195 case COUNTRY_CODE_IC:
196 case COUNTRY_CODE_ETSI:
197 case COUNTRY_CODE_SPAIN:
198 case COUNTRY_CODE_FRANCE:
199 case COUNTRY_CODE_MKK:
200 case COUNTRY_CODE_MKK1:
201 case COUNTRY_CODE_ISRAEL:
202 case COUNTRY_CODE_TELEC:
203 case COUNTRY_CODE_MIC:
204 {
205 Dot11d_Init(ieee);
206 ieee->bGlobalDomain = false;
207
208 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
209 {
210 min_chan = 1;
211 max_chan = 14;
212 }
213 else
214 {
215 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
216 }
217 if (ChannelPlan[channel_plan].Len != 0){
218
219 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
220
221 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
222 {
223 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
224 break;
225 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
226 }
227 }
228 break;
229 }
230 case COUNTRY_CODE_GLOBAL_DOMAIN:
231 {
232 GET_DOT11D_INFO(ieee)->bEnabled = 0;
233 Dot11d_Reset(ieee);
234 ieee->bGlobalDomain = true;
235 break;
236 }
237 default:
238 break;
239 }
240 return;
241}
242
243
244#define rx_hal_is_cck_rate(_pdrvinfo)\
245 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
246 _pdrvinfo->RxRate == DESC90_RATE2M ||\
247 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
248 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
249 !_pdrvinfo->RxHT\
250
251
252void CamResetAllEntry(struct net_device *dev)
253{
254 u32 ulcommand = 0;
255
256
257
258
259
260
261
262
263
264 ulcommand |= BIT31|BIT30;
265 write_nic_dword(dev, RWCAM, ulcommand);
266
267}
268
269
270void write_cam(struct net_device *dev, u8 addr, u32 data)
271{
272 write_nic_dword(dev, WCAMI, data);
273 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
274}
275
276u32 read_cam(struct net_device *dev, u8 addr)
277{
278 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
279 return read_nic_dword(dev, 0xa8);
280}
281
282void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
283{
284 int status;
285 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
286 struct usb_device *udev = priv->udev;
287
288 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
289 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
290 indx|0xfe00, 0, &data, 1, HZ / 2);
291
292 if (status < 0)
293 {
294 printk("write_nic_byte_E TimeOut! status:%d\n", status);
295 }
296}
297
298u8 read_nic_byte_E(struct net_device *dev, int indx)
299{
300 int status;
301 u8 data;
302 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
303 struct usb_device *udev = priv->udev;
304
305 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
306 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
307 indx|0xfe00, 0, &data, 1, HZ / 2);
308
309 if (status < 0)
310 {
311 printk("read_nic_byte_E TimeOut! status:%d\n", status);
312 }
313
314 return data;
315}
316
317void write_nic_byte(struct net_device *dev, int indx, u8 data)
318{
319 int status;
320
321 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
322 struct usb_device *udev = priv->udev;
323
324 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
325 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
326 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
327
328 if (status < 0)
329 {
330 printk("write_nic_byte TimeOut! status:%d\n", status);
331 }
332
333
334}
335
336
337void write_nic_word(struct net_device *dev, int indx, u16 data)
338{
339
340 int status;
341
342 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
343 struct usb_device *udev = priv->udev;
344
345 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
346 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
347 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
348
349 if (status < 0)
350 {
351 printk("write_nic_word TimeOut! status:%d\n", status);
352 }
353
354}
355
356
357void write_nic_dword(struct net_device *dev, int indx, u32 data)
358{
359
360 int status;
361
362 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
363 struct usb_device *udev = priv->udev;
364
365 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
366 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
367 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
368
369
370 if (status < 0)
371 {
372 printk("write_nic_dword TimeOut! status:%d\n", status);
373 }
374
375}
376
377
378
379u8 read_nic_byte(struct net_device *dev, int indx)
380{
381 u8 data;
382 int status;
383 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
384 struct usb_device *udev = priv->udev;
385
386 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
387 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
388 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
389
390 if (status < 0)
391 {
392 printk("read_nic_byte TimeOut! status:%d\n", status);
393 }
394
395 return data;
396}
397
398
399
400u16 read_nic_word(struct net_device *dev, int indx)
401{
402 u16 data;
403 int status;
404 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
405 struct usb_device *udev = priv->udev;
406
407 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
408 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
409 (indx&0xff)|0xff00, (indx>>8)&0x0f,
410 &data, 2, HZ / 2);
411
412 if (status < 0)
413 printk("read_nic_word TimeOut! status:%d\n", status);
414
415 return data;
416}
417
418u16 read_nic_word_E(struct net_device *dev, int indx)
419{
420 u16 data;
421 int status;
422 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
423 struct usb_device *udev = priv->udev;
424
425 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
426 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
427 indx|0xfe00, 0, &data, 2, HZ / 2);
428
429 if (status < 0)
430 printk("read_nic_word TimeOut! status:%d\n", status);
431
432 return data;
433}
434
435u32 read_nic_dword(struct net_device *dev, int indx)
436{
437 u32 data;
438 int status;
439
440
441 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
442 struct usb_device *udev = priv->udev;
443
444 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
445 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
446 (indx&0xff)|0xff00, (indx>>8)&0x0f,
447 &data, 4, HZ / 2);
448
449
450
451
452
453
454 if (status < 0)
455 printk("read_nic_dword TimeOut! status:%d\n", status);
456
457 return data;
458}
459
460
461
462
463
464
465inline void force_pci_posting(struct net_device *dev)
466{
467}
468
469static struct net_device_stats *rtl8192_stats(struct net_device *dev);
470void rtl8192_commit(struct net_device *dev);
471
472void rtl8192_restart(struct work_struct *work);
473
474void watch_dog_timer_callback(unsigned long data);
475
476
477
478
479
480
481static struct proc_dir_entry *rtl8192_proc;
482
483static int proc_get_stats_ap(char *page, char **start, off_t offset, int count,
484 int *eof, void *data)
485{
486 struct net_device *dev = data;
487 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
488 struct ieee80211_device *ieee = priv->ieee80211;
489 struct ieee80211_network *target;
490
491 int len = 0;
492
493 list_for_each_entry(target, &ieee->network_list, list) {
494
495 len += snprintf(page + len, count - len, "%s ", target->ssid);
496
497 if (target->wpa_ie_len > 0 || target->rsn_ie_len > 0)
498 len += snprintf(page + len, count - len, "WPA\n");
499 else
500 len += snprintf(page + len, count - len, "non_WPA\n");
501 }
502
503 *eof = 1;
504 return len;
505}
506
507static int proc_get_registers(char *page, char **start,
508 off_t offset, int count,
509 int *eof, void *data)
510{
511 struct net_device *dev = data;
512
513
514 int len = 0;
515 int i,n;
516
517 int max=0xff;
518
519
520len += snprintf(page + len, count - len,
521 "\n####################page 0##################\n ");
522
523 for(n=0;n<=max;)
524 {
525
526 len += snprintf(page + len, count - len,
527 "\nD: %2x > ",n);
528
529 for(i=0;i<16 && n<=max;i++,n++)
530 len += snprintf(page + len, count - len,
531 "%2x ",read_nic_byte(dev,0x000|n));
532
533
534 }
535len += snprintf(page + len, count - len,
536 "\n####################page 1##################\n ");
537 for(n=0;n<=max;)
538 {
539
540 len += snprintf(page + len, count - len,
541 "\nD: %2x > ",n);
542
543 for(i=0;i<16 && n<=max;i++,n++)
544 len += snprintf(page + len, count - len,
545 "%2x ",read_nic_byte(dev,0x100|n));
546
547
548 }
549len += snprintf(page + len, count - len,
550 "\n####################page 3##################\n ");
551 for(n=0;n<=max;)
552 {
553
554 len += snprintf(page + len, count - len,
555 "\nD: %2x > ",n);
556
557 for(i=0;i<16 && n<=max;i++,n++)
558 len += snprintf(page + len, count - len,
559 "%2x ",read_nic_byte(dev,0x300|n));
560
561
562 }
563
564
565 len += snprintf(page + len, count - len,"\n");
566 *eof = 1;
567 return len;
568
569}
570
571
572
573
574
575static int proc_get_stats_tx(char *page, char **start,
576 off_t offset, int count,
577 int *eof, void *data)
578{
579 struct net_device *dev = data;
580 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
581
582 int len = 0;
583
584 len += snprintf(page + len, count - len,
585 "TX VI priority ok int: %lu\n"
586 "TX VI priority error int: %lu\n"
587 "TX VO priority ok int: %lu\n"
588 "TX VO priority error int: %lu\n"
589 "TX BE priority ok int: %lu\n"
590 "TX BE priority error int: %lu\n"
591 "TX BK priority ok int: %lu\n"
592 "TX BK priority error int: %lu\n"
593 "TX MANAGE priority ok int: %lu\n"
594 "TX MANAGE priority error int: %lu\n"
595 "TX BEACON priority ok int: %lu\n"
596 "TX BEACON priority error int: %lu\n"
597
598
599 "TX queue resume: %lu\n"
600 "TX queue stopped?: %d\n"
601 "TX fifo overflow: %lu\n"
602
603 "TX VI queue: %d\n"
604 "TX VO queue: %d\n"
605 "TX BE queue: %d\n"
606 "TX BK queue: %d\n"
607
608 "TX VI dropped: %lu\n"
609 "TX VO dropped: %lu\n"
610 "TX BE dropped: %lu\n"
611 "TX BK dropped: %lu\n"
612 "TX total data packets %lu\n",
613
614 priv->stats.txviokint,
615 priv->stats.txvierr,
616 priv->stats.txvookint,
617 priv->stats.txvoerr,
618 priv->stats.txbeokint,
619 priv->stats.txbeerr,
620 priv->stats.txbkokint,
621 priv->stats.txbkerr,
622 priv->stats.txmanageokint,
623 priv->stats.txmanageerr,
624 priv->stats.txbeaconokint,
625 priv->stats.txbeaconerr,
626
627
628 priv->stats.txresumed,
629 netif_queue_stopped(dev),
630 priv->stats.txoverflow,
631
632 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
633 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
634 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
635 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
636
637 priv->stats.txvidrop,
638 priv->stats.txvodrop,
639 priv->stats.txbedrop,
640 priv->stats.txbkdrop,
641 priv->stats.txdatapkt
642
643 );
644
645 *eof = 1;
646 return len;
647}
648
649
650
651static int proc_get_stats_rx(char *page, char **start,
652 off_t offset, int count,
653 int *eof, void *data)
654{
655 struct net_device *dev = data;
656 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
657
658 int len = 0;
659
660 len += snprintf(page + len, count - len,
661 "RX packets: %lu\n"
662 "RX urb status error: %lu\n"
663 "RX invalid urb error: %lu\n",
664 priv->stats.rxoktotal,
665 priv->stats.rxstaterr,
666 priv->stats.rxurberr);
667
668 *eof = 1;
669 return len;
670}
671void rtl8192_proc_module_init(void)
672{
673 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
674 rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, init_net.proc_net);
675}
676
677
678void rtl8192_proc_module_remove(void)
679{
680 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
681}
682
683
684void rtl8192_proc_remove_one(struct net_device *dev)
685{
686 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
687
688
689 if (priv->dir_dev) {
690
691 remove_proc_entry("stats-tx", priv->dir_dev);
692 remove_proc_entry("stats-rx", priv->dir_dev);
693
694 remove_proc_entry("stats-ap", priv->dir_dev);
695 remove_proc_entry("registers", priv->dir_dev);
696
697
698
699 remove_proc_entry("wlan0", rtl8192_proc);
700 priv->dir_dev = NULL;
701 }
702}
703
704
705void rtl8192_proc_init_one(struct net_device *dev)
706{
707 struct proc_dir_entry *e;
708 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
709 priv->dir_dev = create_proc_entry(dev->name,
710 S_IFDIR | S_IRUGO | S_IXUGO,
711 rtl8192_proc);
712 if (!priv->dir_dev) {
713 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
714 dev->name);
715 return;
716 }
717 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
718 priv->dir_dev, proc_get_stats_rx, dev);
719
720 if (!e) {
721 RT_TRACE(COMP_ERR,"Unable to initialize "
722 "/proc/net/rtl8192/%s/stats-rx\n",
723 dev->name);
724 }
725
726
727 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
728 priv->dir_dev, proc_get_stats_tx, dev);
729
730 if (!e) {
731 RT_TRACE(COMP_ERR, "Unable to initialize "
732 "/proc/net/rtl8192/%s/stats-tx\n",
733 dev->name);
734 }
735
736 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
737 priv->dir_dev, proc_get_stats_ap, dev);
738
739 if (!e) {
740 RT_TRACE(COMP_ERR, "Unable to initialize "
741 "/proc/net/rtl8192/%s/stats-ap\n",
742 dev->name);
743 }
744
745 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
746 priv->dir_dev, proc_get_registers, dev);
747 if (!e) {
748 RT_TRACE(COMP_ERR, "Unable to initialize "
749 "/proc/net/rtl8192/%s/registers\n",
750 dev->name);
751 }
752}
753
754
755
756
757
758void print_buffer(u32 *buffer, int len)
759{
760 int i;
761 u8 *buf =(u8*)buffer;
762
763 printk("ASCII BUFFER DUMP (len: %x):\n",len);
764
765 for(i=0;i<len;i++)
766 printk("%c",buf[i]);
767
768 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
769
770 for(i=0;i<len;i++)
771 printk("%x",buf[i]);
772
773 printk("\n");
774}
775
776
777short check_nic_enough_desc(struct net_device *dev,int queue_index)
778{
779 struct r8192_priv *priv = ieee80211_priv(dev);
780 int used = atomic_read(&priv->tx_pending[queue_index]);
781
782 return (used < MAX_TX_URB);
783}
784
785void tx_timeout(struct net_device *dev)
786{
787 struct r8192_priv *priv = ieee80211_priv(dev);
788
789
790 schedule_work(&priv->reset_wq);
791
792}
793
794
795
796void dump_eprom(struct net_device *dev)
797{
798 int i;
799 for(i=0; i<63; i++)
800 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
801}
802
803
804void rtl8192_dump_reg(struct net_device *dev)
805{
806 int i;
807 int n;
808 int max=0x1ff;
809
810 RT_TRACE(COMP_PHY, "Dumping NIC register map");
811
812 for(n=0;n<=max;)
813 {
814 printk( "\nD: %2x> ", n);
815 for(i=0;i<16 && n<=max;i++,n++)
816 printk("%2x ",read_nic_byte(dev,n));
817 }
818 printk("\n");
819}
820
821
822
823
824
825
826void rtl8192_set_mode(struct net_device *dev,int mode)
827{
828 u8 ecmd;
829 ecmd=read_nic_byte(dev, EPROM_CMD);
830 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
831 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
832 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
833 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
834 write_nic_byte(dev, EPROM_CMD, ecmd);
835}
836
837
838void rtl8192_update_msr(struct net_device *dev)
839{
840 struct r8192_priv *priv = ieee80211_priv(dev);
841 u8 msr;
842
843 msr = read_nic_byte(dev, MSR);
844 msr &= ~ MSR_LINK_MASK;
845
846
847
848
849
850
851 if (priv->ieee80211->state == IEEE80211_LINKED){
852
853 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
854 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
855 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
856 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
857 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
858 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
859
860 }else
861 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
862
863 write_nic_byte(dev, MSR, msr);
864}
865
866void rtl8192_set_chan(struct net_device *dev,short ch)
867{
868 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
869
870 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
871 priv->chan=ch;
872
873
874
875
876
877
878
879#ifndef LOOP_TEST
880
881
882
883
884 if (priv->rf_set_chan)
885 priv->rf_set_chan(dev,priv->chan);
886 mdelay(10);
887
888#endif
889}
890
891static void rtl8192_rx_isr(struct urb *urb);
892
893
894u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
895{
896
897#ifdef USB_RX_AGGREGATION_SUPPORT
898 if (pstats->bisrxaggrsubframe)
899 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
900 + pstats->RxBufShift + 8);
901 else
902#endif
903 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
904 + pstats->RxBufShift);
905
906}
907static int rtl8192_rx_initiate(struct net_device*dev)
908{
909 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
910 struct urb *entry;
911 struct sk_buff *skb;
912 struct rtl8192_rx_info *info;
913
914
915 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
916 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
917 if (!skb)
918 break;
919 entry = usb_alloc_urb(0, GFP_KERNEL);
920 if (!entry) {
921 kfree_skb(skb);
922 break;
923 }
924
925 usb_fill_bulk_urb(entry, priv->udev,
926 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
927 RX_URB_SIZE, rtl8192_rx_isr, skb);
928 info = (struct rtl8192_rx_info *) skb->cb;
929 info->urb = entry;
930 info->dev = dev;
931 info->out_pipe = 3;
932 skb_queue_tail(&priv->rx_queue, skb);
933 usb_submit_urb(entry, GFP_KERNEL);
934 }
935
936
937 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
938
939 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
940 if (!skb)
941 break;
942 entry = usb_alloc_urb(0, GFP_KERNEL);
943 if (!entry) {
944 kfree_skb(skb);
945 break;
946 }
947 usb_fill_bulk_urb(entry, priv->udev,
948 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
949 RX_URB_SIZE, rtl8192_rx_isr, skb);
950 info = (struct rtl8192_rx_info *) skb->cb;
951 info->urb = entry;
952 info->dev = dev;
953 info->out_pipe = 9;
954 skb_queue_tail(&priv->rx_queue, skb);
955 usb_submit_urb(entry, GFP_KERNEL);
956 }
957
958 return 0;
959}
960
961void rtl8192_set_rxconf(struct net_device *dev)
962{
963 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
964 u32 rxconf;
965
966 rxconf=read_nic_dword(dev,RCR);
967 rxconf = rxconf &~ MAC_FILTER_MASK;
968 rxconf = rxconf | RCR_AMF;
969 rxconf = rxconf | RCR_ADF;
970 rxconf = rxconf | RCR_AB;
971 rxconf = rxconf | RCR_AM;
972
973
974 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
975
976 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
977 dev->flags & IFF_PROMISC){
978 rxconf = rxconf | RCR_AAP;
979 }
980
981
982else{
983 rxconf = rxconf | RCR_APM;
984 rxconf = rxconf | RCR_CBSSID;
985 }
986
987
988 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
989 rxconf = rxconf | RCR_AICV;
990 rxconf = rxconf | RCR_APWRMGT;
991 }
992
993 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
994 rxconf = rxconf | RCR_ACRC32;
995
996
997 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
998 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
999 rxconf = rxconf &~ MAX_RX_DMA_MASK;
1000 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
1001
1002
1003 rxconf = rxconf | RCR_ONLYERLPKT;
1004
1005
1006
1007
1008 write_nic_dword(dev, RCR, rxconf);
1009
1010 #ifdef DEBUG_RX
1011 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1012 #endif
1013}
1014
1015void rtl8192_rx_enable(struct net_device *dev)
1016{
1017
1018
1019
1020
1021 rtl8192_rx_initiate(dev);
1022
1023
1024}
1025
1026
1027void rtl8192_tx_enable(struct net_device *dev)
1028{
1029}
1030
1031
1032
1033void rtl8192_rtx_disable(struct net_device *dev)
1034{
1035 u8 cmd;
1036 struct r8192_priv *priv = ieee80211_priv(dev);
1037 struct sk_buff *skb;
1038 struct rtl8192_rx_info *info;
1039
1040 cmd=read_nic_byte(dev,CMDR);
1041 write_nic_byte(dev, CMDR, cmd &~ \
1042 (CR_TE|CR_RE));
1043 force_pci_posting(dev);
1044 mdelay(10);
1045
1046 while ((skb = __skb_dequeue(&priv->rx_queue))) {
1047 info = (struct rtl8192_rx_info *) skb->cb;
1048 if (!info->urb)
1049 continue;
1050
1051 usb_kill_urb(info->urb);
1052 kfree_skb(skb);
1053 }
1054
1055 if (skb_queue_len(&priv->skb_queue)) {
1056 printk(KERN_WARNING "skb_queue not empty\n");
1057 }
1058
1059 skb_queue_purge(&priv->skb_queue);
1060 return;
1061}
1062
1063
1064int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1065{
1066 return 0;
1067}
1068
1069inline u16 ieeerate2rtlrate(int rate)
1070{
1071 switch(rate){
1072 case 10:
1073 return 0;
1074 case 20:
1075 return 1;
1076 case 55:
1077 return 2;
1078 case 110:
1079 return 3;
1080 case 60:
1081 return 4;
1082 case 90:
1083 return 5;
1084 case 120:
1085 return 6;
1086 case 180:
1087 return 7;
1088 case 240:
1089 return 8;
1090 case 360:
1091 return 9;
1092 case 480:
1093 return 10;
1094 case 540:
1095 return 11;
1096 default:
1097 return 3;
1098
1099 }
1100}
1101static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1102inline u16 rtl8192_rate2rate(short rate)
1103{
1104 if (rate >11) return 0;
1105 return rtl_rate[rate];
1106}
1107
1108
1109
1110static void rtl8192_rx_isr(struct urb *urb)
1111{
1112 struct sk_buff *skb = (struct sk_buff *) urb->context;
1113 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1114 struct net_device *dev = info->dev;
1115 struct r8192_priv *priv = ieee80211_priv(dev);
1116 int out_pipe = info->out_pipe;
1117 int err;
1118 if(!priv->up)
1119 return;
1120 if (unlikely(urb->status)) {
1121 info->urb = NULL;
1122 priv->stats.rxstaterr++;
1123 priv->ieee80211->stats.rx_errors++;
1124 usb_free_urb(urb);
1125
1126 return;
1127 }
1128 skb_unlink(skb, &priv->rx_queue);
1129 skb_put(skb, urb->actual_length);
1130
1131 skb_queue_tail(&priv->skb_queue, skb);
1132 tasklet_schedule(&priv->irq_rx_tasklet);
1133
1134 skb = dev_alloc_skb(RX_URB_SIZE);
1135 if (unlikely(!skb)) {
1136 usb_free_urb(urb);
1137 printk("%s():can,t alloc skb\n",__FUNCTION__);
1138
1139 return;
1140 }
1141
1142 usb_fill_bulk_urb(urb, priv->udev,
1143 usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
1144 RX_URB_SIZE, rtl8192_rx_isr, skb);
1145
1146 info = (struct rtl8192_rx_info *) skb->cb;
1147 info->urb = urb;
1148 info->dev = dev;
1149 info->out_pipe = out_pipe;
1150
1151 urb->transfer_buffer = skb_tail_pointer(skb);
1152 urb->context = skb;
1153 skb_queue_tail(&priv->rx_queue, skb);
1154 err = usb_submit_urb(urb, GFP_ATOMIC);
1155 if(err && err != EPERM)
1156 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1157}
1158
1159u32
1160rtl819xusb_rx_command_packet(
1161 struct net_device *dev,
1162 struct ieee80211_rx_stats *pstats
1163 )
1164{
1165 u32 status;
1166
1167
1168
1169 status = cmpk_message_handle_rx(dev, pstats);
1170 if (status)
1171 {
1172 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1173 }
1174 else
1175 {
1176
1177 }
1178
1179
1180 return status;
1181}
1182
1183
1184void rtl8192_data_hard_stop(struct net_device *dev)
1185{
1186
1187}
1188
1189
1190void rtl8192_data_hard_resume(struct net_device *dev)
1191{
1192
1193}
1194
1195
1196
1197
1198void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1199{
1200 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1201 int ret;
1202 unsigned long flags;
1203 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1204 u8 queue_index = tcb_desc->queue_index;
1205
1206
1207 assert(queue_index != TXCMD_QUEUE);
1208
1209 spin_lock_irqsave(&priv->tx_lock,flags);
1210
1211 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1212
1213
1214
1215 tcb_desc->bTxEnableFwCalcDur = 1;
1216 skb_push(skb, priv->ieee80211->tx_headroom);
1217 ret = rtl8192_tx(dev, skb);
1218
1219
1220
1221
1222 spin_unlock_irqrestore(&priv->tx_lock,flags);
1223
1224
1225 return;
1226}
1227
1228
1229
1230
1231
1232
1233int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1234{
1235 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1236 int ret;
1237 unsigned long flags;
1238 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1239 u8 queue_index = tcb_desc->queue_index;
1240
1241
1242 spin_lock_irqsave(&priv->tx_lock,flags);
1243
1244 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1245 if(queue_index == TXCMD_QUEUE) {
1246 skb_push(skb, USB_HWDESC_HEADER_LEN);
1247 rtl819xU_tx_cmd(dev, skb);
1248 ret = 1;
1249 spin_unlock_irqrestore(&priv->tx_lock,flags);
1250 return ret;
1251 } else {
1252 skb_push(skb, priv->ieee80211->tx_headroom);
1253 ret = rtl8192_tx(dev, skb);
1254 }
1255
1256 spin_unlock_irqrestore(&priv->tx_lock,flags);
1257
1258 return ret;
1259}
1260
1261
1262void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1263
1264#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1265u16 DrvAggr_PaddingAdd(struct net_device *dev, struct sk_buff *skb)
1266{
1267 u16 PaddingNum = 256 - ((skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES) % 256);
1268 return (PaddingNum&0xff);
1269}
1270
1271u8 MRateToHwRate8190Pci(u8 rate);
1272u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
1273u8 MapHwQueueToFirmwareQueue(u8 QueueID);
1274struct sk_buff *DrvAggr_Aggregation(struct net_device *dev, struct ieee80211_drv_agg_txb *pSendList)
1275{
1276 struct ieee80211_device *ieee = netdev_priv(dev);
1277 struct r8192_priv *priv = ieee80211_priv(dev);
1278 cb_desc *tcb_desc = NULL;
1279 u8 i;
1280 u32 TotalLength;
1281 struct sk_buff *skb;
1282 struct sk_buff *agg_skb;
1283 tx_desc_819x_usb_aggr_subframe *tx_agg_desc = NULL;
1284 tx_fwinfo_819x_usb *tx_fwinfo = NULL;
1285
1286
1287
1288
1289
1290 skb = pSendList->tx_agg_frames[0];
1291 TotalLength = skb->len;
1292
1293
1294
1295
1296 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1297 TotalLength += DrvAggr_PaddingAdd(dev, skb);
1298 skb = pSendList->tx_agg_frames[i];
1299 TotalLength += (skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1300 }
1301
1302
1303 agg_skb = dev_alloc_skb(TotalLength + ieee->tx_headroom);
1304 memset(agg_skb->data, 0, agg_skb->len);
1305 skb_reserve(agg_skb, ieee->tx_headroom);
1306
1307
1308
1309 skb = pSendList->tx_agg_frames[0];
1310 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1311 tcb_desc->drv_agg_enable = 1;
1312 tcb_desc->pkt_size = skb->len;
1313 tcb_desc->DrvAggrNum = pSendList->nr_drv_agg_frames;
1314 printk("DrvAggNum = %d\n", tcb_desc->DrvAggrNum);
1315
1316
1317
1318 memcpy(agg_skb->cb, skb->cb, sizeof(skb->cb));
1319 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1320
1321 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1322
1323 skb_put(agg_skb,DrvAggr_PaddingAdd(dev,skb));
1324
1325
1326 skb = pSendList->tx_agg_frames[i];
1327 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1328 tx_agg_desc = (tx_desc_819x_usb_aggr_subframe *)agg_skb->tail;
1329 tx_fwinfo = (tx_fwinfo_819x_usb *)(agg_skb->tail + sizeof(tx_desc_819x_usb_aggr_subframe));
1330
1331 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
1332
1333 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1334 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1335 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1336 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1337 if(tcb_desc->bAMPDUEnable) {
1338 tx_fwinfo->AllowAggregation = 1;
1339
1340 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1341 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;
1342 } else {
1343 tx_fwinfo->AllowAggregation = 0;
1344
1345 tx_fwinfo->RxMF = 0;
1346 tx_fwinfo->RxAMD = 0;
1347 }
1348
1349
1350 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1351 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1352 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1353 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
1354 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1355 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
1356 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
1357 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
1358 (tcb_desc->bRTSUseShortGI?1:0);
1359
1360
1361 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1362 {
1363 if(tcb_desc->bPacketBW) {
1364 tx_fwinfo->TxBandwidth = 1;
1365 tx_fwinfo->TxSubCarrier = 0;
1366 } else {
1367 tx_fwinfo->TxBandwidth = 0;
1368 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1369 }
1370 } else {
1371 tx_fwinfo->TxBandwidth = 0;
1372 tx_fwinfo->TxSubCarrier = 0;
1373 }
1374
1375
1376 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
1377
1378
1379
1380 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1381
1382 tx_agg_desc->PktSize = skb->len & 0xffff;
1383
1384
1385 tx_agg_desc->SecCAMID= 0;
1386 tx_agg_desc->RATid = tcb_desc->RATRIndex;
1387 {
1388
1389 tx_agg_desc->NoEnc = 1;
1390 }
1391 tx_agg_desc->SecType = 0x0;
1392
1393 if (tcb_desc->bHwSec) {
1394 switch (priv->ieee80211->pairwise_key_type)
1395 {
1396 case KEY_TYPE_WEP40:
1397 case KEY_TYPE_WEP104:
1398 tx_agg_desc->SecType = 0x1;
1399 tx_agg_desc->NoEnc = 0;
1400 break;
1401 case KEY_TYPE_TKIP:
1402 tx_agg_desc->SecType = 0x2;
1403 tx_agg_desc->NoEnc = 0;
1404 break;
1405 case KEY_TYPE_CCMP:
1406 tx_agg_desc->SecType = 0x3;
1407 tx_agg_desc->NoEnc = 0;
1408 break;
1409 case KEY_TYPE_NA:
1410 tx_agg_desc->SecType = 0x0;
1411 tx_agg_desc->NoEnc = 1;
1412 break;
1413 }
1414 }
1415
1416 tx_agg_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1417 tx_agg_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
1418
1419 tx_agg_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
1420 tx_agg_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1421
1422 tx_agg_desc->OWN = 1;
1423
1424
1425
1426
1427
1428
1429 skb_put(agg_skb,TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1430 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1431 }
1432
1433 for(i = 0; i < pSendList->nr_drv_agg_frames; i++) {
1434 dev_kfree_skb_any(pSendList->tx_agg_frames[i]);
1435 }
1436
1437 return agg_skb;
1438}
1439
1440
1441
1442
1443
1444u8 DrvAggr_GetAggregatibleList(struct net_device *dev, struct sk_buff *skb,
1445 struct ieee80211_drv_agg_txb *pSendList)
1446{
1447 struct ieee80211_device *ieee = netdev_priv(dev);
1448 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1449 u16 nMaxAggrNum = pHTInfo->UsbTxAggrNum;
1450 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1451 u8 QueueID = tcb_desc->queue_index;
1452
1453 do {
1454 pSendList->tx_agg_frames[pSendList->nr_drv_agg_frames++] = skb;
1455 if(pSendList->nr_drv_agg_frames >= nMaxAggrNum) {
1456 break;
1457 }
1458
1459 } while((skb = skb_dequeue(&ieee->skb_drv_aggQ[QueueID])));
1460
1461 RT_TRACE(COMP_AMSDU, "DrvAggr_GetAggregatibleList, nAggrTcbNum = %d \n", pSendList->nr_drv_agg_frames);
1462 return pSendList->nr_drv_agg_frames;
1463}
1464#endif
1465
1466static void rtl8192_tx_isr(struct urb *tx_urb)
1467{
1468 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1469 struct net_device *dev = NULL;
1470 struct r8192_priv *priv = NULL;
1471 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1472 u8 queue_index = tcb_desc->queue_index;
1473
1474
1475
1476 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1477 priv = ieee80211_priv(dev);
1478
1479 if(tcb_desc->queue_index != TXCMD_QUEUE) {
1480 if(tx_urb->status == 0) {
1481 dev->trans_start = jiffies;
1482
1483
1484
1485 priv->stats.txoktotal++;
1486 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1487 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1488 } else {
1489 priv->ieee80211->stats.tx_errors++;
1490
1491
1492 }
1493 }
1494
1495
1496 if(skb != NULL) {
1497 dev_kfree_skb_any(skb);
1498 usb_free_urb(tx_urb);
1499 atomic_dec(&priv->tx_pending[queue_index]);
1500 }
1501
1502 {
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515 if(queue_index != BEACON_QUEUE) {
1516
1517 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1518 (!(priv->ieee80211->queue_stop))) {
1519 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1520 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1521
1522 return;
1523 }
1524#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1525 else if ((skb_queue_len(&priv->ieee80211->skb_drv_aggQ[queue_index])!= 0)&&\
1526 (!(priv->ieee80211->queue_stop))) {
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536 skb = skb_dequeue(&priv->ieee80211->skb_drv_aggQ[queue_index]);
1537 if(!check_nic_enough_desc(dev, queue_index)) {
1538 skb_queue_head(&(priv->ieee80211->skb_drv_aggQ[queue_index]), skb);
1539 return;
1540 }
1541
1542 {
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553 {
1554 struct ieee80211_drv_agg_txb SendList;
1555
1556 memset(&SendList, 0, sizeof(struct ieee80211_drv_agg_txb));
1557 if(DrvAggr_GetAggregatibleList(dev, skb, &SendList) > 1) {
1558 skb = DrvAggr_Aggregation(dev, &SendList);
1559
1560 }
1561 }
1562 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1563 }
1564 }
1565#endif
1566 }
1567 }
1568
1569}
1570
1571void rtl8192_beacon_stop(struct net_device *dev)
1572{
1573 u8 msr, msrm, msr2;
1574 struct r8192_priv *priv = ieee80211_priv(dev);
1575
1576 msr = read_nic_byte(dev, MSR);
1577 msrm = msr & MSR_LINK_MASK;
1578 msr2 = msr & ~MSR_LINK_MASK;
1579
1580 if(NIC_8192U == priv->card_8192) {
1581 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1582 }
1583 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1584 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1585 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1586 write_nic_byte(dev, MSR, msr);
1587 }
1588}
1589
1590void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1591{
1592 struct r8192_priv *priv = ieee80211_priv(dev);
1593 struct ieee80211_network *net;
1594 u8 i=0, basic_rate = 0;
1595 net = & priv->ieee80211->current_network;
1596
1597 for (i=0; i<net->rates_len; i++)
1598 {
1599 basic_rate = net->rates[i]&0x7f;
1600 switch(basic_rate)
1601 {
1602 case MGN_1M: *rate_config |= RRSR_1M; break;
1603 case MGN_2M: *rate_config |= RRSR_2M; break;
1604 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1605 case MGN_11M: *rate_config |= RRSR_11M; break;
1606 case MGN_6M: *rate_config |= RRSR_6M; break;
1607 case MGN_9M: *rate_config |= RRSR_9M; break;
1608 case MGN_12M: *rate_config |= RRSR_12M; break;
1609 case MGN_18M: *rate_config |= RRSR_18M; break;
1610 case MGN_24M: *rate_config |= RRSR_24M; break;
1611 case MGN_36M: *rate_config |= RRSR_36M; break;
1612 case MGN_48M: *rate_config |= RRSR_48M; break;
1613 case MGN_54M: *rate_config |= RRSR_54M; break;
1614 }
1615 }
1616 for (i=0; i<net->rates_ex_len; i++)
1617 {
1618 basic_rate = net->rates_ex[i]&0x7f;
1619 switch(basic_rate)
1620 {
1621 case MGN_1M: *rate_config |= RRSR_1M; break;
1622 case MGN_2M: *rate_config |= RRSR_2M; break;
1623 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1624 case MGN_11M: *rate_config |= RRSR_11M; break;
1625 case MGN_6M: *rate_config |= RRSR_6M; break;
1626 case MGN_9M: *rate_config |= RRSR_9M; break;
1627 case MGN_12M: *rate_config |= RRSR_12M; break;
1628 case MGN_18M: *rate_config |= RRSR_18M; break;
1629 case MGN_24M: *rate_config |= RRSR_24M; break;
1630 case MGN_36M: *rate_config |= RRSR_36M; break;
1631 case MGN_48M: *rate_config |= RRSR_48M; break;
1632 case MGN_54M: *rate_config |= RRSR_54M; break;
1633 }
1634 }
1635}
1636
1637
1638#define SHORT_SLOT_TIME 9
1639#define NON_SHORT_SLOT_TIME 20
1640
1641void rtl8192_update_cap(struct net_device* dev, u16 cap)
1642{
1643 u32 tmp = 0;
1644 struct r8192_priv *priv = ieee80211_priv(dev);
1645 struct ieee80211_network *net = &priv->ieee80211->current_network;
1646 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1647 tmp = priv->basic_rate;
1648 if (priv->short_preamble)
1649 tmp |= BRSR_AckShortPmb;
1650 write_nic_dword(dev, RRSR, tmp);
1651
1652 if (net->mode & (IEEE_G|IEEE_N_24G))
1653 {
1654 u8 slot_time = 0;
1655 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1656 {
1657 slot_time = SHORT_SLOT_TIME;
1658 }
1659 else
1660 slot_time = NON_SHORT_SLOT_TIME;
1661 priv->slot_time = slot_time;
1662 write_nic_byte(dev, SLOT_TIME, slot_time);
1663 }
1664
1665}
1666void rtl8192_net_update(struct net_device *dev)
1667{
1668
1669 struct r8192_priv *priv = ieee80211_priv(dev);
1670 struct ieee80211_network *net;
1671 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1672 u16 rate_config = 0;
1673 net = & priv->ieee80211->current_network;
1674
1675 rtl8192_config_rate(dev, &rate_config);
1676 priv->basic_rate = rate_config &= 0x15f;
1677
1678 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1679 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1680
1681
1682
1683 rtl8192_update_msr(dev);
1684
1685 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1686 {
1687 write_nic_word(dev, ATIMWND, 2);
1688 write_nic_word(dev, BCN_DMATIME, 1023);
1689 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1690
1691 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1692 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1693 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1694
1695 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1696
1697 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1698 }
1699
1700
1701
1702}
1703
1704
1705
1706void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
1707{
1708
1709}
1710inline u8 rtl8192_IsWirelessBMode(u16 rate)
1711{
1712 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1713 return 1;
1714 else return 0;
1715}
1716
1717u16 N_DBPSOfRate(u16 DataRate);
1718
1719u16 ComputeTxTime(
1720 u16 FrameLength,
1721 u16 DataRate,
1722 u8 bManagementFrame,
1723 u8 bShortPreamble
1724)
1725{
1726 u16 FrameTime;
1727 u16 N_DBPS;
1728 u16 Ceiling;
1729
1730 if( rtl8192_IsWirelessBMode(DataRate) )
1731 {
1732 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1733 {
1734 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1735 }
1736 else
1737 {
1738 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1739 }
1740 if( ( FrameLength*8 % (DataRate/10) ) != 0 )
1741 FrameTime ++;
1742 } else {
1743 N_DBPS = N_DBPSOfRate(DataRate);
1744 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1745 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1746 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1747 }
1748 return FrameTime;
1749}
1750
1751u16 N_DBPSOfRate(u16 DataRate)
1752{
1753 u16 N_DBPS = 24;
1754
1755 switch(DataRate)
1756 {
1757 case 60:
1758 N_DBPS = 24;
1759 break;
1760
1761 case 90:
1762 N_DBPS = 36;
1763 break;
1764
1765 case 120:
1766 N_DBPS = 48;
1767 break;
1768
1769 case 180:
1770 N_DBPS = 72;
1771 break;
1772
1773 case 240:
1774 N_DBPS = 96;
1775 break;
1776
1777 case 360:
1778 N_DBPS = 144;
1779 break;
1780
1781 case 480:
1782 N_DBPS = 192;
1783 break;
1784
1785 case 540:
1786 N_DBPS = 216;
1787 break;
1788
1789 default:
1790 break;
1791 }
1792
1793 return N_DBPS;
1794}
1795
1796void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1797{
1798 usb_free_urb(tx_cmd_urb);
1799}
1800
1801unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1802
1803 if(tx_queue >= 9)
1804 {
1805 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1806 return 0x04;
1807 }
1808 return priv->txqueue_to_outpipemap[tx_queue];
1809}
1810
1811short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1812{
1813 struct r8192_priv *priv = ieee80211_priv(dev);
1814
1815 int status;
1816 struct urb *tx_urb;
1817
1818 unsigned int idx_pipe;
1819 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1820 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1821 u8 queue_index = tcb_desc->queue_index;
1822
1823
1824 atomic_inc(&priv->tx_pending[queue_index]);
1825 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1826 if(!tx_urb){
1827 dev_kfree_skb(skb);
1828 return -ENOMEM;
1829 }
1830
1831 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1832
1833 pdesc->FirstSeg = 1;
1834 pdesc->LastSeg = 1;
1835 pdesc->CmdInit = tcb_desc->bCmdOrInit;
1836 pdesc->TxBufferSize = tcb_desc->txbuf_size;
1837 pdesc->OWN = 1;
1838 pdesc->LINIP = tcb_desc->bLastIniPkt;
1839
1840
1841
1842
1843
1844#ifndef USE_ONE_PIPE
1845 idx_pipe = txqueue2outpipe(priv,queue_index);
1846#else
1847 idx_pipe = 0x04;
1848#endif
1849#ifdef JOHN_DUMP_TXDESC
1850 int i;
1851 printk("<Tx descriptor>--rate %x---",rate);
1852 for (i = 0; i < 8; i++)
1853 printk("%8x ", tx[i]);
1854 printk("\n");
1855#endif
1856 usb_fill_bulk_urb(tx_urb,priv->udev, usb_sndbulkpipe(priv->udev,idx_pipe), \
1857 skb->data, skb->len, rtl8192_tx_isr, skb);
1858
1859 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1860
1861 if (!status){
1862 return 0;
1863 }else{
1864 DMESGE("Error TX CMD URB, error %d",
1865 status);
1866 return -1;
1867 }
1868}
1869
1870
1871
1872
1873
1874
1875
1876
1877u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1878{
1879 u8 QueueSelect = 0x0;
1880
1881 switch(QueueID) {
1882 case BE_QUEUE:
1883 QueueSelect = QSLT_BE;
1884 break;
1885
1886 case BK_QUEUE:
1887 QueueSelect = QSLT_BK;
1888 break;
1889
1890 case VO_QUEUE:
1891 QueueSelect = QSLT_VO;
1892 break;
1893
1894 case VI_QUEUE:
1895 QueueSelect = QSLT_VI;
1896 break;
1897 case MGNT_QUEUE:
1898 QueueSelect = QSLT_MGNT;
1899 break;
1900
1901 case BEACON_QUEUE:
1902 QueueSelect = QSLT_BEACON;
1903 break;
1904
1905
1906
1907
1908 case TXCMD_QUEUE:
1909 QueueSelect = QSLT_CMD;
1910 break;
1911
1912 case HIGH_QUEUE:
1913 QueueSelect = QSLT_HIGH;
1914 break;
1915
1916 default:
1917 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1918 break;
1919 }
1920 return QueueSelect;
1921}
1922
1923u8 MRateToHwRate8190Pci(u8 rate)
1924{
1925 u8 ret = DESC90_RATE1M;
1926
1927 switch(rate) {
1928 case MGN_1M: ret = DESC90_RATE1M; break;
1929 case MGN_2M: ret = DESC90_RATE2M; break;
1930 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1931 case MGN_11M: ret = DESC90_RATE11M; break;
1932 case MGN_6M: ret = DESC90_RATE6M; break;
1933 case MGN_9M: ret = DESC90_RATE9M; break;
1934 case MGN_12M: ret = DESC90_RATE12M; break;
1935 case MGN_18M: ret = DESC90_RATE18M; break;
1936 case MGN_24M: ret = DESC90_RATE24M; break;
1937 case MGN_36M: ret = DESC90_RATE36M; break;
1938 case MGN_48M: ret = DESC90_RATE48M; break;
1939 case MGN_54M: ret = DESC90_RATE54M; break;
1940
1941
1942 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1943 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1944 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1945 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1946 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1947 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1948 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1949 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1950 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1951 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1952 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1953 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1954 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1955 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1956 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1957 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1958 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1959
1960 default: break;
1961 }
1962 return ret;
1963}
1964
1965
1966u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1967{
1968 u8 tmp_Short;
1969
1970 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1971
1972 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1973 tmp_Short = 0;
1974
1975 return tmp_Short;
1976}
1977
1978static void tx_zero_isr(struct urb *tx_urb)
1979{
1980 return;
1981}
1982
1983
1984
1985
1986
1987
1988short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1989{
1990 struct r8192_priv *priv = ieee80211_priv(dev);
1991 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1992 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
1993 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
1994 struct usb_device *udev = priv->udev;
1995 int pend;
1996 int status;
1997 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
1998
1999 unsigned int idx_pipe;
2000
2001
2002 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
2003
2004
2005
2006
2007 if( pend > MAX_TX_URB){
2008 printk("To discard skb packet!\n");
2009 dev_kfree_skb_any(skb);
2010 return -1;
2011 }
2012
2013 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
2014 if(!tx_urb){
2015 dev_kfree_skb_any(skb);
2016 return -ENOMEM;
2017 }
2018
2019
2020 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2021
2022 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2023 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2024 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2025 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
2026 if(tcb_desc->bAMPDUEnable) {
2027 tx_fwinfo->AllowAggregation = 1;
2028
2029 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2030 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;
2031 } else {
2032 tx_fwinfo->AllowAggregation = 0;
2033
2034 tx_fwinfo->RxMF = 0;
2035 tx_fwinfo->RxAMD = 0;
2036 }
2037
2038
2039 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
2040 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
2041 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
2042 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
2043 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2044 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
2045 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2046 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2047 (tcb_desc->bRTSUseShortGI?1:0);
2048
2049
2050 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2051 {
2052 if(tcb_desc->bPacketBW) {
2053 tx_fwinfo->TxBandwidth = 1;
2054 tx_fwinfo->TxSubCarrier = 0;
2055 } else {
2056 tx_fwinfo->TxBandwidth = 0;
2057 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
2058 }
2059 } else {
2060 tx_fwinfo->TxBandwidth = 0;
2061 tx_fwinfo->TxSubCarrier = 0;
2062 }
2063
2064#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2065 if (tcb_desc->drv_agg_enable)
2066 {
2067 tx_fwinfo->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1;
2068 }
2069#endif
2070
2071 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2072
2073 tx_desc->LINIP = 0;
2074 tx_desc->CmdInit = 1;
2075 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
2076
2077#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2078 if (tcb_desc->drv_agg_enable) {
2079 tx_desc->PktSize = tcb_desc->pkt_size;
2080 } else
2081#endif
2082 {
2083 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
2084 }
2085
2086
2087 tx_desc->SecCAMID= 0;
2088 tx_desc->RATid = tcb_desc->RATRIndex;
2089 {
2090
2091 tx_desc->NoEnc = 1;
2092 }
2093 tx_desc->SecType = 0x0;
2094 if (tcb_desc->bHwSec)
2095 {
2096 switch (priv->ieee80211->pairwise_key_type)
2097 {
2098 case KEY_TYPE_WEP40:
2099 case KEY_TYPE_WEP104:
2100 tx_desc->SecType = 0x1;
2101 tx_desc->NoEnc = 0;
2102 break;
2103 case KEY_TYPE_TKIP:
2104 tx_desc->SecType = 0x2;
2105 tx_desc->NoEnc = 0;
2106 break;
2107 case KEY_TYPE_CCMP:
2108 tx_desc->SecType = 0x3;
2109 tx_desc->NoEnc = 0;
2110 break;
2111 case KEY_TYPE_NA:
2112 tx_desc->SecType = 0x0;
2113 tx_desc->NoEnc = 1;
2114 break;
2115 }
2116 }
2117
2118 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2119 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
2120
2121 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2122 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2123
2124
2125
2126 tx_desc->FirstSeg = 1;
2127 tx_desc->LastSeg = 1;
2128 tx_desc->OWN = 1;
2129
2130#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2131 if (tcb_desc->drv_agg_enable) {
2132 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
2133 } else
2134#endif
2135 {
2136
2137 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2138 }
2139
2140#ifndef USE_ONE_PIPE
2141 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2142#else
2143 idx_pipe = 0x5;
2144#endif
2145
2146
2147
2148
2149
2150 usb_fill_bulk_urb(tx_urb,udev,
2151 usb_sndbulkpipe(udev,idx_pipe), skb->data,
2152 skb->len, rtl8192_tx_isr, skb);
2153
2154 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2155 if (!status){
2156
2157 bool bSend0Byte = false;
2158 u8 zero = 0;
2159 if(udev->speed == USB_SPEED_HIGH)
2160 {
2161 if (skb->len > 0 && skb->len % 512 == 0)
2162 bSend0Byte = true;
2163 }
2164 else
2165 {
2166 if (skb->len > 0 && skb->len % 64 == 0)
2167 bSend0Byte = true;
2168 }
2169 if (bSend0Byte)
2170 {
2171 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2172 if(!tx_urb_zero){
2173 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2174 return -ENOMEM;
2175 }
2176 usb_fill_bulk_urb(tx_urb_zero,udev,
2177 usb_sndbulkpipe(udev,idx_pipe), &zero,
2178 0, tx_zero_isr, dev);
2179 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2180 if (status){
2181 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2182 return -1;
2183 }
2184 }
2185 dev->trans_start = jiffies;
2186 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2187 return 0;
2188 }else{
2189 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2190 status);
2191 return -1;
2192 }
2193}
2194
2195short rtl8192_usb_initendpoints(struct net_device *dev)
2196{
2197 struct r8192_priv *priv = ieee80211_priv(dev);
2198
2199 priv->rx_urb = kmalloc(sizeof(struct urb *) * (MAX_RX_URB+1),
2200 GFP_KERNEL);
2201 if (priv->rx_urb == NULL)
2202 return -ENOMEM;
2203
2204#ifndef JACKSON_NEW_RX
2205 for(i=0;i<(MAX_RX_URB+1);i++){
2206
2207 priv->rx_urb[i] = usb_alloc_urb(0,GFP_KERNEL);
2208
2209 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
2210
2211 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
2212 }
2213#endif
2214
2215#ifdef THOMAS_BEACON
2216{
2217 long align = 0;
2218 void *oldaddr, *newaddr;
2219
2220 priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
2221 priv->oldaddr = kmalloc(16, GFP_KERNEL);
2222 oldaddr = priv->oldaddr;
2223 align = ((long)oldaddr) & 3;
2224 if (align) {
2225 newaddr = oldaddr + 4 - align;
2226 priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
2227 } else {
2228 newaddr = oldaddr;
2229 priv->rx_urb[16]->transfer_buffer_length = 16;
2230 }
2231 priv->rx_urb[16]->transfer_buffer = newaddr;
2232}
2233#endif
2234
2235 memset(priv->rx_urb, 0, sizeof(struct urb*) * MAX_RX_URB);
2236 priv->pp_rxskb = kcalloc(MAX_RX_URB, sizeof(struct sk_buff *),
2237 GFP_KERNEL);
2238 if (priv->pp_rxskb == NULL)
2239 goto destroy;
2240
2241 goto _middle;
2242
2243
2244destroy:
2245 if (priv->pp_rxskb) {
2246 kfree(priv->pp_rxskb);
2247 }
2248 if (priv->rx_urb) {
2249 kfree(priv->rx_urb);
2250 }
2251
2252 priv->pp_rxskb = NULL;
2253 priv->rx_urb = NULL;
2254
2255 DMESGE("Endpoint Alloc Failure");
2256 return -ENOMEM;
2257
2258
2259_middle:
2260
2261 printk("End of initendpoints\n");
2262 return 0;
2263
2264}
2265#ifdef THOMAS_BEACON
2266void rtl8192_usb_deleteendpoints(struct net_device *dev)
2267{
2268 int i;
2269 struct r8192_priv *priv = ieee80211_priv(dev);
2270
2271 if(priv->rx_urb){
2272 for(i=0;i<(MAX_RX_URB+1);i++){
2273 usb_kill_urb(priv->rx_urb[i]);
2274 usb_free_urb(priv->rx_urb[i]);
2275 }
2276 kfree(priv->rx_urb);
2277 priv->rx_urb = NULL;
2278 }
2279 if(priv->oldaddr){
2280 kfree(priv->oldaddr);
2281 priv->oldaddr = NULL;
2282 }
2283 if (priv->pp_rxskb) {
2284 kfree(priv->pp_rxskb);
2285 priv->pp_rxskb = 0;
2286 }
2287}
2288#else
2289void rtl8192_usb_deleteendpoints(struct net_device *dev)
2290{
2291 int i;
2292 struct r8192_priv *priv = ieee80211_priv(dev);
2293
2294#ifndef JACKSON_NEW_RX
2295
2296 if(priv->rx_urb){
2297 for(i=0;i<(MAX_RX_URB+1);i++){
2298 usb_kill_urb(priv->rx_urb[i]);
2299 kfree(priv->rx_urb[i]->transfer_buffer);
2300 usb_free_urb(priv->rx_urb[i]);
2301 }
2302 kfree(priv->rx_urb);
2303 priv->rx_urb = NULL;
2304
2305 }
2306#else
2307 if(priv->rx_urb){
2308 kfree(priv->rx_urb);
2309 priv->rx_urb = NULL;
2310 }
2311 if(priv->oldaddr){
2312 kfree(priv->oldaddr);
2313 priv->oldaddr = NULL;
2314 }
2315 if (priv->pp_rxskb) {
2316 kfree(priv->pp_rxskb);
2317 priv->pp_rxskb = 0;
2318
2319 }
2320
2321#endif
2322}
2323#endif
2324
2325extern void rtl8192_update_ratr_table(struct net_device* dev);
2326void rtl8192_link_change(struct net_device *dev)
2327{
2328
2329
2330 struct r8192_priv *priv = ieee80211_priv(dev);
2331 struct ieee80211_device* ieee = priv->ieee80211;
2332
2333 if (ieee->state == IEEE80211_LINKED)
2334 {
2335 rtl8192_net_update(dev);
2336 rtl8192_update_ratr_table(dev);
2337
2338 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
2339 EnableHWSecurityConfig8192(dev);
2340 }
2341
2342
2343
2344 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
2345 {
2346 u32 reg = 0;
2347 reg = read_nic_dword(dev, RCR);
2348 if (priv->ieee80211->state == IEEE80211_LINKED)
2349 priv->ReceiveConfig = reg |= RCR_CBSSID;
2350 else
2351 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2352 write_nic_dword(dev, RCR, reg);
2353 }
2354
2355
2356}
2357
2358static struct ieee80211_qos_parameters def_qos_parameters = {
2359 {3,3,3,3},
2360 {7,7,7,7},
2361 {2,2,2,2},
2362 {0,0,0,0},
2363 {0,0,0,0}
2364};
2365
2366
2367void rtl8192_update_beacon(struct work_struct * work)
2368{
2369 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2370 struct net_device *dev = priv->ieee80211->dev;
2371 struct ieee80211_device* ieee = priv->ieee80211;
2372 struct ieee80211_network* net = &ieee->current_network;
2373
2374 if (ieee->pHTInfo->bCurrentHTSupport)
2375 HTUpdateSelfAndPeerSetting(ieee, net);
2376 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2377 rtl8192_update_cap(dev, net->capability);
2378}
2379
2380
2381
2382int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2383void rtl8192_qos_activate(struct work_struct * work)
2384{
2385 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2386 struct net_device *dev = priv->ieee80211->dev;
2387 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2388 u8 mode = priv->ieee80211->current_network.mode;
2389
2390 u8 u1bAIFS;
2391 u32 u4bAcParam;
2392 int i;
2393
2394 if (priv == NULL)
2395 return;
2396
2397 mutex_lock(&priv->mutex);
2398 if(priv->ieee80211->state != IEEE80211_LINKED)
2399 goto success;
2400 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2401
2402
2403
2404 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2405
2406 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2407 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2408 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2409 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2410 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2411
2412 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2413
2414 }
2415
2416success:
2417 mutex_unlock(&priv->mutex);
2418}
2419
2420static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2421 int active_network,
2422 struct ieee80211_network *network)
2423{
2424 int ret = 0;
2425 u32 size = sizeof(struct ieee80211_qos_parameters);
2426
2427 if(priv->ieee80211->state !=IEEE80211_LINKED)
2428 return ret;
2429
2430 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2431 return ret;
2432
2433 if (network->flags & NETWORK_HAS_QOS_MASK) {
2434 if (active_network &&
2435 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2436 network->qos_data.active = network->qos_data.supported;
2437
2438 if ((network->qos_data.active == 1) && (active_network == 1) &&
2439 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2440 (network->qos_data.old_param_count !=
2441 network->qos_data.param_count)) {
2442 network->qos_data.old_param_count =
2443 network->qos_data.param_count;
2444 queue_work(priv->priv_wq, &priv->qos_activate);
2445 RT_TRACE (COMP_QOS, "QoS parameters change call "
2446 "qos_activate\n");
2447 }
2448 } else {
2449 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2450 &def_qos_parameters, size);
2451
2452 if ((network->qos_data.active == 1) && (active_network == 1)) {
2453 queue_work(priv->priv_wq, &priv->qos_activate);
2454 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2455 }
2456 network->qos_data.active = 0;
2457 network->qos_data.supported = 0;
2458 }
2459
2460 return 0;
2461}
2462
2463
2464static int rtl8192_handle_beacon(struct net_device * dev,
2465 struct ieee80211_beacon * beacon,
2466 struct ieee80211_network * network)
2467{
2468 struct r8192_priv *priv = ieee80211_priv(dev);
2469
2470 rtl8192_qos_handle_probe_response(priv,1,network);
2471 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2472 return 0;
2473
2474}
2475
2476
2477
2478
2479
2480
2481static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2482 struct ieee80211_network *network)
2483{
2484 int ret = 0;
2485 unsigned long flags;
2486 u32 size = sizeof(struct ieee80211_qos_parameters);
2487 int set_qos_param = 0;
2488
2489 if ((priv == NULL) || (network == NULL))
2490 return ret;
2491
2492 if(priv->ieee80211->state !=IEEE80211_LINKED)
2493 return ret;
2494
2495 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2496 return ret;
2497
2498 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2499 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2500 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2501 &network->qos_data.parameters,\
2502 sizeof(struct ieee80211_qos_parameters));
2503 priv->ieee80211->current_network.qos_data.active = 1;
2504 {
2505 set_qos_param = 1;
2506
2507 priv->ieee80211->current_network.qos_data.old_param_count = \
2508 priv->ieee80211->current_network.qos_data.param_count;
2509 priv->ieee80211->current_network.qos_data.param_count = \
2510 network->qos_data.param_count;
2511 }
2512 } else {
2513 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2514 &def_qos_parameters, size);
2515 priv->ieee80211->current_network.qos_data.active = 0;
2516 priv->ieee80211->current_network.qos_data.supported = 0;
2517 set_qos_param = 1;
2518 }
2519
2520 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2521
2522 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2523 if (set_qos_param == 1)
2524 queue_work(priv->priv_wq, &priv->qos_activate);
2525
2526
2527 return ret;
2528}
2529
2530
2531static int rtl8192_handle_assoc_response(struct net_device *dev,
2532 struct ieee80211_assoc_response_frame *resp,
2533 struct ieee80211_network *network)
2534{
2535 struct r8192_priv *priv = ieee80211_priv(dev);
2536 rtl8192_qos_association_resp(priv, network);
2537 return 0;
2538}
2539
2540
2541void rtl8192_update_ratr_table(struct net_device* dev)
2542
2543
2544
2545{
2546 struct r8192_priv* priv = ieee80211_priv(dev);
2547 struct ieee80211_device* ieee = priv->ieee80211;
2548 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2549
2550 u32 ratr_value = 0;
2551 u8 rate_index = 0;
2552 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2553 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2554
2555 switch (ieee->mode)
2556 {
2557 case IEEE_A:
2558 ratr_value &= 0x00000FF0;
2559 break;
2560 case IEEE_B:
2561 ratr_value &= 0x0000000F;
2562 break;
2563 case IEEE_G:
2564 ratr_value &= 0x00000FF7;
2565 break;
2566 case IEEE_N_24G:
2567 case IEEE_N_5G:
2568 if (ieee->pHTInfo->PeerMimoPs == 0)
2569 ratr_value &= 0x0007F007;
2570 else{
2571 if (priv->rf_type == RF_1T2R)
2572 ratr_value &= 0x000FF007;
2573 else
2574 ratr_value &= 0x0F81F007;
2575 }
2576 break;
2577 default:
2578 break;
2579 }
2580 ratr_value &= 0x0FFFFFFF;
2581 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2582 ratr_value |= 0x80000000;
2583 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2584 ratr_value |= 0x80000000;
2585 }
2586 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2587 write_nic_byte(dev, UFWP, 1);
2588}
2589
2590static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2591static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2592bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2593{
2594 struct r8192_priv* priv = ieee80211_priv(dev);
2595 struct ieee80211_device* ieee = priv->ieee80211;
2596 struct ieee80211_network * network = &ieee->current_network;
2597 int wpa_ie_len= ieee->wpa_ie_len;
2598 struct ieee80211_crypt_data* crypt;
2599 int encrypt;
2600
2601 crypt = ieee->crypt[ieee->tx_keyidx];
2602
2603 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2604
2605
2606 if(encrypt && (wpa_ie_len == 0)) {
2607
2608 return false;
2609
2610 } else if((wpa_ie_len != 0)) {
2611
2612
2613 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) || ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
2614 return true;
2615 else
2616 return false;
2617 } else {
2618 return true;
2619 }
2620
2621 return true;
2622}
2623
2624bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2625{
2626 bool Reval;
2627 struct r8192_priv* priv = ieee80211_priv(dev);
2628 struct ieee80211_device* ieee = priv->ieee80211;
2629
2630 if(ieee->bHalfWirelessN24GMode == true)
2631 Reval = true;
2632 else
2633 Reval = false;
2634
2635 return Reval;
2636}
2637
2638void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2639{
2640 struct ieee80211_device* ieee = priv->ieee80211;
2641
2642 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2643 {
2644 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2645
2646
2647 }
2648 else
2649 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2650 return;
2651}
2652
2653u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2654{
2655 struct r8192_priv *priv = ieee80211_priv(dev);
2656 u8 ret = 0;
2657 switch(priv->rf_chip)
2658 {
2659 case RF_8225:
2660 case RF_8256:
2661 case RF_PSEUDO_11N:
2662 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2663 break;
2664 case RF_8258:
2665 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2666 break;
2667 default:
2668 ret = WIRELESS_MODE_B;
2669 break;
2670 }
2671 return ret;
2672}
2673void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2674{
2675 struct r8192_priv *priv = ieee80211_priv(dev);
2676 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2677
2678 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2679 {
2680 if(bSupportMode & WIRELESS_MODE_N_24G)
2681 {
2682 wireless_mode = WIRELESS_MODE_N_24G;
2683 }
2684 else if(bSupportMode & WIRELESS_MODE_N_5G)
2685 {
2686 wireless_mode = WIRELESS_MODE_N_5G;
2687 }
2688 else if((bSupportMode & WIRELESS_MODE_A))
2689 {
2690 wireless_mode = WIRELESS_MODE_A;
2691 }
2692 else if((bSupportMode & WIRELESS_MODE_G))
2693 {
2694 wireless_mode = WIRELESS_MODE_G;
2695 }
2696 else if((bSupportMode & WIRELESS_MODE_B))
2697 {
2698 wireless_mode = WIRELESS_MODE_B;
2699 }
2700 else{
2701 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2702 wireless_mode = WIRELESS_MODE_B;
2703 }
2704 }
2705#ifdef TO_DO_LIST
2706 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2707#endif
2708 priv->ieee80211->mode = wireless_mode;
2709
2710 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2711 priv->ieee80211->pHTInfo->bEnableHT = 1;
2712 else
2713 priv->ieee80211->pHTInfo->bEnableHT = 0;
2714 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2715 rtl8192_refresh_supportrate(priv);
2716
2717}
2718
2719static void rtl8192_init_priv_variable(struct net_device* dev)
2720{
2721 struct r8192_priv *priv = ieee80211_priv(dev);
2722 u8 i;
2723 priv->card_8192 = NIC_8192U;
2724 priv->chan = 1;
2725 priv->ieee80211->mode = WIRELESS_MODE_AUTO;
2726 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2727 priv->ieee80211->ieee_up=0;
2728 priv->retry_rts = DEFAULT_RETRY_RTS;
2729 priv->retry_data = DEFAULT_RETRY_DATA;
2730 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2731 priv->ieee80211->rate = 110;
2732 priv->ieee80211->short_slot = 1;
2733 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2734 priv->CckPwEnl = 6;
2735
2736 priv->IrpPendingCount = 1;
2737 priv->ResetProgress = RESET_TYPE_NORESET;
2738 priv->bForcedSilentReset = 0;
2739 priv->bDisableNormalResetCheck = false;
2740 priv->force_reset = false;
2741
2742 priv->ieee80211->FwRWRF = 0;
2743 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2744 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2745 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2746 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2747 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2748 IEEE_SOFTMAC_BEACONS;
2749
2750 priv->ieee80211->active_scan = 1;
2751 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2752 priv->ieee80211->host_encrypt = 1;
2753 priv->ieee80211->host_decrypt = 1;
2754 priv->ieee80211->start_send_beacons = NULL;
2755 priv->ieee80211->stop_send_beacons = NULL;
2756 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2757 priv->ieee80211->set_chan = rtl8192_set_chan;
2758 priv->ieee80211->link_change = rtl8192_link_change;
2759 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2760 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2761 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2762 priv->ieee80211->init_wmmparam_flag = 0;
2763 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2764 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2765 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2766 priv->ieee80211->qos_support = 1;
2767
2768
2769
2770 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2771 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2772 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2773
2774 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2775 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2776 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2777
2778 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2779 priv->card_type = USB;
2780#ifdef TO_DO_LIST
2781 if(Adapter->bInHctTest)
2782 {
2783 pHalData->ShortRetryLimit = 7;
2784 pHalData->LongRetryLimit = 7;
2785 }
2786#endif
2787 {
2788 priv->ShortRetryLimit = 0x30;
2789 priv->LongRetryLimit = 0x30;
2790 }
2791 priv->EarlyRxThreshold = 7;
2792 priv->enable_gpio0 = 0;
2793 priv->TransmitConfig =
2794
2795
2796 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)|
2797 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)|
2798 (priv->LongRetryLimit<<TCR_LRL_OFFSET) |
2799 (false ? TCR_SAT: 0);
2800#ifdef TO_DO_LIST
2801 if(Adapter->bInHctTest)
2802 pHalData->ReceiveConfig = pHalData->CSMethod |
2803 RCR_AMF | RCR_ADF |
2804
2805 RCR_ACF |
2806 RCR_AB | RCR_AM | RCR_APM |
2807 RCR_AICV | RCR_ACRC32 |
2808 ((u32)7<<RCR_MXDMA_OFFSET) |
2809 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) |
2810 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
2811 else
2812
2813#endif
2814 priv->ReceiveConfig =
2815 RCR_AMF | RCR_ADF |
2816 RCR_ACF |
2817 RCR_AB | RCR_AM | RCR_APM |
2818
2819 ((u32)7<<RCR_MXDMA_OFFSET)|
2820 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) |
2821 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
2822
2823 priv->AcmControl = 0;
2824 priv->pFirmware = kmalloc(sizeof(rt_firmware), GFP_KERNEL);
2825 if (priv->pFirmware)
2826 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2827
2828
2829 skb_queue_head_init(&priv->rx_queue);
2830 skb_queue_head_init(&priv->skb_queue);
2831
2832
2833 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2834 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2835 }
2836 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2837 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2838 }
2839 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2840 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
2841 }
2842 priv->rf_set_chan = rtl8192_phy_SwChnl;
2843}
2844
2845
2846static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2847{
2848 spin_lock_init(&priv->tx_lock);
2849 spin_lock_init(&priv->irq_lock);
2850
2851 sema_init(&priv->wx_sem,1);
2852 sema_init(&priv->rf_sem,1);
2853 mutex_init(&priv->mutex);
2854}
2855
2856extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2857
2858void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2859
2860#define DRV_NAME "wlan0"
2861static void rtl8192_init_priv_task(struct net_device* dev)
2862{
2863 struct r8192_priv *priv = ieee80211_priv(dev);
2864
2865#ifdef PF_SYNCTHREAD
2866 priv->priv_wq = create_workqueue(DRV_NAME,0);
2867#else
2868 priv->priv_wq = create_workqueue(DRV_NAME);
2869#endif
2870
2871 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2872
2873
2874 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2875 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2876
2877 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2878 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2879 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2880
2881
2882 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2883
2884 tasklet_init(&priv->irq_rx_tasklet,
2885 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2886 (unsigned long)priv);
2887}
2888
2889static void rtl8192_get_eeprom_size(struct net_device* dev)
2890{
2891 u16 curCR = 0;
2892 struct r8192_priv *priv = ieee80211_priv(dev);
2893 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2894 curCR = read_nic_word_E(dev,EPROM_CMD);
2895 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2896
2897 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2898 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2899}
2900
2901
2902static inline u16 endian_swap(u16* data)
2903{
2904 u16 tmp = *data;
2905 *data = (tmp >> 8) | (tmp << 8);
2906 return *data;
2907}
2908static void rtl8192_read_eeprom_info(struct net_device* dev)
2909{
2910 u16 wEPROM_ID = 0;
2911 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2912 u8 bLoad_From_EEPOM = false;
2913 struct r8192_priv *priv = ieee80211_priv(dev);
2914 u16 tmpValue = 0;
2915 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2916 wEPROM_ID = eprom_read(dev, 0);
2917 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2918
2919 if (wEPROM_ID != RTL8190_EEPROM_ID)
2920 {
2921 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2922 }
2923 else
2924 bLoad_From_EEPOM = true;
2925
2926 if (bLoad_From_EEPOM)
2927 {
2928 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2929 priv->eeprom_vid = endian_swap(&tmpValue);
2930 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2931 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2932 priv->eeprom_ChannelPlan =((tmpValue&0xff00)>>8);
2933 priv->btxpowerdata_readfromEEPORM = true;
2934 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2935 }
2936 else
2937 {
2938 priv->eeprom_vid = 0;
2939 priv->eeprom_pid = 0;
2940 priv->card_8192_version = VERSION_819xU_B;
2941 priv->eeprom_ChannelPlan = 0;
2942 priv->eeprom_CustomerID = 0;
2943 }
2944 RT_TRACE(COMP_EPROM, "vid:0x%4x, pid:0x%4x, CustomID:0x%2x, ChanPlan:0x%x\n", priv->eeprom_vid, priv->eeprom_pid, priv->eeprom_CustomerID, priv->eeprom_ChannelPlan);
2945
2946 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2947 if (bLoad_From_EEPOM)
2948 {
2949 int i;
2950 for (i=0; i<6; i+=2)
2951 {
2952 u16 tmp = 0;
2953 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2954 *(u16*)(&dev->dev_addr[i]) = tmp;
2955 }
2956 }
2957 else
2958 {
2959 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2960
2961 }
2962 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2963 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2964 priv->rf_chip = RF_8256;
2965
2966 if (priv->card_8192_version == (u8)VERSION_819xU_A)
2967 {
2968
2969 if (bLoad_From_EEPOM)
2970 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2971 else
2972 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2973 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2974
2975 if (bLoad_From_EEPOM)
2976 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2977 else
2978 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2979 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2980
2981 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2982
2983 if (bLoad_From_EEPOM)
2984 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2985 else
2986 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2987 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2988
2989 if (bLoad_From_EEPOM)
2990 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2991 else
2992 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2993 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2994
2995 if (bLoad_From_EEPOM)
2996 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2997 else
2998 priv->EEPROM_Def_Ver = 1;
2999 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
3000 if (priv->EEPROM_Def_Ver == 0)
3001 {
3002 int i;
3003 if (bLoad_From_EEPOM)
3004 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
3005 else
3006 priv->EEPROMTxPowerLevelCCK = 0x10;
3007 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
3008 for (i=0; i<3; i++)
3009 {
3010 if (bLoad_From_EEPOM)
3011 {
3012 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
3013 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
3014 tmpValue = tmpValue & 0x00ff;
3015 else
3016 tmpValue = (tmpValue & 0xff00) >> 8;
3017 }
3018 else
3019 tmpValue = 0x10;
3020 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
3021 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
3022 }
3023 }
3024 else if (priv->EEPROM_Def_Ver == 1)
3025 {
3026 if (bLoad_From_EEPOM)
3027 {
3028 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
3029 tmpValue = (tmpValue & 0xff00) >> 8;
3030 }
3031 else
3032 tmpValue = 0x10;
3033 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
3034
3035 if (bLoad_From_EEPOM)
3036 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
3037 else
3038 tmpValue = 0x1010;
3039 *((u16*)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
3040 if (bLoad_From_EEPOM)
3041 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
3042 else
3043 tmpValue = 0x1010;
3044 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
3045 if (bLoad_From_EEPOM)
3046 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
3047 else
3048 tmpValue = 0x10;
3049 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
3050 }
3051
3052
3053
3054 {
3055 int i;
3056 for (i=0; i<14; i++)
3057 {
3058 if (i<=3)
3059 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
3060 else if (i>=4 && i<=9)
3061 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
3062 else
3063 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
3064 }
3065
3066 for (i=0; i<14; i++)
3067 {
3068 if (priv->EEPROM_Def_Ver == 0)
3069 {
3070 if (i<=3)
3071 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3072 else if (i>=4 && i<=9)
3073 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
3074 else
3075 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3076 }
3077 else if (priv->EEPROM_Def_Ver == 1)
3078 {
3079 if (i<=3)
3080 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
3081 else if (i>=4 && i<=9)
3082 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
3083 else
3084 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
3085 }
3086 }
3087 }
3088 priv->TxPowerDiff = priv->EEPROMPwDiff;
3089
3090 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
3091
3092 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
3093
3094 priv->CrystalCap = priv->EEPROMCrystalCap;
3095
3096
3097 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
3098 }
3099
3100
3101 switch(priv->eeprom_CustomerID)
3102 {
3103 case EEPROM_CID_RUNTOP:
3104 priv->CustomerID = RT_CID_819x_RUNTOP;
3105 break;
3106
3107 case EEPROM_CID_DLINK:
3108 priv->CustomerID = RT_CID_DLINK;
3109 break;
3110
3111 default:
3112 priv->CustomerID = RT_CID_DEFAULT;
3113 break;
3114
3115 }
3116
3117 switch(priv->CustomerID)
3118 {
3119 case RT_CID_819x_RUNTOP:
3120 priv->LedStrategy = SW_LED_MODE2;
3121 break;
3122
3123 case RT_CID_DLINK:
3124 priv->LedStrategy = SW_LED_MODE4;
3125 break;
3126
3127 default:
3128 priv->LedStrategy = SW_LED_MODE0;
3129 break;
3130
3131 }
3132
3133
3134 if(priv->rf_type == RF_1T2R)
3135 {
3136 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
3137 }
3138 else
3139 {
3140 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
3141 }
3142
3143
3144
3145 init_rate_adaptive(dev);
3146
3147
3148 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
3149 return;
3150}
3151
3152short rtl8192_get_channel_map(struct net_device * dev)
3153{
3154 struct r8192_priv *priv = ieee80211_priv(dev);
3155 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
3156 printk("rtl8180_init:Error channel plan! Set to default.\n");
3157 priv->ChannelPlan= 0;
3158 }
3159 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3160
3161 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3162 return 0;
3163}
3164
3165short rtl8192_init(struct net_device *dev)
3166{
3167
3168 struct r8192_priv *priv = ieee80211_priv(dev);
3169
3170 memset(&(priv->stats),0,sizeof(struct Stats));
3171 memset(priv->txqueue_to_outpipemap,0,9);
3172#ifdef PIPE12
3173 {
3174 int i=0;
3175 u8 queuetopipe[]={3,2,1,0,4,8,7,6,5};
3176 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3177
3178
3179
3180 }
3181#else
3182 {
3183 u8 queuetopipe[]={3,2,1,0,4,4,0,4,4};
3184 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3185
3186
3187
3188 }
3189#endif
3190 rtl8192_init_priv_variable(dev);
3191 rtl8192_init_priv_lock(priv);
3192 rtl8192_init_priv_task(dev);
3193 rtl8192_get_eeprom_size(dev);
3194 rtl8192_read_eeprom_info(dev);
3195 rtl8192_get_channel_map(dev);
3196 init_hal_dm(dev);
3197 init_timer(&priv->watch_dog_timer);
3198 priv->watch_dog_timer.data = (unsigned long)dev;
3199 priv->watch_dog_timer.function = watch_dog_timer_callback;
3200 if(rtl8192_usb_initendpoints(dev)!=0){
3201 DMESG("Endopoints initialization failed");
3202 return -ENOMEM;
3203 }
3204
3205
3206#ifdef DEBUG_EPROM
3207 dump_eprom(dev);
3208#endif
3209 return 0;
3210}
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220void rtl8192_hwconfig(struct net_device* dev)
3221{
3222 u32 regRATR = 0, regRRSR = 0;
3223 u8 regBwOpMode = 0, regTmp = 0;
3224 struct r8192_priv *priv = ieee80211_priv(dev);
3225
3226
3227
3228 switch(priv->ieee80211->mode)
3229 {
3230 case WIRELESS_MODE_B:
3231 regBwOpMode = BW_OPMODE_20MHZ;
3232 regRATR = RATE_ALL_CCK;
3233 regRRSR = RATE_ALL_CCK;
3234 break;
3235 case WIRELESS_MODE_A:
3236 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3237 regRATR = RATE_ALL_OFDM_AG;
3238 regRRSR = RATE_ALL_OFDM_AG;
3239 break;
3240 case WIRELESS_MODE_G:
3241 regBwOpMode = BW_OPMODE_20MHZ;
3242 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3243 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3244 break;
3245 case WIRELESS_MODE_AUTO:
3246#ifdef TO_DO_LIST
3247 if (Adapter->bInHctTest)
3248 {
3249 regBwOpMode = BW_OPMODE_20MHZ;
3250 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3251 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3252 }
3253 else
3254#endif
3255 {
3256 regBwOpMode = BW_OPMODE_20MHZ;
3257 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3258 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3259 }
3260 break;
3261 case WIRELESS_MODE_N_24G:
3262
3263
3264 regBwOpMode = BW_OPMODE_20MHZ;
3265 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3266 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3267 break;
3268 case WIRELESS_MODE_N_5G:
3269 regBwOpMode = BW_OPMODE_5G;
3270 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3271 regRRSR = RATE_ALL_OFDM_AG;
3272 break;
3273 }
3274
3275 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3276 {
3277 u32 ratr_value = 0;
3278 ratr_value = regRATR;
3279 if (priv->rf_type == RF_1T2R)
3280 {
3281 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3282 }
3283 write_nic_dword(dev, RATR0, ratr_value);
3284 write_nic_byte(dev, UFWP, 1);
3285 }
3286 regTmp = read_nic_byte(dev, 0x313);
3287 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3288 write_nic_dword(dev, RRSR, regRRSR);
3289
3290
3291
3292
3293 write_nic_word(dev, RETRY_LIMIT,
3294 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
3295 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305}
3306
3307
3308
3309bool rtl8192_adapter_start(struct net_device *dev)
3310{
3311 struct r8192_priv *priv = ieee80211_priv(dev);
3312 u32 dwRegRead = 0;
3313 bool init_status = true;
3314 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3315 priv->Rf_Mode = RF_OP_By_SW_3wire;
3316
3317 write_nic_byte_E(dev, 0x5f, 0x80);
3318 mdelay(50);
3319 write_nic_byte_E(dev, 0x5f, 0xf0);
3320 write_nic_byte_E(dev, 0x5d, 0x00);
3321 write_nic_byte_E(dev, 0x5e, 0x80);
3322 write_nic_byte(dev, 0x17, 0x37);
3323 mdelay(10);
3324
3325 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3326
3327
3328 dwRegRead = read_nic_dword(dev, CPU_GEN);
3329 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3330 dwRegRead |= CPU_GEN_SYSTEM_RESET;
3331 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3332 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
3333 else
3334 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3335
3336 write_nic_dword(dev, CPU_GEN, dwRegRead);
3337
3338
3339 rtl8192_BBConfig(dev);
3340
3341
3342 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
3343
3344
3345 dwRegRead = read_nic_dword(dev, CPU_GEN);
3346 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
3347 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3348 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
3349 dwRegRead |= CPU_CCK_LOOPBACK;
3350 else
3351 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __FUNCTION__, priv->LoopbackMode);
3352
3353 write_nic_dword(dev, CPU_GEN, dwRegRead);
3354
3355
3356 udelay(500);
3357
3358
3359 write_nic_byte_E(dev, 0x5f, (read_nic_byte_E(dev, 0x5f)|0x20));
3360
3361
3362 rtl8192_hwconfig(dev);
3363
3364
3365 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3366
3367
3368 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3369 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3370
3371
3372 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3373
3374
3375 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3376 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3377 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3378 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3379 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |\
3380 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
3381 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3382 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
3383
3384 );
3385 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3386
3387
3388
3389 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3390
3391
3392 if(priv->ResetProgress == RESET_TYPE_NORESET)
3393 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3394 if(priv->ResetProgress == RESET_TYPE_NORESET){
3395 CamResetAllEntry(dev);
3396 {
3397 u8 SECR_value = 0x0;
3398 SECR_value |= SCR_TxEncEnable;
3399 SECR_value |= SCR_RxDecEnable;
3400 SECR_value |= SCR_NoSKMC;
3401 write_nic_byte(dev, SECR, SECR_value);
3402 }
3403 }
3404
3405
3406 write_nic_word(dev, ATIMWND, 2);
3407 write_nic_word(dev, BCN_INTERVAL, 100);
3408
3409 {
3410#define DEFAULT_EDCA 0x005e4332
3411 int i;
3412 for (i=0; i<QOS_QUEUE_NUM; i++)
3413 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
3414 }
3415#ifdef USB_RX_AGGREGATION_SUPPORT
3416
3417 if(priv->ResetProgress == RESET_TYPE_NORESET)
3418 {
3419 u32 ulValue;
3420 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
3421 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
3422 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
3423
3424
3425
3426
3427
3428 write_nic_dword(dev, 0x1a8, ulValue);
3429 priv->bCurrentRxAggrEnable = true;
3430 }
3431#endif
3432
3433 rtl8192_phy_configmac(dev);
3434
3435 if (priv->card_8192_version == (u8) VERSION_819xU_A)
3436 {
3437 rtl8192_phy_getTxPower(dev);
3438 rtl8192_phy_setTxPower(dev, priv->chan);
3439 }
3440
3441
3442 init_status = init_firmware(dev);
3443 if(!init_status)
3444 {
3445 RT_TRACE(COMP_ERR,"ERR!!! %s(): Firmware download is failed\n", __FUNCTION__);
3446 return init_status;
3447 }
3448 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __FUNCTION__);
3449
3450#ifdef TO_DO_LIST
3451if(Adapter->ResetProgress == RESET_TYPE_NORESET)
3452 {
3453 if(pMgntInfo->RegRfOff == TRUE)
3454 {
3455 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
3456 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
3457
3458 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3459 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3460 }
3461 else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS)
3462 {
3463 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
3464 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3465 }
3466 else
3467 {
3468 pHalData->eRFPowerState = eRfOn;
3469 pMgntInfo->RfOffReason = 0;
3470 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
3471 }
3472 }
3473 else
3474 {
3475 if(pHalData->eRFPowerState == eRfOff)
3476 {
3477 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3478
3479 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3480 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3481 }
3482 }
3483#endif
3484
3485 if(priv->ResetProgress == RESET_TYPE_NORESET){
3486 rtl8192_phy_RFConfig(dev);
3487 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __FUNCTION__);
3488 }
3489
3490
3491 if(priv->ieee80211->FwRWRF)
3492
3493 priv->Rf_Mode = RF_OP_By_FW;
3494 else
3495 priv->Rf_Mode = RF_OP_By_SW_3wire;
3496
3497
3498 rtl8192_phy_updateInitGain(dev);
3499
3500 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3501 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3502
3503 if(priv->ResetProgress == RESET_TYPE_NORESET)
3504 {
3505
3506 u8 tmpvalue = read_nic_byte(dev, 0x301);
3507 if(tmpvalue ==0x03)
3508 {
3509 priv->bDcut = TRUE;
3510 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
3511 }
3512 else
3513 {
3514 priv->bDcut = FALSE;
3515 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
3516 }
3517 dm_initialize_txpower_tracking(dev);
3518
3519 if(priv->bDcut == TRUE)
3520 {
3521 u32 i, TempCCk;
3522 u32 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3523
3524 for(i = 0; i<TxBBGainTableLength; i++)
3525 {
3526 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3527 {
3528 priv->rfa_txpowertrackingindex= (u8)i;
3529 priv->rfa_txpowertrackingindex_real= (u8)i;
3530 priv->rfa_txpowertracking_default= priv->rfa_txpowertrackingindex;
3531 break;
3532 }
3533 }
3534
3535 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3536
3537 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3538 {
3539
3540 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3541 {
3542 priv->cck_present_attentuation_20Mdefault=(u8) i;
3543 break;
3544 }
3545 }
3546 priv->cck_present_attentuation_40Mdefault= 0;
3547 priv->cck_present_attentuation_difference= 0;
3548 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
3549
3550
3551 }
3552 }
3553 write_nic_byte(dev, 0x87, 0x0);
3554
3555
3556 return init_status;
3557}
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567static struct net_device_stats *rtl8192_stats(struct net_device *dev)
3568{
3569 struct r8192_priv *priv = ieee80211_priv(dev);
3570
3571 return &priv->ieee80211->stats;
3572}
3573
3574bool
3575HalTxCheckStuck819xUsb(
3576 struct net_device *dev
3577 )
3578{
3579 struct r8192_priv *priv = ieee80211_priv(dev);
3580 u16 RegTxCounter = read_nic_word(dev, 0x128);
3581 bool bStuck = FALSE;
3582 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3583 if(priv->TxCounter==RegTxCounter)
3584 bStuck = TRUE;
3585
3586 priv->TxCounter = RegTxCounter;
3587
3588 return bStuck;
3589}
3590
3591
3592
3593
3594
3595RESET_TYPE
3596TxCheckStuck(struct net_device *dev)
3597{
3598 struct r8192_priv *priv = ieee80211_priv(dev);
3599 u8 QueueID;
3600
3601
3602 bool bCheckFwTxCnt = false;
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
3613 {
3614 if(QueueID == TXCMD_QUEUE)
3615 continue;
3616#ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3617 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_drv_aggQ[QueueID]) == 0))
3618#else
3619 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
3620#endif
3621 continue;
3622
3623 bCheckFwTxCnt = true;
3624 }
3625
3626
3627
3628 if(bCheckFwTxCnt)
3629 {
3630 if(HalTxCheckStuck819xUsb(dev))
3631 {
3632 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3633 return RESET_TYPE_SILENT;
3634 }
3635 }
3636 return RESET_TYPE_NORESET;
3637}
3638
3639bool
3640HalRxCheckStuck819xUsb(struct net_device *dev)
3641{
3642 u16 RegRxCounter = read_nic_word(dev, 0x130);
3643 struct r8192_priv *priv = ieee80211_priv(dev);
3644 bool bStuck = FALSE;
3645 static u8 rx_chk_cnt = 0;
3646 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3647
3648
3649 rx_chk_cnt++;
3650 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3651 {
3652 rx_chk_cnt = 0;
3653 }
3654 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3655 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3656 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3657 {
3658 if(rx_chk_cnt < 2)
3659 {
3660 return bStuck;
3661 }
3662 else
3663 {
3664 rx_chk_cnt = 0;
3665 }
3666 }
3667 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3668 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3669 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3670 {
3671 if(rx_chk_cnt < 4)
3672 {
3673
3674 return bStuck;
3675 }
3676 else
3677 {
3678 rx_chk_cnt = 0;
3679
3680 }
3681 }
3682 else
3683 {
3684 if(rx_chk_cnt < 8)
3685 {
3686
3687 return bStuck;
3688 }
3689 else
3690 {
3691 rx_chk_cnt = 0;
3692
3693 }
3694 }
3695
3696 if(priv->RxCounter==RegRxCounter)
3697 bStuck = TRUE;
3698
3699 priv->RxCounter = RegRxCounter;
3700
3701 return bStuck;
3702}
3703
3704RESET_TYPE
3705RxCheckStuck(struct net_device *dev)
3706{
3707 struct r8192_priv *priv = ieee80211_priv(dev);
3708
3709 bool bRxCheck = FALSE;
3710
3711
3712
3713
3714 if(priv->IrpPendingCount > 1)
3715 bRxCheck = TRUE;
3716
3717
3718
3719 if(bRxCheck)
3720 {
3721 if(HalRxCheckStuck819xUsb(dev))
3722 {
3723 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3724 return RESET_TYPE_SILENT;
3725 }
3726 }
3727 return RESET_TYPE_NORESET;
3728}
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743RESET_TYPE
3744rtl819x_ifcheck_resetornot(struct net_device *dev)
3745{
3746 struct r8192_priv *priv = ieee80211_priv(dev);
3747 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3748 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3749 RT_RF_POWER_STATE rfState;
3750
3751 rfState = priv->ieee80211->eRFPowerState;
3752
3753 TxResetType = TxCheckStuck(dev);
3754 if( rfState != eRfOff ||
3755
3756 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3757 {
3758
3759
3760
3761
3762
3763
3764
3765
3766 RxResetType = RxCheckStuck(dev);
3767 }
3768 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3769 return RESET_TYPE_NORMAL;
3770 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
3771 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
3772 return RESET_TYPE_SILENT;
3773 }
3774 else
3775 return RESET_TYPE_NORESET;
3776
3777}
3778
3779void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
3780int _rtl8192_up(struct net_device *dev);
3781int rtl8192_close(struct net_device *dev);
3782
3783
3784
3785void
3786CamRestoreAllEntry( struct net_device *dev)
3787{
3788 u8 EntryId = 0;
3789 struct r8192_priv *priv = ieee80211_priv(dev);
3790 u8* MacAddr = priv->ieee80211->current_network.bssid;
3791
3792 static u8 CAM_CONST_ADDR[4][6] = {
3793 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3794 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3795 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3796 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3797 static u8 CAM_CONST_BROAD[] =
3798 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3799
3800 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3801
3802
3803 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3804 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3805 {
3806
3807 for(EntryId=0; EntryId<4; EntryId++)
3808 {
3809 {
3810 MacAddr = CAM_CONST_ADDR[EntryId];
3811 setKey(dev,
3812 EntryId ,
3813 EntryId,
3814 priv->ieee80211->pairwise_key_type,
3815 MacAddr,
3816 0,
3817 NULL);
3818 }
3819 }
3820
3821 }
3822 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3823 {
3824
3825 {
3826 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3827 setKey(dev,
3828 4,
3829 0,
3830 priv->ieee80211->pairwise_key_type,
3831 (u8*)dev->dev_addr,
3832 0,
3833 NULL);
3834 else
3835 setKey(dev,
3836 4,
3837 0,
3838 priv->ieee80211->pairwise_key_type,
3839 MacAddr,
3840 0,
3841 NULL);
3842 }
3843 }
3844 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3845 {
3846
3847 {
3848 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3849 setKey(dev,
3850 4,
3851 0,
3852 priv->ieee80211->pairwise_key_type,
3853 (u8*)dev->dev_addr,
3854 0,
3855 NULL);
3856 else
3857 setKey(dev,
3858 4,
3859 0,
3860 priv->ieee80211->pairwise_key_type,
3861 MacAddr,
3862 0,
3863 NULL);
3864 }
3865 }
3866
3867
3868
3869 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3870 {
3871 MacAddr = CAM_CONST_BROAD;
3872 for(EntryId=1 ; EntryId<4 ; EntryId++)
3873 {
3874 {
3875 setKey(dev,
3876 EntryId,
3877 EntryId,
3878 priv->ieee80211->group_key_type,
3879 MacAddr,
3880 0,
3881 NULL);
3882 }
3883 }
3884 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3885 setKey(dev,
3886 0,
3887 0,
3888 priv->ieee80211->group_key_type,
3889 CAM_CONST_ADDR[0],
3890 0,
3891 NULL);
3892 }
3893 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3894 {
3895 MacAddr = CAM_CONST_BROAD;
3896 for(EntryId=1; EntryId<4 ; EntryId++)
3897 {
3898 {
3899 setKey(dev,
3900 EntryId ,
3901 EntryId,
3902 priv->ieee80211->group_key_type,
3903 MacAddr,
3904 0,
3905 NULL);
3906 }
3907 }
3908
3909 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3910 setKey(dev,
3911 0 ,
3912 0,
3913 priv->ieee80211->group_key_type,
3914 CAM_CONST_ADDR[0],
3915 0,
3916 NULL);
3917 }
3918}
3919
3920
3921
3922
3923
3924
3925void
3926rtl819x_ifsilentreset(struct net_device *dev)
3927{
3928
3929 struct r8192_priv *priv = ieee80211_priv(dev);
3930 u8 reset_times = 0;
3931 int reset_status = 0;
3932 struct ieee80211_device *ieee = priv->ieee80211;
3933
3934
3935
3936
3937
3938 if(priv->ResetProgress==RESET_TYPE_NORESET)
3939 {
3940RESET_START:
3941
3942 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3943
3944
3945 priv->ResetProgress = RESET_TYPE_SILENT;
3946
3947 down(&priv->wx_sem);
3948 if(priv->up == 0)
3949 {
3950 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3951 up(&priv->wx_sem);
3952 return ;
3953 }
3954 priv->up = 0;
3955 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3956
3957
3958
3959 rtl8192_rtx_disable(dev);
3960 rtl8192_cancel_deferred_work(priv);
3961 deinit_hal_dm(dev);
3962 del_timer_sync(&priv->watch_dog_timer);
3963
3964 ieee->sync_scan_hurryup = 1;
3965 if(ieee->state == IEEE80211_LINKED)
3966 {
3967 down(&ieee->wx_sem);
3968 printk("ieee->state is IEEE80211_LINKED\n");
3969 ieee80211_stop_send_beacons(priv->ieee80211);
3970 del_timer_sync(&ieee->associate_timer);
3971 cancel_delayed_work(&ieee->associate_retry_wq);
3972 ieee80211_stop_scan(ieee);
3973 netif_carrier_off(dev);
3974 up(&ieee->wx_sem);
3975 }
3976 else{
3977 printk("ieee->state is NOT LINKED\n");
3978 ieee80211_softmac_stop_protocol(priv->ieee80211); }
3979 up(&priv->wx_sem);
3980 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3981
3982 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
3983 reset_status = _rtl8192_up(dev);
3984
3985 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3986 if(reset_status == -EAGAIN)
3987 {
3988 if(reset_times < 3)
3989 {
3990 reset_times++;
3991 goto RESET_START;
3992 }
3993 else
3994 {
3995 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
3996 }
3997 }
3998 ieee->is_silent_reset = 1;
3999 EnableHWSecurityConfig8192(dev);
4000 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4001 {
4002 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4003
4004 queue_work(ieee->wq, &ieee->associate_complete_wq);
4005
4006 }
4007 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4008 {
4009 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4010 ieee->link_change(ieee->dev);
4011
4012
4013
4014 ieee80211_start_send_beacons(ieee);
4015
4016 if (ieee->data_hard_resume)
4017 ieee->data_hard_resume(ieee->dev);
4018 netif_carrier_on(ieee->dev);
4019 }
4020
4021 CamRestoreAllEntry(dev);
4022
4023 priv->ResetProgress = RESET_TYPE_NORESET;
4024 priv->reset_count++;
4025
4026 priv->bForcedSilentReset =false;
4027 priv->bResetInProgress = false;
4028
4029
4030 write_nic_byte(dev, UFWP, 1);
4031 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4032 }
4033}
4034
4035void CAM_read_entry(
4036 struct net_device *dev,
4037 u32 iIndex
4038)
4039{
4040 u32 target_command=0;
4041 u32 target_content=0;
4042 u8 entry_i=0;
4043 u32 ulStatus;
4044 s32 i=100;
4045
4046 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
4047 {
4048
4049 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
4050 target_command= target_command | BIT31;
4051
4052
4053
4054 while((i--)>=0)
4055 {
4056 ulStatus = read_nic_dword(dev, RWCAM);
4057 if(ulStatus & BIT31){
4058 continue;
4059 }
4060 else{
4061 break;
4062 }
4063 }
4064 write_nic_dword(dev, RWCAM, target_command);
4065 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
4066
4067 target_content = read_nic_dword(dev, RCAMO);
4068 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
4069
4070 }
4071 printk("\n");
4072}
4073
4074void rtl819x_update_rxcounts(
4075 struct r8192_priv *priv,
4076 u32* TotalRxBcnNum,
4077 u32* TotalRxDataNum
4078)
4079{
4080 u16 SlotIndex;
4081 u8 i;
4082
4083 *TotalRxBcnNum = 0;
4084 *TotalRxDataNum = 0;
4085
4086 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4087 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4088 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4089 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4090 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4091 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4092 }
4093}
4094
4095
4096extern void rtl819x_watchdog_wqcallback(struct work_struct *work)
4097{
4098 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4099 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4100 struct net_device *dev = priv->ieee80211->dev;
4101 struct ieee80211_device* ieee = priv->ieee80211;
4102 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4103 static u8 check_reset_cnt=0;
4104 bool bBusyTraffic = false;
4105
4106 if(!priv->up)
4107 return;
4108 hal_dm_watchdog(dev);
4109
4110 {
4111 if(ieee->state == IEEE80211_LINKED)
4112 {
4113 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
4114 ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
4115 bBusyTraffic = true;
4116 }
4117 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4118 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4119 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4120 }
4121 }
4122
4123 {
4124 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
4125 {
4126 u32 TotalRxBcnNum = 0;
4127 u32 TotalRxDataNum = 0;
4128
4129 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4130 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4131 {
4132 #ifdef TODO
4133 if(rfState == eRfOff)
4134 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4135 #endif
4136 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4137
4138 priv->ieee80211->state = IEEE80211_ASSOCIATING;
4139 notify_wx_assoc_event(priv->ieee80211);
4140 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4141 priv->ieee80211->link_change(dev);
4142 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
4143
4144 }
4145 }
4146 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
4147 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
4148 }
4149
4150
4151 if(check_reset_cnt++ >= 3)
4152 {
4153 ResetType = rtl819x_ifcheck_resetornot(dev);
4154 check_reset_cnt = 3;
4155
4156 }
4157
4158 if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
4159 (priv->bForcedSilentReset ||
4160 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))))
4161 {
4162 RT_TRACE(COMP_RESET,"%s():priv->force_reset is %d,priv->ResetProgress is %d, priv->bForcedSilentReset is %d,priv->bDisableNormalResetCheck is %d,ResetType is %d\n",__FUNCTION__,priv->force_reset,priv->ResetProgress,priv->bForcedSilentReset,priv->bDisableNormalResetCheck,ResetType);
4163 rtl819x_ifsilentreset(dev);
4164 }
4165 priv->force_reset = false;
4166 priv->bForcedSilentReset = false;
4167 priv->bResetInProgress = false;
4168 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4169
4170}
4171
4172void watch_dog_timer_callback(unsigned long data)
4173{
4174 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4175
4176 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
4177 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4178}
4179int _rtl8192_up(struct net_device *dev)
4180{
4181 struct r8192_priv *priv = ieee80211_priv(dev);
4182
4183 int init_status = 0;
4184 priv->up=1;
4185 priv->ieee80211->ieee_up=1;
4186 RT_TRACE(COMP_INIT, "Bringing up iface");
4187 init_status = rtl8192_adapter_start(dev);
4188 if(!init_status)
4189 {
4190 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n", __FUNCTION__);
4191 priv->up=priv->ieee80211->ieee_up = 0;
4192 return -EAGAIN;
4193 }
4194 RT_TRACE(COMP_INIT, "start adapter finished\n");
4195 rtl8192_rx_enable(dev);
4196
4197 if(priv->ieee80211->state != IEEE80211_LINKED)
4198 ieee80211_softmac_start_protocol(priv->ieee80211);
4199 ieee80211_reset_queue(priv->ieee80211);
4200 watch_dog_timer_callback((unsigned long) dev);
4201 if(!netif_queue_stopped(dev))
4202 netif_start_queue(dev);
4203 else
4204 netif_wake_queue(dev);
4205
4206 return 0;
4207}
4208
4209
4210int rtl8192_open(struct net_device *dev)
4211{
4212 struct r8192_priv *priv = ieee80211_priv(dev);
4213 int ret;
4214 down(&priv->wx_sem);
4215 ret = rtl8192_up(dev);
4216 up(&priv->wx_sem);
4217 return ret;
4218
4219}
4220
4221
4222int rtl8192_up(struct net_device *dev)
4223{
4224 struct r8192_priv *priv = ieee80211_priv(dev);
4225
4226 if (priv->up == 1) return -1;
4227
4228 return _rtl8192_up(dev);
4229}
4230
4231
4232int rtl8192_close(struct net_device *dev)
4233{
4234 struct r8192_priv *priv = ieee80211_priv(dev);
4235 int ret;
4236
4237 down(&priv->wx_sem);
4238
4239 ret = rtl8192_down(dev);
4240
4241 up(&priv->wx_sem);
4242
4243 return ret;
4244
4245}
4246
4247int rtl8192_down(struct net_device *dev)
4248{
4249 struct r8192_priv *priv = ieee80211_priv(dev);
4250 int i;
4251
4252 if (priv->up == 0) return -1;
4253
4254 priv->up=0;
4255 priv->ieee80211->ieee_up = 0;
4256 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4257
4258 if (!netif_queue_stopped(dev))
4259 netif_stop_queue(dev);
4260
4261 rtl8192_rtx_disable(dev);
4262
4263
4264
4265 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4266 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
4267 }
4268 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4269 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
4270 }
4271
4272 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4273 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
4274 }
4275
4276
4277
4278 rtl8192_cancel_deferred_work(priv);
4279 deinit_hal_dm(dev);
4280 del_timer_sync(&priv->watch_dog_timer);
4281
4282
4283 ieee80211_softmac_stop_protocol(priv->ieee80211);
4284 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4285 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4286
4287 return 0;
4288}
4289
4290
4291void rtl8192_commit(struct net_device *dev)
4292{
4293 struct r8192_priv *priv = ieee80211_priv(dev);
4294 int reset_status = 0;
4295
4296 if (priv->up == 0) return ;
4297 priv->up = 0;
4298
4299 rtl8192_cancel_deferred_work(priv);
4300 del_timer_sync(&priv->watch_dog_timer);
4301
4302
4303 ieee80211_softmac_stop_protocol(priv->ieee80211);
4304
4305
4306 rtl8192_rtx_disable(dev);
4307 reset_status = _rtl8192_up(dev);
4308
4309}
4310
4311
4312
4313
4314
4315
4316void rtl8192_restart(struct work_struct *work)
4317{
4318 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4319 struct net_device *dev = priv->ieee80211->dev;
4320
4321 down(&priv->wx_sem);
4322
4323 rtl8192_commit(dev);
4324
4325 up(&priv->wx_sem);
4326}
4327
4328static void r8192_set_multicast(struct net_device *dev)
4329{
4330 struct r8192_priv *priv = ieee80211_priv(dev);
4331 short promisc;
4332
4333
4334
4335
4336
4337 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4338
4339 if (promisc != priv->promisc)
4340
4341
4342 priv->promisc = promisc;
4343
4344
4345
4346}
4347
4348
4349int r8192_set_mac_adr(struct net_device *dev, void *mac)
4350{
4351 struct r8192_priv *priv = ieee80211_priv(dev);
4352 struct sockaddr *addr = mac;
4353
4354 down(&priv->wx_sem);
4355
4356 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4357
4358 schedule_work(&priv->reset_wq);
4359 up(&priv->wx_sem);
4360
4361 return 0;
4362}
4363
4364
4365int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4366{
4367 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4368 struct iwreq *wrq = (struct iwreq *)rq;
4369 int ret=-1;
4370 struct ieee80211_device *ieee = priv->ieee80211;
4371 u32 key[4];
4372 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4373 struct iw_point *p = &wrq->u.data;
4374 struct ieee_param *ipw = NULL;
4375
4376 down(&priv->wx_sem);
4377
4378
4379 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4380 ret = -EINVAL;
4381 goto out;
4382 }
4383
4384 ipw = kmalloc(p->length, GFP_KERNEL);
4385 if (ipw == NULL){
4386 ret = -ENOMEM;
4387 goto out;
4388 }
4389 if (copy_from_user(ipw, p->pointer, p->length)) {
4390 kfree(ipw);
4391 ret = -EFAULT;
4392 goto out;
4393 }
4394
4395 switch (cmd) {
4396 case RTL_IOCTL_WPA_SUPPLICANT:
4397
4398 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4399 {
4400 if (ipw->u.crypt.set_tx)
4401 {
4402 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4403 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4404 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4405 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4406 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4407 {
4408 if (ipw->u.crypt.key_len == 13)
4409 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4410 else if (ipw->u.crypt.key_len == 5)
4411 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4412 }
4413 else
4414 ieee->pairwise_key_type = KEY_TYPE_NA;
4415
4416 if (ieee->pairwise_key_type)
4417 {
4418 memcpy((u8*)key, ipw->u.crypt.key, 16);
4419 EnableHWSecurityConfig8192(dev);
4420
4421
4422 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4423 if (ieee->auth_mode != 2)
4424 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4425 }
4426 }
4427 else
4428 {
4429 memcpy((u8*)key, ipw->u.crypt.key, 16);
4430 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4431 ieee->group_key_type= KEY_TYPE_CCMP;
4432 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4433 ieee->group_key_type = KEY_TYPE_TKIP;
4434 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4435 {
4436 if (ipw->u.crypt.key_len == 13)
4437 ieee->group_key_type = KEY_TYPE_WEP104;
4438 else if (ipw->u.crypt.key_len == 5)
4439 ieee->group_key_type = KEY_TYPE_WEP40;
4440 }
4441 else
4442 ieee->group_key_type = KEY_TYPE_NA;
4443
4444 if (ieee->group_key_type)
4445 {
4446 setKey( dev,
4447 ipw->u.crypt.idx,
4448 ipw->u.crypt.idx,
4449 ieee->group_key_type,
4450 broadcast_addr,
4451 0,
4452 key);
4453 }
4454 }
4455 }
4456#ifdef JOHN_HWSEC_DEBUG
4457
4458 printk("@@ wrq->u pointer = ");
4459 for(i=0;i<wrq->u.data.length;i++){
4460 if(i%10==0) printk("\n");
4461 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4462 }
4463 printk("\n");
4464#endif
4465 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4466 break;
4467
4468 default:
4469 ret = -EOPNOTSUPP;
4470 break;
4471 }
4472 kfree(ipw);
4473 ipw = NULL;
4474out:
4475 up(&priv->wx_sem);
4476 return ret;
4477}
4478
4479u8 HwRateToMRate90(bool bIsHT, u8 rate)
4480{
4481 u8 ret_rate = 0xff;
4482
4483 if(!bIsHT) {
4484 switch(rate) {
4485 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4486 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4487 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4488 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4489 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4490 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4491 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4492 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4493 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4494 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4495 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4496 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4497
4498 default:
4499 ret_rate = 0xff;
4500 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4501 break;
4502 }
4503
4504 } else {
4505 switch(rate) {
4506 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4507 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4508 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4509 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4510 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4511 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4512 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4513 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4514 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4515 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4516 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4517 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4518 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4519 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4520 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4521 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4522 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4523
4524 default:
4525 ret_rate = 0xff;
4526 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4527 break;
4528 }
4529 }
4530
4531 return ret_rate;
4532}
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4550{
4551 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4552
4553 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4554 stats->mac_time[0] = priv->LastRxDescTSFLow;
4555 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4556 } else {
4557 priv->LastRxDescTSFLow = stats->mac_time[0];
4558 priv->LastRxDescTSFHigh = stats->mac_time[1];
4559 }
4560}
4561
4562
4563
4564long rtl819x_translate_todbm(u8 signal_strength_index )
4565{
4566 long signal_power;
4567
4568
4569 signal_power = (long)((signal_strength_index + 1) >> 1);
4570 signal_power -= 95;
4571
4572 return signal_power;
4573}
4574
4575
4576
4577
4578
4579
4580void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4581{
4582 bool bcheck = false;
4583 u8 rfpath;
4584 u32 nspatial_stream, tmp_val;
4585
4586 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4587 static u32 slide_evm_index=0, slide_evm_statistics=0;
4588 static u32 last_rssi=0, last_evm=0;
4589
4590 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4591 static u32 last_beacon_adc_pwdb=0;
4592
4593 struct ieee80211_hdr_3addr *hdr;
4594 u16 sc ;
4595 unsigned int frag,seq;
4596 hdr = (struct ieee80211_hdr_3addr *)buffer;
4597 sc = le16_to_cpu(hdr->seq_ctl);
4598 frag = WLAN_GET_SEQ_FRAG(sc);
4599 seq = WLAN_GET_SEQ_SEQ(sc);
4600
4601 pcurrent_stats->Seq_Num = seq;
4602
4603
4604
4605 if(!pprevious_stats->bIsAMPDU)
4606 {
4607
4608 bcheck = true;
4609 }else
4610 {
4611 }
4612
4613
4614 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4615 {
4616 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4617 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4618 priv->stats.slide_rssi_total -= last_rssi;
4619 }
4620 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4621
4622 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4623 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4624 slide_rssi_index = 0;
4625
4626
4627 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4628 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4629 pcurrent_stats->rssi = priv->stats.signal_strength;
4630
4631
4632
4633 if(!pprevious_stats->bPacketMatchBSSID)
4634 {
4635 if(!pprevious_stats->bToSelfBA)
4636 return;
4637 }
4638
4639 if(!bcheck)
4640 return;
4641
4642
4643
4644
4645
4646
4647
4648 priv->stats.num_process_phyinfo++;
4649
4650
4651
4652
4653
4654
4655 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
4656 {
4657 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
4658 {
4659 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
4660 continue;
4661
4662
4663 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
4664 {
4665 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
4666
4667 }
4668 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
4669 {
4670 priv->stats.rx_rssi_percentage[rfpath] =
4671 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4672 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4673 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
4674 }
4675 else
4676 {
4677 priv->stats.rx_rssi_percentage[rfpath] =
4678 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4679 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4680 }
4681 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
4682 }
4683 }
4684
4685
4686
4687
4688
4689 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4690 pprevious_stats->bIsCCK? "CCK": "OFDM",
4691 pprevious_stats->RxPWDBAll);
4692
4693 if(pprevious_stats->bPacketBeacon)
4694 {
4695
4696 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4697 {
4698 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
4699 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
4700 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
4701
4702
4703 }
4704 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
4705 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
4706
4707 slide_beacon_adc_pwdb_index++;
4708 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4709 slide_beacon_adc_pwdb_index = 0;
4710 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
4711 if(pprevious_stats->RxPWDBAll >= 3)
4712 pprevious_stats->RxPWDBAll -= 3;
4713 }
4714
4715 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4716 pprevious_stats->bIsCCK? "CCK": "OFDM",
4717 pprevious_stats->RxPWDBAll);
4718
4719
4720 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4721 {
4722 if(priv->undecorated_smoothed_pwdb < 0)
4723 {
4724 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
4725
4726 }
4727 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
4728 {
4729 priv->undecorated_smoothed_pwdb =
4730 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4731 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4732 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
4733 }
4734 else
4735 {
4736 priv->undecorated_smoothed_pwdb =
4737 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4738 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4739 }
4740
4741 }
4742
4743
4744
4745
4746
4747 if(pprevious_stats->SignalQuality == 0)
4748 {
4749 }
4750 else
4751 {
4752 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
4753 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
4754 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
4755 last_evm = priv->stats.slide_evm[slide_evm_index];
4756 priv->stats.slide_evm_total -= last_evm;
4757 }
4758
4759 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
4760
4761 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
4762 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
4763 slide_evm_index = 0;
4764
4765
4766 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
4767 priv->stats.signal_quality = tmp_val;
4768
4769 priv->stats.last_signal_strength_inpercent = tmp_val;
4770 }
4771
4772
4773 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4774 {
4775 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++)
4776 {
4777 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
4778 {
4779 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0)
4780 {
4781 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
4782 }
4783 priv->stats.rx_evm_percentage[nspatial_stream] =
4784 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
4785 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
4786 }
4787 }
4788 }
4789 }
4790
4791
4792}
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810static u8 rtl819x_query_rxpwrpercentage(
4811 char antpower
4812 )
4813{
4814 if ((antpower <= -100) || (antpower >= 20))
4815 {
4816 return 0;
4817 }
4818 else if (antpower >= 0)
4819 {
4820 return 100;
4821 }
4822 else
4823 {
4824 return (100+antpower);
4825 }
4826
4827}
4828
4829static u8
4830rtl819x_evm_dbtopercentage(
4831 char value
4832 )
4833{
4834 char ret_val;
4835
4836 ret_val = value;
4837
4838 if(ret_val >= 0)
4839 ret_val = 0;
4840 if(ret_val <= -33)
4841 ret_val = -33;
4842 ret_val = 0 - ret_val;
4843 ret_val*=3;
4844 if(ret_val == 99)
4845 ret_val = 100;
4846 return(ret_val);
4847}
4848
4849
4850
4851
4852
4853long
4854rtl819x_signal_scale_mapping(
4855 long currsig
4856 )
4857{
4858 long retsig;
4859
4860
4861 if(currsig >= 61 && currsig <= 100)
4862 {
4863 retsig = 90 + ((currsig - 60) / 4);
4864 }
4865 else if(currsig >= 41 && currsig <= 60)
4866 {
4867 retsig = 78 + ((currsig - 40) / 2);
4868 }
4869 else if(currsig >= 31 && currsig <= 40)
4870 {
4871 retsig = 66 + (currsig - 30);
4872 }
4873 else if(currsig >= 21 && currsig <= 30)
4874 {
4875 retsig = 54 + (currsig - 20);
4876 }
4877 else if(currsig >= 5 && currsig <= 20)
4878 {
4879 retsig = 42 + (((currsig - 5) * 2) / 3);
4880 }
4881 else if(currsig == 4)
4882 {
4883 retsig = 36;
4884 }
4885 else if(currsig == 3)
4886 {
4887 retsig = 27;
4888 }
4889 else if(currsig == 2)
4890 {
4891 retsig = 18;
4892 }
4893 else if(currsig == 1)
4894 {
4895 retsig = 9;
4896 }
4897 else
4898 {
4899 retsig = currsig;
4900 }
4901
4902 return retsig;
4903}
4904
4905static void rtl8192_query_rxphystatus(
4906 struct r8192_priv * priv,
4907 struct ieee80211_rx_stats * pstats,
4908 rx_drvinfo_819x_usb * pdrvinfo,
4909 struct ieee80211_rx_stats * precord_stats,
4910 bool bpacket_match_bssid,
4911 bool bpacket_toself,
4912 bool bPacketBeacon,
4913 bool bToSelfBA
4914 )
4915{
4916
4917 phy_sts_ofdm_819xusb_t* pofdm_buf;
4918 phy_sts_cck_819xusb_t * pcck_buf;
4919 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
4920 u8 *prxpkt;
4921 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
4922 char rx_pwr[4], rx_pwr_all=0;
4923
4924 char rx_snrX, rx_evmX;
4925 u8 evm, pwdb_all;
4926 u32 RSSI, total_rssi=0;
4927
4928 u8 is_cck_rate=0;
4929 u8 rf_rx_num = 0;
4930
4931
4932 priv->stats.numqry_phystatus++;
4933
4934 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4935
4936
4937 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4938 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4939 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4940 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;
4941 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4942 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4943
4944 prxpkt = (u8*)pdrvinfo;
4945
4946
4947 prxpkt += sizeof(rx_drvinfo_819x_usb);
4948
4949
4950 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4951 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4952
4953 pstats->RxMIMOSignalQuality[0] = -1;
4954 pstats->RxMIMOSignalQuality[1] = -1;
4955 precord_stats->RxMIMOSignalQuality[0] = -1;
4956 precord_stats->RxMIMOSignalQuality[1] = -1;
4957
4958 if(is_cck_rate)
4959 {
4960
4961
4962
4963
4964
4965
4966
4967 u8 report;
4968
4969 priv->stats.numqry_phystatusCCK++;
4970
4971 if(!priv->bCckHighPower)
4972 {
4973 report = pcck_buf->cck_agc_rpt & 0xc0;
4974 report = report>>6;
4975 switch(report)
4976 {
4977
4978
4979
4980 case 0x3:
4981 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4982 break;
4983 case 0x2:
4984 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4985 break;
4986 case 0x1:
4987 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4988 break;
4989 case 0x0:
4990 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4991 break;
4992 }
4993 }
4994 else
4995 {
4996 report = pcck_buf->cck_agc_rpt & 0x60;
4997 report = report>>5;
4998 switch(report)
4999 {
5000 case 0x3:
5001 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5002 break;
5003 case 0x2:
5004 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5005 break;
5006 case 0x1:
5007 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5008 break;
5009 case 0x0:
5010 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5011 break;
5012 }
5013 }
5014
5015 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5016 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5017 pstats->RecvSignalPower = pwdb_all;
5018
5019
5020
5021
5022
5023 {
5024 u8 sq;
5025
5026 if(pstats->RxPWDBAll > 40)
5027 {
5028 sq = 100;
5029 }else
5030 {
5031 sq = pcck_buf->sq_rpt;
5032
5033 if(pcck_buf->sq_rpt > 64)
5034 sq = 0;
5035 else if (pcck_buf->sq_rpt < 20)
5036 sq = 100;
5037 else
5038 sq = ((64-sq) * 100) / 44;
5039 }
5040 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5041 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5042 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5043 }
5044 }
5045 else
5046 {
5047 priv->stats.numqry_phystatusHT++;
5048
5049
5050
5051 for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
5052 {
5053
5054 if (priv->brfpath_rxenable[i])
5055 rf_rx_num++;
5056 else
5057 continue;
5058
5059 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
5060 continue;
5061
5062
5063
5064 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5065
5066
5067 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5068 rx_snrX = (char)(tmp_rxsnr);
5069
5070 rx_snrX /= 2;
5071 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5072
5073
5074 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5075 total_rssi += RSSI;
5076
5077
5078
5079 {
5080 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5081 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5082 }
5083 }
5084
5085
5086
5087
5088
5089
5090
5091 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5092 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5093
5094 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5095 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5096
5097
5098
5099
5100 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5101 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5102 max_spatial_stream = 2;
5103 else
5104 max_spatial_stream = 1;
5105
5106 for(i=0; i<max_spatial_stream; i++)
5107 {
5108 tmp_rxevm = pofdm_buf->rxevm_X[i];
5109 rx_evmX = (char)(tmp_rxevm);
5110
5111
5112
5113
5114 rx_evmX /= 2;
5115
5116 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5117
5118 {
5119 if(i==0)
5120 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5121 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5122 }
5123 }
5124
5125
5126
5127 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5128 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5129 if(pdrvinfo->BW)
5130 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5131 else
5132 priv->stats.received_bwtype[0]++;
5133 }
5134
5135
5136
5137 if(is_cck_rate)
5138 {
5139 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));
5140
5141 }
5142 else
5143 {
5144
5145
5146 if (rf_rx_num != 0)
5147 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5148 }
5149}
5150
5151void
5152rtl8192_record_rxdesc_forlateruse(
5153 struct ieee80211_rx_stats * psrc_stats,
5154 struct ieee80211_rx_stats * ptarget_stats
5155)
5156{
5157 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5158 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5159 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5160}
5161
5162
5163void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
5164 struct ieee80211_rx_stats * pstats,
5165 rx_drvinfo_819x_usb *pdrvinfo)
5166{
5167
5168 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5169 struct net_device *dev=info->dev;
5170 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5171 bool bpacket_match_bssid, bpacket_toself;
5172 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
5173 static struct ieee80211_rx_stats previous_stats;
5174 struct ieee80211_hdr_3addr *hdr;
5175 u16 fc,type;
5176
5177
5178
5179 u8* tmp_buf;
5180
5181 u8 *praddr;
5182
5183
5184 tmp_buf = (u8*)skb->data;
5185
5186 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5187 fc = le16_to_cpu(hdr->frame_ctl);
5188 type = WLAN_FC_GET_TYPE(fc);
5189 praddr = hdr->addr1;
5190
5191
5192 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5193 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5194 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5195 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5196
5197 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5198 {
5199 bPacketBeacon = true;
5200
5201 }
5202 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5203 {
5204 if((eqMacAddr(praddr,dev->dev_addr)))
5205 bToSelfBA = true;
5206
5207 }
5208
5209
5210
5211 if(bpacket_match_bssid)
5212 {
5213 priv->stats.numpacket_matchbssid++;
5214 }
5215 if(bpacket_toself){
5216 priv->stats.numpacket_toself++;
5217 }
5218
5219
5220
5221
5222
5223 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
5224 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
5225 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5226
5227}
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243void
5244UpdateReceivedRateHistogramStatistics8190(
5245 struct net_device *dev,
5246 struct ieee80211_rx_stats *stats
5247 )
5248{
5249 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5250 u32 rcvType=1;
5251 u32 rateIndex;
5252 u32 preamble_guardinterval;
5253
5254
5255 if(stats->bCRC)
5256 rcvType = 2;
5257 else if(stats->bICV)
5258 rcvType = 3;
5259
5260 if(stats->bShortPreamble)
5261 preamble_guardinterval = 1;
5262 else
5263 preamble_guardinterval = 0;
5264
5265 switch(stats->rate)
5266 {
5267
5268
5269
5270 case MGN_1M: rateIndex = 0; break;
5271 case MGN_2M: rateIndex = 1; break;
5272 case MGN_5_5M: rateIndex = 2; break;
5273 case MGN_11M: rateIndex = 3; break;
5274
5275
5276
5277 case MGN_6M: rateIndex = 4; break;
5278 case MGN_9M: rateIndex = 5; break;
5279 case MGN_12M: rateIndex = 6; break;
5280 case MGN_18M: rateIndex = 7; break;
5281 case MGN_24M: rateIndex = 8; break;
5282 case MGN_36M: rateIndex = 9; break;
5283 case MGN_48M: rateIndex = 10; break;
5284 case MGN_54M: rateIndex = 11; break;
5285
5286
5287
5288 case MGN_MCS0: rateIndex = 12; break;
5289 case MGN_MCS1: rateIndex = 13; break;
5290 case MGN_MCS2: rateIndex = 14; break;
5291 case MGN_MCS3: rateIndex = 15; break;
5292 case MGN_MCS4: rateIndex = 16; break;
5293 case MGN_MCS5: rateIndex = 17; break;
5294 case MGN_MCS6: rateIndex = 18; break;
5295 case MGN_MCS7: rateIndex = 19; break;
5296 case MGN_MCS8: rateIndex = 20; break;
5297 case MGN_MCS9: rateIndex = 21; break;
5298 case MGN_MCS10: rateIndex = 22; break;
5299 case MGN_MCS11: rateIndex = 23; break;
5300 case MGN_MCS12: rateIndex = 24; break;
5301 case MGN_MCS13: rateIndex = 25; break;
5302 case MGN_MCS14: rateIndex = 26; break;
5303 case MGN_MCS15: rateIndex = 27; break;
5304 default: rateIndex = 28; break;
5305 }
5306 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5307 priv->stats.received_rate_histogram[0][rateIndex]++;
5308 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5309}
5310
5311
5312void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
5313{
5314 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5315 struct net_device *dev=info->dev;
5316 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5317
5318 rx_drvinfo_819x_usb *driver_info = NULL;
5319
5320
5321
5322
5323#ifdef USB_RX_AGGREGATION_SUPPORT
5324 if (bIsRxAggrSubframe)
5325 {
5326 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
5327 stats->Length = desc->Length ;
5328 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5329 stats->RxBufShift = 0;
5330 stats->bICV = desc->ICV;
5331 stats->bCRC = desc->CRC32;
5332 stats->bHwError = stats->bCRC|stats->bICV;
5333 stats->Decrypted = !desc->SWDec;
5334 } else
5335#endif
5336 {
5337 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5338
5339 stats->Length = desc->Length;
5340 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5341 stats->RxBufShift = 0;
5342 stats->bICV = desc->ICV;
5343 stats->bCRC = desc->CRC32;
5344 stats->bHwError = stats->bCRC|stats->bICV;
5345
5346 stats->Decrypted = !desc->SWDec;
5347 }
5348
5349 if((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
5350 {
5351 stats->bHwError = false;
5352 }
5353 else
5354 {
5355 stats->bHwError = stats->bCRC|stats->bICV;
5356 }
5357
5358 if(stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
5359 stats->bHwError |= 1;
5360
5361
5362
5363
5364
5365 if (stats->RxDrvInfoSize != 0) {
5366 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
5367 stats->RxBufShift);
5368
5369
5370 if(!stats->bHwError){
5371 u8 ret_rate;
5372 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
5373 if(ret_rate == 0xff)
5374 {
5375
5376
5377
5378 stats->bHwError = 1;
5379 stats->rate = MGN_1M;
5380 }else
5381 {
5382 stats->rate = ret_rate;
5383 }
5384 }
5385 else
5386 stats->rate = 0x02;
5387
5388 stats->bShortPreamble = driver_info->SPLCP;
5389
5390
5391 UpdateReceivedRateHistogramStatistics8190(dev, stats);
5392
5393 stats->bIsAMPDU = (driver_info->PartAggr==1);
5394 stats->bFirstMPDU = (driver_info->PartAggr==1) && (driver_info->FirstAGGR==1);
5395 stats->TimeStampLow = driver_info->TSFL;
5396
5397
5398
5399
5400 UpdateRxPktTimeStamp8190(dev, stats);
5401
5402
5403
5404
5405 if(driver_info->FirstAGGR==1 || driver_info->PartAggr == 1)
5406 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
5407 driver_info->FirstAGGR, driver_info->PartAggr);
5408
5409 }
5410
5411 skb_pull(skb,sizeof(rx_desc_819x_usb));
5412
5413
5414
5415 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
5416 stats->bShift = 1;
5417 skb_pull(skb,stats->RxBufShift + stats->RxDrvInfoSize);
5418 }
5419
5420#ifdef USB_RX_AGGREGATION_SUPPORT
5421
5422 if(bIsRxAggrSubframe) {
5423 skb_pull(skb, 8);
5424 }
5425#endif
5426
5427
5428
5429 stats->RxIs40MHzPacket = driver_info->BW;
5430 if(stats->RxDrvInfoSize != 0)
5431 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
5432
5433}
5434
5435u32 GetRxPacketShiftBytes819xUsb(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
5436{
5437#ifdef USB_RX_AGGREGATION_SUPPORT
5438 if (bIsRxAggrSubframe)
5439 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5440 + Status->RxBufShift + 8);
5441 else
5442#endif
5443 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5444 + Status->RxBufShift);
5445}
5446
5447void rtl8192_rx_nomal(struct sk_buff* skb)
5448{
5449 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5450 struct net_device *dev=info->dev;
5451 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5452 struct ieee80211_rx_stats stats = {
5453 .signal = 0,
5454 .noise = -98,
5455 .rate = 0,
5456
5457 .freq = IEEE80211_24GHZ_BAND,
5458 };
5459 u32 rx_pkt_len = 0;
5460 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5461 bool unicast_packet = false;
5462#ifdef USB_RX_AGGREGATION_SUPPORT
5463 struct sk_buff *agg_skb = NULL;
5464 u32 TotalLength = 0;
5465 u32 TempDWord = 0;
5466 u32 PacketLength = 0;
5467 u32 PacketOccupiedLendth = 0;
5468 u8 TempByte = 0;
5469 u32 PacketShiftBytes = 0;
5470 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
5471 u8 PaddingBytes = 0;
5472
5473 u8 testing;
5474
5475#endif
5476
5477
5478 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
5479#ifdef USB_RX_AGGREGATION_SUPPORT
5480 TempByte = *(skb->data + sizeof(rx_desc_819x_usb));
5481#endif
5482
5483 query_rxdesc_status(skb, &stats, false);
5484
5485
5486#ifdef USB_RX_AGGREGATION_SUPPORT
5487 if (TempByte & BIT0) {
5488 agg_skb = skb;
5489
5490 TotalLength = stats.Length - 4;
5491
5492
5493 TempDWord = *(u32 *)(agg_skb->data - 4);
5494 PacketLength = (u16)(TempDWord & 0x3FFF);
5495 skb = dev_alloc_skb(PacketLength);
5496 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
5497 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, false);
5498 }
5499#endif
5500
5501 skb_trim(skb, skb->len - 4);
5502
5503 rx_pkt_len = skb->len;
5504 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5505 unicast_packet = false;
5506 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5507
5508 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5509
5510 }else {
5511
5512 unicast_packet = true;
5513 }
5514
5515 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5516 dev_kfree_skb_any(skb);
5517 } else {
5518 priv->stats.rxoktotal++;
5519 if(unicast_packet) {
5520 priv->stats.rxbytesunicast += rx_pkt_len;
5521 }
5522 }
5523#ifdef USB_RX_AGGREGATION_SUPPORT
5524 testing = 1;
5525
5526 if (TotalLength > 0) {
5527 PacketOccupiedLendth = PacketLength + (PacketShiftBytes + 8);
5528 if ((PacketOccupiedLendth & 0xFF) != 0)
5529 PacketOccupiedLendth = (PacketOccupiedLendth & 0xFFFFFF00) + 256;
5530 PacketOccupiedLendth -= 8;
5531 TempDWord = PacketOccupiedLendth - PacketShiftBytes;
5532 if (agg_skb->len > TempDWord)
5533 skb_pull(agg_skb, TempDWord);
5534 else
5535 agg_skb->len = 0;
5536
5537 while (agg_skb->len>=GetRxPacketShiftBytes819xUsb(&stats, true)) {
5538 u8 tmpCRC = 0, tmpICV = 0;
5539
5540 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
5541 tmpCRC = RxDescr->CRC32;
5542 tmpICV = RxDescr->ICV;
5543 memcpy(agg_skb->data, &agg_skb->data[44], 2);
5544 RxDescr->CRC32 = tmpCRC;
5545 RxDescr->ICV = tmpICV;
5546
5547 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
5548 stats.signal = 0;
5549 stats.noise = -98;
5550 stats.rate = 0;
5551 stats.freq = IEEE80211_24GHZ_BAND;
5552 query_rxdesc_status(agg_skb, &stats, true);
5553 PacketLength = stats.Length;
5554
5555 if(PacketLength > agg_skb->len) {
5556 break;
5557 }
5558
5559 skb = dev_alloc_skb(PacketLength);
5560 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
5561 skb_trim(skb, skb->len - 4);
5562
5563 rx_pkt_len = skb->len;
5564 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5565 unicast_packet = false;
5566 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5567
5568 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5569
5570 }else {
5571
5572 unicast_packet = true;
5573 }
5574 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5575 dev_kfree_skb_any(skb);
5576 } else {
5577 priv->stats.rxoktotal++;
5578 if(unicast_packet) {
5579 priv->stats.rxbytesunicast += rx_pkt_len;
5580 }
5581 }
5582
5583 skb_pull(agg_skb, PacketLength);
5584 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, true);
5585 PacketOccupiedLendth = PacketLength + PacketShiftBytes;
5586 if ((PacketOccupiedLendth & 0xFF) != 0) {
5587 PaddingBytes = 256 - (PacketOccupiedLendth & 0xFF);
5588 if (agg_skb->len > PaddingBytes)
5589 skb_pull(agg_skb, PaddingBytes);
5590 else
5591 agg_skb->len = 0;
5592 }
5593 }
5594 dev_kfree_skb(agg_skb);
5595 }
5596#endif
5597 } else {
5598 priv->stats.rxurberr++;
5599 printk("actual_length:%d\n", skb->len);
5600 dev_kfree_skb_any(skb);
5601 }
5602
5603}
5604
5605void
5606rtl819xusb_process_received_packet(
5607 struct net_device *dev,
5608 struct ieee80211_rx_stats *pstats
5609 )
5610{
5611
5612 u8* frame;
5613 u16 frame_len=0;
5614 struct r8192_priv *priv = ieee80211_priv(dev);
5615
5616
5617
5618
5619
5620
5621
5622 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
5623 frame = pstats->virtual_address;
5624 frame_len = pstats->packetlength;
5625#ifdef TODO
5626 if(!Adapter->bInHctTest)
5627 CountRxErrStatistics(Adapter, pRfd);
5628#endif
5629 {
5630 #ifdef ENABLE_PS
5631 RT_RF_POWER_STATE rtState;
5632
5633
5634
5635 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
5636 if (rtState == eRfOff)
5637 {
5638 return;
5639 }
5640 #endif
5641 priv->stats.rxframgment++;
5642
5643 }
5644#ifdef TODO
5645 RmMonitorSignalStrength(Adapter, pRfd);
5646#endif
5647
5648
5649 if (rtl819xusb_rx_command_packet(dev, pstats))
5650 {
5651 return;
5652 }
5653
5654#ifdef SW_CRC_CHECK
5655 SwCrcCheck();
5656#endif
5657
5658
5659}
5660
5661void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
5662{
5663
5664
5665
5666 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5667
5668
5669
5670
5671
5672 stats->virtual_address = (u8*)skb->data;
5673 stats->Length = desc->Length;
5674 stats->RxDrvInfoSize = 0;
5675 stats->RxBufShift = 0;
5676 stats->packetlength = stats->Length-scrclng;
5677 stats->fraglength = stats->packetlength;
5678 stats->fragoffset = 0;
5679 stats->ntotalfrag = 1;
5680}
5681
5682
5683void rtl8192_rx_cmd(struct sk_buff *skb)
5684{
5685 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5686 struct net_device *dev = info->dev;
5687
5688
5689
5690 struct ieee80211_rx_stats stats = {
5691 .signal = 0,
5692 .noise = -98,
5693 .rate = 0,
5694
5695 .freq = IEEE80211_24GHZ_BAND,
5696 };
5697
5698 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE))
5699 {
5700
5701 query_rx_cmdpkt_desc_status(skb,&stats);
5702
5703
5704
5705
5706
5707
5708
5709 rtl819xusb_process_received_packet(dev,&stats);
5710
5711 dev_kfree_skb_any(skb);
5712 }
5713 else
5714 ;
5715
5716
5717}
5718
5719void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5720{
5721 struct sk_buff *skb;
5722 struct rtl8192_rx_info *info;
5723
5724 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
5725 info = (struct rtl8192_rx_info *)skb->cb;
5726 switch (info->out_pipe) {
5727
5728 case 3:
5729
5730 priv->IrpPendingCount--;
5731 rtl8192_rx_nomal(skb);
5732 break;
5733
5734
5735 case 9:
5736 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
5737 info->out_pipe);
5738
5739 rtl8192_rx_cmd(skb);
5740 break;
5741
5742 default:
5743 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
5744 info->out_pipe);
5745 dev_kfree_skb(skb);
5746 break;
5747
5748 }
5749 }
5750}
5751
5752static const struct net_device_ops rtl8192_netdev_ops = {
5753 .ndo_open = rtl8192_open,
5754 .ndo_stop = rtl8192_close,
5755 .ndo_get_stats = rtl8192_stats,
5756 .ndo_tx_timeout = tx_timeout,
5757 .ndo_do_ioctl = rtl8192_ioctl,
5758 .ndo_set_multicast_list = r8192_set_multicast,
5759 .ndo_set_mac_address = r8192_set_mac_adr,
5760 .ndo_validate_addr = eth_validate_addr,
5761 .ndo_change_mtu = eth_change_mtu,
5762 .ndo_start_xmit = ieee80211_xmit,
5763};
5764
5765
5766
5767
5768
5769
5770static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
5771 const struct usb_device_id *id)
5772{
5773
5774 struct net_device *dev = NULL;
5775 struct r8192_priv *priv= NULL;
5776 struct usb_device *udev = interface_to_usbdev(intf);
5777 int ret;
5778 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
5779
5780 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5781 if (dev == NULL)
5782 return -ENOMEM;
5783
5784 usb_set_intfdata(intf, dev);
5785 SET_NETDEV_DEV(dev, &intf->dev);
5786 priv = ieee80211_priv(dev);
5787 priv->ieee80211 = netdev_priv(dev);
5788 priv->udev=udev;
5789
5790 dev->netdev_ops = &rtl8192_netdev_ops;
5791
5792
5793#if WIRELESS_EXT >= 12
5794#if WIRELESS_EXT < 17
5795 dev->get_wireless_stats = r8192_get_wireless_stats;
5796#endif
5797 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5798#endif
5799 dev->type=ARPHRD_ETHER;
5800
5801 dev->watchdog_timeo = HZ*3;
5802
5803 if (dev_alloc_name(dev, ifname) < 0){
5804 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5805 ifname = "wlan%d";
5806 dev_alloc_name(dev, ifname);
5807 }
5808
5809 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
5810 if(rtl8192_init(dev)!=0){
5811 RT_TRACE(COMP_ERR, "Initialization failed");
5812 ret = -ENODEV;
5813 goto fail;
5814 }
5815 netif_carrier_off(dev);
5816 netif_stop_queue(dev);
5817
5818 ret = register_netdev(dev);
5819 if (ret)
5820 goto fail2;
5821
5822 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
5823 rtl8192_proc_init_one(dev);
5824
5825
5826 RT_TRACE(COMP_INIT, "Driver probe completed\n");
5827 return 0;
5828
5829fail2:
5830 rtl8192_down(dev);
5831 if (priv->pFirmware) {
5832 kfree(priv->pFirmware);
5833 priv->pFirmware = NULL;
5834 }
5835 rtl8192_usb_deleteendpoints(dev);
5836 destroy_workqueue(priv->priv_wq);
5837 mdelay(10);
5838fail:
5839 free_ieee80211(dev);
5840
5841 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
5842 return ret;
5843}
5844
5845
5846void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
5847{
5848
5849 cancel_work_sync(&priv->reset_wq);
5850 cancel_delayed_work(&priv->watch_dog_wq);
5851 cancel_delayed_work(&priv->update_beacon_wq);
5852 cancel_work_sync(&priv->qos_activate);
5853
5854
5855
5856}
5857
5858
5859static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf)
5860{
5861 struct net_device *dev = usb_get_intfdata(intf);
5862
5863 struct r8192_priv *priv = ieee80211_priv(dev);
5864 if(dev){
5865
5866 unregister_netdev(dev);
5867
5868 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
5869 rtl8192_proc_remove_one(dev);
5870
5871 rtl8192_down(dev);
5872 if (priv->pFirmware)
5873 {
5874 kfree(priv->pFirmware);
5875 priv->pFirmware = NULL;
5876 }
5877
5878
5879 rtl8192_usb_deleteendpoints(dev);
5880 destroy_workqueue(priv->priv_wq);
5881
5882
5883 mdelay(10);
5884
5885 }
5886 free_ieee80211(dev);
5887 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
5888}
5889
5890
5891extern int ieee80211_debug_init(void);
5892extern void ieee80211_debug_exit(void);
5893extern int ieee80211_crypto_init(void);
5894extern void ieee80211_crypto_deinit(void);
5895extern int ieee80211_crypto_tkip_init(void);
5896extern void ieee80211_crypto_tkip_exit(void);
5897extern int ieee80211_crypto_ccmp_init(void);
5898extern void ieee80211_crypto_ccmp_exit(void);
5899extern int ieee80211_crypto_wep_init(void);
5900extern void ieee80211_crypto_wep_exit(void);
5901
5902static int __init rtl8192_usb_module_init(void)
5903{
5904 int ret;
5905
5906#ifdef CONFIG_IEEE80211_DEBUG
5907 ret = ieee80211_debug_init();
5908 if (ret) {
5909 printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
5910 return ret;
5911 }
5912#endif
5913 ret = ieee80211_crypto_init();
5914 if (ret) {
5915 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
5916 return ret;
5917 }
5918
5919 ret = ieee80211_crypto_tkip_init();
5920 if (ret) {
5921 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
5922 ret);
5923 return ret;
5924 }
5925
5926 ret = ieee80211_crypto_ccmp_init();
5927 if (ret) {
5928 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
5929 ret);
5930 return ret;
5931 }
5932
5933 ret = ieee80211_crypto_wep_init();
5934 if (ret) {
5935 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
5936 return ret;
5937 }
5938
5939 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
5940 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
5941 RT_TRACE(COMP_INIT, "Initializing module");
5942 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
5943 rtl8192_proc_module_init();
5944 return usb_register(&rtl8192_usb_driver);
5945}
5946
5947
5948static void __exit rtl8192_usb_module_exit(void)
5949{
5950 usb_deregister(&rtl8192_usb_driver);
5951
5952 RT_TRACE(COMP_DOWN, "Exiting");
5953
5954}
5955
5956
5957void rtl8192_try_wake_queue(struct net_device *dev, int pri)
5958{
5959 unsigned long flags;
5960 short enough_desc;
5961 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5962
5963 spin_lock_irqsave(&priv->tx_lock,flags);
5964 enough_desc = check_nic_enough_desc(dev,pri);
5965 spin_unlock_irqrestore(&priv->tx_lock,flags);
5966
5967 if(enough_desc)
5968 ieee80211_wake_queue(priv->ieee80211);
5969}
5970
5971void EnableHWSecurityConfig8192(struct net_device *dev)
5972{
5973 u8 SECR_value = 0x0;
5974 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5975 struct ieee80211_device* ieee = priv->ieee80211;
5976 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
5977 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
5978 {
5979 SECR_value |= SCR_RxUseDK;
5980 SECR_value |= SCR_TxUseDK;
5981 }
5982 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
5983 {
5984 SECR_value |= SCR_RxUseDK;
5985 SECR_value |= SCR_TxUseDK;
5986 }
5987
5988
5989
5990 ieee->hwsec_active = 1;
5991
5992 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep)
5993 {
5994 ieee->hwsec_active = 0;
5995 SECR_value &= ~SCR_RxDecEnable;
5996 }
5997 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
5998 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
5999 {
6000 write_nic_byte(dev, SECR, SECR_value);
6001 }
6002}
6003
6004
6005void setKey( struct net_device *dev,
6006 u8 EntryNo,
6007 u8 KeyIndex,
6008 u16 KeyType,
6009 u8 *MacAddr,
6010 u8 DefaultKey,
6011 u32 *KeyContent )
6012{
6013 u32 TargetCommand = 0;
6014 u32 TargetContent = 0;
6015 u16 usConfig = 0;
6016 u8 i;
6017 if (EntryNo >= TOTAL_CAM_ENTRY)
6018 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6019
6020 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6021
6022 if (DefaultKey)
6023 usConfig |= BIT15 | (KeyType<<2);
6024 else
6025 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6026
6027
6028
6029 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6030 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6031 TargetCommand |= BIT31|BIT16;
6032
6033 if(i==0){
6034 TargetContent = (u32)(*(MacAddr+0)) << 16|
6035 (u32)(*(MacAddr+1)) << 24|
6036 (u32)usConfig;
6037
6038 write_nic_dword(dev, WCAMI, TargetContent);
6039 write_nic_dword(dev, RWCAM, TargetCommand);
6040
6041 }
6042 else if(i==1){
6043 TargetContent = (u32)(*(MacAddr+2)) |
6044 (u32)(*(MacAddr+3)) << 8|
6045 (u32)(*(MacAddr+4)) << 16|
6046 (u32)(*(MacAddr+5)) << 24;
6047 write_nic_dword(dev, WCAMI, TargetContent);
6048 write_nic_dword(dev, RWCAM, TargetCommand);
6049 }
6050 else {
6051
6052 if(KeyContent !=NULL){
6053 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6054 write_nic_dword(dev, RWCAM, TargetCommand);
6055 }
6056 }
6057 }
6058
6059}
6060
6061
6062
6063
6064module_init(rtl8192_usb_module_init);
6065module_exit(rtl8192_usb_module_exit);
6066