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