?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next
[linux-2.6.git] / drivers / staging / rtl8192u / r8192U_core.c
blob14c14c24ac500bc39c79d02424eb7cd706287269
1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8192U
4 *
5 * Based on the r8187 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
22 *
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
25 */
26
27 #ifndef CONFIG_FORCE_HARD_FLOAT
28 double __floatsidf(int i)
29 {
30 return i;
31 }
32
33 unsigned int __fixunsdfsi(double d)
34 {
35 return d;
36 }
37
38 double __adddf3(double a, double b)
39 {
40 return a+b;
41 }
42
43 double __addsf3(float a, float b)
44 {
45 return a+b;
46 }
47
48 double __subdf3(double a, double b)
49 {
50 return a-b;
51 }
52
53 double __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" /* RTL8225 Radio frontend */
88 #include "r8180_93cx6.h" /* Card EEPROM */
89 #include "r8192U_wx.h"
90 #include "r819xU_phy.h" //added by WB 4.30.2008
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 // FIXME: check if 2.6.7 is ok
99
100 #ifdef CONFIG_RTL8192_PM
101 #include "r8192_pm.h"
102 #endif
103
104 #include "dot11d.h"
105 //set here to open your trace code. //WB
106 u32 rt_global_debug_component = COMP_DOWN |
107 COMP_SEC |
108 COMP_ERR; //always open err flags on
109
110 #define TOTAL_CAM_ENTRY 32
111 #define CAM_CONTENT_COUNT 8
112
113 static const struct usb_device_id rtl8192_usb_id_tbl[] = {
114 /* Realtek */
115 {USB_DEVICE(0x0bda, 0x8709)},
116 /* Corega */
117 {USB_DEVICE(0x07aa, 0x0043)},
118 /* Belkin */
119 {USB_DEVICE(0x050d, 0x805E)},
120 /* Sitecom */
121 {USB_DEVICE(0x0df6, 0x0031)},
122 /* EnGenius */
123 {USB_DEVICE(0x1740, 0x9201)},
124 /* Dlink */
125 {USB_DEVICE(0x2001, 0x3301)},
126 /* Zinwell */
127 {USB_DEVICE(0x5a57, 0x0290)},
128 /* LG */
129 {USB_DEVICE(0x043e, 0x7a01)},
130 {}
131 };
132
133 MODULE_LICENSE("GPL");
134 MODULE_VERSION("V 1.1");
135 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
136 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
137
138 static char *ifname = "wlan%d";
139 static int hwwep = 1; //default use hw. set 0 to use software security
140 static int channels = 0x3fff;
141
142
143
144 module_param(ifname, charp, S_IRUGO|S_IWUSR);
145 module_param(hwwep, int, S_IRUGO|S_IWUSR);
146 module_param(channels, int, S_IRUGO|S_IWUSR);
147
148 MODULE_PARM_DESC(ifname, " Net interface name, wlan%d=default");
149 MODULE_PARM_DESC(hwwep, " Try to use hardware security support. ");
150 MODULE_PARM_DESC(channels, " Channel bitmask for specific locales. NYI");
151
152 static int rtl8192_usb_probe(struct usb_interface *intf,
153 const struct usb_device_id *id);
154 static void rtl8192_usb_disconnect(struct usb_interface *intf);
155
156
157 static struct usb_driver rtl8192_usb_driver = {
158 .name = RTL819xU_MODULE_NAME, /* Driver name */
159 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
160 .probe = rtl8192_usb_probe, /* probe fn */
161 .disconnect = rtl8192_usb_disconnect, /* remove fn */
162 #ifdef CONFIG_RTL8192_PM
163 .suspend = rtl8192_suspend, /* PM suspend fn */
164 .resume = rtl8192_resume, /* PM resume fn */
165 #else
166 .suspend = NULL, /* PM suspend fn */
167 .resume = NULL, /* PM resume fn */
168 #endif
169 };
170
171
172 typedef struct _CHANNEL_LIST {
173 u8 Channel[32];
174 u8 Len;
175 } CHANNEL_LIST, *PCHANNEL_LIST;
176
177 static 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}, //FCC
179 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
183 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
184 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
185 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
186 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
187 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
188 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626
189 };
190
191 static 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 //actually 8225 & 8256 rf chips only support B,G,24N mode
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 // Clear old channel map
217 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
218 // Set new channel map
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;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
229 Dot11d_Reset(ieee);
230 ieee->bGlobalDomain = true;
231 break;
232
233 default:
234 break;
235 }
236 }
237
238
239
240
241 void CamResetAllEntry(struct net_device *dev)
242 {
243 u32 ulcommand = 0;
244 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
245 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
246 // In this condition, Cam can not be reset because upper layer will not set this static key again.
247 ulcommand |= BIT31|BIT30;
248 write_nic_dword(dev, RWCAM, ulcommand);
249
250 }
251
252
253 void 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
259 u32 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
268 void 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
282 int 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 //as 92U has extend page from 4 to 16, so modify functions below.
300 void 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
318 void 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
336 void 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
356 int 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
376 int 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
395 int 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
413 int 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 /* u8 read_phy_cck(struct net_device *dev, u8 adr); */
434 /* u8 read_phy_ofdm(struct net_device *dev, u8 adr); */
435 /* this might still called in what was the PHY rtl8185/rtl8192 common code
436 * plans are to possibility turn it again in one common code...
437 */
438 inline void force_pci_posting(struct net_device *dev)
439 {
440 }
441
442 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
443 void rtl8192_commit(struct net_device *dev);
444 void rtl8192_restart(struct work_struct *work);
445 void watch_dog_timer_callback(unsigned long data);
446
447 /****************************************************************************
448 * -----------------------------PROCFS STUFF-------------------------
449 *****************************************************************************
450 */
451
452 static struct proc_dir_entry *rtl8192_proc;
453
454 static 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
472 static 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
513 static 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
572 static 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
588 void 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
595 void rtl8192_proc_module_remove(void)
596 {
597 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
598 }
599
600 /*
601 * seq_file wrappers for procfile show routines.
602 */
603 static 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
611 static 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 * Table of proc files we need to create.
620 */
621 struct rtl8192_proc_file {
622 char name[12];
623 int (*show)(struct seq_file *, void *);
624 };
625
626 static 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
634 void 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
659 void rtl8192_proc_remove_one(struct net_device *dev)
660 {
661 remove_proc_subtree(dev->name, rtl8192_proc);
662 }
663
664 /****************************************************************************
665 -----------------------------MISC STUFF-------------------------
666 *****************************************************************************/
667
668 short 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
676 void 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 /* this is only for debug */
685 void 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 ------------------------------HW STUFF---------------------------
695 *****************************************************************************/
696
697
698 void 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
710 void 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 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
719 * msr must be updated if the state is ASSOCIATING.
720 * this is intentional and make sense for ad-hoc and
721 * master (see the create BSS/IBSS func)
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
739 void 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 /* this hack should avoid frame TX during channel setting*/
746
747 #ifndef LOOP_TEST
748 //need to implement rf set channel here WB
749
750 if (priv->rf_set_chan)
751 priv->rf_set_chan(dev, priv->chan);
752 mdelay(10);
753 #endif
754 }
755
756 static void rtl8192_rx_isr(struct urb *urb);
757
758 u32 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 }
771 static 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 /* nomal packet rx procedure */
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; //denote rx normal packet queue
795 skb_queue_tail(&priv->rx_queue, skb);
796 usb_submit_urb(entry, GFP_KERNEL);
797 }
798
799 /* command packet rx procedure */
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; //denote rx cmd packet queue
816 skb_queue_tail(&priv->rx_queue, skb);
817 usb_submit_urb(entry, GFP_KERNEL);
818 }
819
820 return 0;
821 }
822
823 void 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 //wait to be removed
866 void rtl8192_rx_enable(struct net_device *dev)
867 {
868 rtl8192_rx_initiate(dev);
869 }
870
871
872 void rtl8192_tx_enable(struct net_device *dev)
873 {
874 }
875
876
877
878 void 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
907 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
908 {
909 return 0;
910 }
911
912 inline 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 }
944 static u16 rtl_rate[] = {10, 20, 55, 110, 60, 90, 120, 180, 240, 360, 480, 540};
945 inline u16 rtl8192_rate2rate(short rate)
946 {
947 if (rate > 11) return 0;
948 return rtl_rate[rate];
949 }
950
951
952 /* The prototype of rx_isr has changed since one version of Linux Kernel */
953 static 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 /* TODO check rx queue length and refill *somewhere* */
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
1001 u32 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
1014 void rtl8192_data_hard_stop(struct net_device *dev)
1015 {
1016 //FIXME !!
1017 }
1018
1019
1020 void rtl8192_data_hard_resume(struct net_device *dev)
1021 {
1022 // FIXME !!
1023 }
1024
1025 /* this function TX data frames when the ieee80211 stack requires this.
1026 * It checks also if we need to stop the ieee tx queue, eventually do it
1027 */
1028 void 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 /* shall not be referred by command packet */
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 /* This is a rough attempt to TX a frame
1052 * This is called by the ieee 80211 stack to TX management frames.
1053 * If the ring is full packet are dropped (for data frame the queue
1054 * is stopped before this can happen).
1055 */
1056 int 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
1085 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1086
1087 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1088 u16 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
1094 u8 MRateToHwRate8190Pci(u8 rate);
1095 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
1096 u8 MapHwQueueToFirmwareQueue(u8 QueueID);
1097 struct 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 // Local variable initialization.
1111 //
1112 /* first skb initialization */
1113 skb = pSendList->tx_agg_frames[0];
1114 TotalLength = skb->len;
1115
1116 /* Get the total aggregation length including the padding space and
1117 * sub frame header.
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 /* allocate skb to contain the aggregated packets */
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 /* reserve info for first subframe Tx descriptor to be set in the tx function */
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 /* push the next sub frame to be 256 byte aline */
1142 skb_put(agg_skb, DrvAggr_PaddingAdd(dev, skb));
1143
1144 /* Subframe drv Tx descriptor and firmware info setting */
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 /* DWORD 0 */
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) {//AMPDU enabled
1157 tx_fwinfo->AllowAggregation = 1;
1158 /* DWORD 1 */
1159 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1160 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1161 } else {
1162 tx_fwinfo->AllowAggregation = 0;
1163 /* DWORD 1 */
1164 tx_fwinfo->RxMF = 0;
1165 tx_fwinfo->RxAMD = 0;
1166 }
1167
1168 /* Protection mode related */
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 /* Set Bandwidth and sub-channel settings. */
1180 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40) {
1181 if (tcb_desc->bPacketBW) {
1182 tx_fwinfo->TxBandwidth = 1;
1183 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
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 /* Fill Tx descriptor */
1194 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
1195 /* DWORD 0 */
1196 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1197 /* already raw data, need not to subtract header length */
1198 tx_agg_desc->PktSize = skb->len & 0xffff;
1199
1200 /*DWORD 1*/
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 //DWORD 2
1237 /* According windows driver, it seems that there no need to fill this field */
1238
1239 /* to fill next packet */
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 /* NOTE:
1251 This function return a list of PTCB which is proper to be aggregate with the input TCB.
1252 If no proper TCB is found to do aggregation, SendList will only contain the input TCB.
1253 */
1254 u8 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
1275 static 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 /* TODO */
1295 }
1296 }
1297
1298 /* free skb and tx_urb */
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 // Handle HW Beacon:
1307 // We had transfer our beacon frame to host controller at this moment.
1308 //
1309 //
1310 // Caution:
1311 // Handling the wait queue of command packets.
1312 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1313 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1314 //
1315
1316 /* Handle MPDU in wait queue. */
1317 if (queue_index != BEACON_QUEUE) {
1318 /* Don't send data frame during scanning.*/
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; //modified by david to avoid further processing AMSDU
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 // Tx Driver Aggregation process
1330 /* The driver will aggregation the packets according to the following stats
1331 * 1. check whether there's tx irq available, for it's a completion return
1332 * function, it should contain enough tx irq;
1333 * 2. check packet type;
1334 * 3. initialize sendlist, check whether the to-be send packet no greater than 1
1335 * 4. aggregates the packets, and fill firmware info and tx desc into it, etc.
1336 * 5. check whether the packet could be sent, otherwise just insert into wait head
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 /*TODO*/
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
1361 void 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
1379 void 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
1426 void 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)) //short slot time
1440 slot_time = SHORT_SLOT_TIME;
1441 else //long slot time
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 }
1448 void 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 // TODO: BcnIFS may required to be changed on ASIC
1472 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1473
1474 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1475 }
1476
1477
1478
1479 }
1480
1481 //temporary hw beacon is not used any more.
1482 //open it when necessary
1483 void rtl819xusb_beacon_tx(struct net_device *dev, u16 tx_rate)
1484 {
1485
1486 }
1487 inline 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
1494 u16 N_DBPSOfRate(u16 DataRate);
1495
1496 u16 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) // long preamble
1505 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1506 else // Short preamble
1507 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1508 if ((FrameLength*8 % (DataRate/10)) != 0) //Get the Ceilling
1509 FrameTime++;
1510 } else { //802.11g DSSS-OFDM PLCP length field calculation.
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
1519 u16 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
1563 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1564 {
1565 usb_free_urb(tx_cmd_urb);
1566 }
1567
1568 unsigned 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
1577 short 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 /* Tx descriptor ought to be set according to the skb->cb */
1596 pdesc->FirstSeg = 1;//bFirstSeg;
1597 pdesc->LastSeg = 1;//bLastSeg;
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 // Fill up USB_OUT_CONTEXT.
1605 //----------------------------------------------------------------------------
1606 // Get index to out pipe from specified QueueID.
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 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1634 * in TxFwInfo data structure
1635 * 2006.10.30 by Emily
1636 *
1637 * \param QUEUEID Software Queue
1638 */
1639 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1640 {
1641 u8 QueueSelect = 0x0; //defualt set to
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 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1668 // TODO: Remove Assertions
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
1683 u8 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 // HT rate since here
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
1726 u8 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
1738 static void tx_zero_isr(struct urb *tx_urb)
1739 {
1740 return;
1741 }
1742
1743 /*
1744 * The tx procedure is just as following,
1745 * skb->cb will contain all the following information,
1746 * priority, morefrag, rate, &dev.
1747 * */
1748 short 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 /* we are locked here so the two atomic_read and inc are executed
1761 * without interleaves
1762 * !!! For debug purpose
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 /* Fill Tx firmware info */
1777 memset(tx_fwinfo, 0, sizeof(tx_fwinfo_819x_usb));
1778 /* DWORD 0 */
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) {//AMPDU enabled
1784 tx_fwinfo->AllowAggregation = 1;
1785 /* DWORD 1 */
1786 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1787 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1788 } else {
1789 tx_fwinfo->AllowAggregation = 0;
1790 /* DWORD 1 */
1791 tx_fwinfo->RxMF = 0;
1792 tx_fwinfo->RxAMD = 0;
1793 }
1794
1795 /* Protection mode related */
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 /* Set Bandwidth and sub-channel settings. */
1807 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40) {
1808 if (tcb_desc->bPacketBW) {
1809 tx_fwinfo->TxBandwidth = 1;
1810 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
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 /* Fill Tx descriptor */
1825 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
1826 /* DWORD 0 */
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 /*DWORD 1*/
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 /* Fill fields that are required to be initialized in all of the descriptors */
1874 //DWORD 0
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 //DWORD 2
1886 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
1887 }
1888 /* Get index to out pipe from specified QueueID */
1889 #ifndef USE_ONE_PIPE
1890 idx_pipe = txqueue2outpipe(priv, tcb_desc->queue_index);
1891 #else
1892 idx_pipe = 0x5;
1893 #endif
1894
1895 /* To submit bulk urb */
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 //we need to send 0 byte packet whenever 512N bytes/64N(HIGN SPEED/NORMAL SPEED) bytes packet has been transmitted. Otherwise, it will be halt to wait for another packet. WB. 2008.08.27
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
1937 short 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
1995 void 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
2016 void 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
2048 extern void rtl8192_update_ratr_table(struct net_device *dev);
2049 void 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 //add this as in pure N mode, wep encryption will use software way, but there is no chance to set this as wep will not set group key in wext. WB.2008.07.08
2057 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
2058 EnableHWSecurityConfig8192(dev);
2059 }
2060 /*update timing params*/
2061 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC) {
2062 u32 reg = 0;
2063 read_nic_dword(dev, RCR, &reg);
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
2072 static struct ieee80211_qos_parameters def_qos_parameters = {
2073 {3, 3, 3, 3},/* cw_min */
2074 {7, 7, 7, 7},/* cw_max */
2075 {2, 2, 2, 2},/* aifs */
2076 {0, 0, 0, 0},/* flags */
2077 {0, 0, 0, 0} /* tx_op_limit */
2078 };
2079
2080
2081 void 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 * background support to run QoS activate functionality
2095 */
2096 int WDCAPARA_ADD[] = {EDCAPARA_BE, EDCAPARA_BK, EDCAPARA_VI, EDCAPARA_VO};
2097 void 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 /* It better set slot time at first */
2115 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2116 /* update the ac parameter to related registers */
2117 for (i = 0; i < QOS_QUEUE_NUM; i++) {
2118 //Mode G/A: slotTimeTimer = 9; Mode B: 20
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
2128 success:
2129 mutex_unlock(&priv->mutex);
2130 }
2131
2132 static 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 /* handle and manage frame from beacon and probe response */
2176 static 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 * handling the beaconing responses. if we get different QoS setting
2190 * off the network from the associated setting, adjust the QoS
2191 * setting
2192 */
2193 static 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 /* update qos parameter for current network */
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
2241 static 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
2251 void 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) {//MIMO_PS_STATIC
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
2293 static u8 ccmp_ie[4] = {0x00, 0x50, 0xf2, 0x04};
2294 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2295 bool 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 //we use connecting AP's capability instead of only security config on our driver to distinguish whether it should use N mode or G mode
2306 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name, "WEP")));
2307
2308 /* simply judge */
2309 if (encrypt && (wpa_ie_len == 0)) {
2310 /* wep encryption, no N mode setting */
2311 return false;
2312 } else if ((wpa_ie_len != 0)) {
2313 /* parse pairwise key type */
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
2325 bool 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
2339 void rtl8192_refresh_supportrate(struct r8192_priv *priv)
2340 {
2341 struct ieee80211_device *ieee = priv->ieee80211;
2342 //we do not consider set support rate for ABG mode, only HT MCS rate is set here.
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
2350 u8 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 }
2369 void 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 //// TODO: this function doesn't work well at this time, we should wait for FPGA
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 //init priv variables here. only non_zero value should be initialized here.
2404 static 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; //set to channel 1
2410 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET 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; //11 mbps
2417 priv->ieee80211->short_slot = 1;
2418 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2419 priv->CckPwEnl = 6;
2420 //for silent reset
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; //we don't use FW read/write RF until stable firmware is available.
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;//added by amy 080604
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; //-by amy 080604
2440 priv->ieee80211->stop_send_beacons = NULL; //-by amy 080604
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 //added by WB
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 //added by david
2458 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2459 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2460 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2461 //added by amy
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)| // Max DMA Burst Size per Tx DMA Burst, 7: reserved.
2476 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2477 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2478 (false ? TCR_SAT : 0); // FALSE: HW provides PLCP length and LENGEXT, TRUE: SW provides them
2479 #ifdef TO_DO_LIST
2480 if (Adapter->bInHctTest)
2481 pHalData->ReceiveConfig = pHalData->CSMethod |
2482 RCR_AMF | RCR_ADF | //accept management/data
2483 //guangan200710
2484 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2485 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2486 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2487 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2488 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2489 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt : 0);
2490 else
2491
2492 #endif
2493 priv->ReceiveConfig =
2494 RCR_AMF | RCR_ADF | //accept management/data
2495 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2496 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2497 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2498 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2499 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT : 0);
2500
2501 priv->AcmControl = 0;
2502 priv->pFirmware = kzalloc(sizeof(rt_firmware), GFP_KERNEL);
2503
2504 /* rx related queue */
2505 skb_queue_head_init(&priv->rx_queue);
2506 skb_queue_head_init(&priv->skb_queue);
2507
2508 /* Tx related queue */
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 //init lock here
2519 static void rtl8192_init_priv_lock(struct r8192_priv *priv)
2520 {
2521 spin_lock_init(&priv->tx_lock);
2522 spin_lock_init(&priv->irq_lock);//added by thomas
2523 sema_init(&priv->wx_sem, 1);
2524 sema_init(&priv->rf_sem, 1);
2525 mutex_init(&priv->mutex);
2526 }
2527
2528 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2529
2530 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2531 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2532 #define DRV_NAME "wlan0"
2533 static 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
2553 static 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 //whether need I consider BIT5?
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 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2566 static inline u16 endian_swap(u16 *data)
2567 {
2568 u16 tmp = *data;
2569 *data = (tmp >> 8) | (tmp << 8);
2570 return *data;
2571 }
2572 static 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); //first read EEPROM ID out;
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 //set channelplan from eeprom
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 //should I set IDR0 here?
2618 }
2619 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2620 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2621 priv->rf_chip = RF_8256;
2622
2623 if (priv->card_8192_version == (u8)VERSION_819xU_A) {
2624 //read Tx power gain offset of legacy OFDM to HT rate
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 //read ThermalMeter from EEPROM
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 //vivi, for tx power track
2637 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2638 //read antenna tx power offset of B/C/D to A from EEPROM
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 // Read CrystalCap from EEPROM
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 //get per-channel Tx power level
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) { //old eeprom definition
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 }//endif EEPROM_Def_Ver == 1
2701
2702 //update HAL variables
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 // Antenna B gain offset to antenna A, bit0~3
2732 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
2733 // Antenna C gain offset to antenna A, bit4~7
2734 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
2735 // CrystalCap, bit12~15
2736 priv->CrystalCap = priv->EEPROMCrystalCap;
2737 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2738 // 92U does not enable TX power tracking.
2739 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
2740 }//end if VersionID == VERSION_819xU_A
2741
2742 //added by vivi, for dlink led, 20080416
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 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2781 // DIG RATR table again.
2782 init_rate_adaptive(dev);
2783 //we need init DIG RATR table here again.
2784
2785 RT_TRACE(COMP_EPROM, "<===========%s()\n", __func__);
2786 return;
2787 }
2788
2789 short 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
2802 short 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 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
2844 * not to do all the hw config as its name says
2845 * input: net_device dev
2846 * output: none
2847 * return: none
2848 * notice: This part need to modified according to the rate set we filtered
2849 * ****************************************************************************/
2850 void 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 // Set RRSR, RATR, and BW_OPMODE registers
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 // It support CCK rate by default.
2892 // CCK rate will be filtered out only when associated AP does not support it.
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, &regTmp);
2911 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2912 write_nic_dword(dev, RRSR, regRRSR);
2913
2914 //
2915 // Set Retry Limit here
2916 //
2917 write_nic_word(dev, RETRY_LIMIT,
2918 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
2919 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
2920 // Set Contention Window here
2921
2922 // Set Tx AGC
2923
2924 // Set Tx Antenna including Feedback control
2925
2926 // Set Auto Rate fallback control
2927
2928
2929 }
2930
2931
2932 //InitializeAdapter and PhyCfg
2933 bool 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 //for ASIC power on sequence
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 //config CPUReset Register
2952 //Firmware Reset or not?
2953 read_nic_dword(dev, CPU_GEN, &dwRegRead);
2954 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
2955 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
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 //config BB.
2963 rtl8192_BBConfig(dev);
2964
2965 //Loopback mode or not
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 //after reset cpu, we need wait for a seconds to write in register.
2979 udelay(500);
2980
2981 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
2982 read_nic_byte_E(dev, 0x5f, &tmp);
2983 write_nic_byte_E(dev, 0x5f, tmp|0x20);
2984
2985 //Set Hardware
2986 rtl8192_hwconfig(dev);
2987
2988 //turn on Tx/Rx
2989 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
2990
2991 //set IDR0 here
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 //set RCR
2996 write_nic_dword(dev, RCR, priv->ReceiveConfig);
2997
2998 //Initialize Number of Reserved Pages in Firmware Queue
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 //Set AckTimeout
3010 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
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 //Beacon related
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 //3 For usb rx firmware aggregation control
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 * If usb rx firmware aggregation is enabled,
3042 * when anyone of three threshold conditions above is reached,
3043 * firmware will send aggregated packet to driver.
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 //Firmware download
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) { // User disable RF via registry.
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 // Those actions will be discard in MgntActSet_RF_State because of the same state
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) { // H/W or S/W RF OFF before sleep.
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 // Those actions will be discard in MgntActSet_RF_State because of the same state
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 //config RF.
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 // We can force firmware to do RF-R/W
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 /*--set CCK and OFDM Block "ON"--*/
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 //if D or C cut
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 /* this configures registers for beacon tx and enables it via
3156 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3157 * be used to stop beacon transmission
3158 */
3159 /***************************************************************************
3160 -------------------------------NET STUFF---------------------------
3161 ***************************************************************************/
3162
3163 static 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
3170 bool 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 * <Assumption: RT_TX_SPINLOCK is acquired.>
3187 * First added: 2006.11.19 by emily
3188 */
3189 RESET_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 // Decide such threshold according to current power save mode
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
3220 bool 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 // If rssi is small, we should check rx for long time because of bad rx.
3229 // or maybe it will continuous silent reset every 2 seconds.
3230 rx_chk_cnt++;
3231 if (priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5)) {
3232 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
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
3262 RESET_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 * This function is called by Checkforhang to check whether we should ask OS to reset driver
3282 *
3283 * \param pAdapter The adapter context for this miniport
3284 *
3285 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
3286 * to judge whether there is tx stuck.
3287 * Note: This function may be required to be rewrite for Vista OS.
3288 * <<<Assumption: Tx spinlock has been acquired >>>
3289 *
3290 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
3291 */
3292 RESET_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 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3305 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3306 // if driver is in firmware download failure status, driver should initialize RF in the following
3307 // silent reset procedure Emily, 2008.01.21
3308
3309 // Driver should not check RX stuck in IBSS mode because it is required to
3310 // set Check BSSID in order to send beacon, however, if check BSSID is
3311 // set, STA cannot hear any packet at all. Emily, 2008.04.12
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
3325 void rtl8192_cancel_deferred_work(struct r8192_priv *priv);
3326 int _rtl8192_up(struct net_device *dev);
3327 int rtl8192_close(struct net_device *dev);
3328
3329
3330
3331 void 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 // This function is used to fix Tx/Rx stop bug temporarily.
3403 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3404 // The method checking Tx/Rx stuck of this function is supported by FW,
3405 // which reports Tx and Rx counter to register 0x128 and 0x130.
3406 //////////////////////////////////////////////////////////////
3407 void 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 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3416 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3417
3418 if (priv->ResetProgress == RESET_TYPE_NORESET) {
3419 RESET_START:
3420
3421 RT_TRACE(COMP_RESET, "=========>Reset progress!! \n");
3422
3423 // Set the variable for reset.
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 // For test --> force write UFWP.
3494 write_nic_byte(dev, UFWP, 1);
3495 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
3496 }
3497 }
3498
3499 void 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 // polling bit, and No Write enable, and address
3508 target_command = entry_i+CAM_CONTENT_COUNT*iIndex;
3509 target_command = target_command | BIT31;
3510
3511 //Check polling bit is clear
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
3527 void 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
3546 extern 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 //to get busy traffic condition
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 //added by amy for AP roaming
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 //check if reset the driver
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)))) { // This is control by OID set in Pomelo
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
3610 void 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 }
3616 int _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
3644 int 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
3656 int 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
3666 int 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
3681 int 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 /* FIXME */
3692 if (!netif_queue_stopped(dev))
3693 netif_stop_queue(dev);
3694
3695 rtl8192_rtx_disable(dev);
3696
3697 /* Tx related queue release */
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 //as cancel_delayed_work will del work->timer, so if work is not defined as struct delayed_work, it will corrupt
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
3720 void 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
3737 void 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
3749 static void r8192_set_multicast(struct net_device *dev)
3750 {
3751 struct r8192_priv *priv = ieee80211_priv(dev);
3752 short promisc;
3753
3754 /* FIXME FIXME */
3755
3756 promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
3757
3758 if (promisc != priv->promisc)
3759
3760 priv->promisc = promisc;
3761 }
3762
3763
3764 int 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 /* based on ipw2200 driver */
3780 int 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 //parse here for HW security
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 //we fill both index entry and 4th entry for pairwise key as in IPW interface, adhoc will only get here, so we need index entry for its default key serching!
3832 //added by WB.
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, //KeyIndex
3855 ieee->group_key_type, //KeyType
3856 broadcast_addr, //MacAddr
3857 0, //DefaultKey
3858 key); //KeyContent
3859 }
3860 }
3861 }
3862 #ifdef JOHN_HWSEC_DEBUG
3863 //john's test 0711
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 /*JOHN_HWSEC_DEBUG*/
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;
3880 out:
3881 up(&priv->wx_sem);
3882 return ret;
3883 }
3884
3885 u8 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 * Function: UpdateRxPktTimeStamp
3942 * Overview: Record the TSF time stamp when receiving a packet
3943 *
3944 * Input:
3945 * PADAPTER Adapter
3946 * PRT_RFD pRfd,
3947 *
3948 * Output:
3949 * PRT_RFD pRfd
3950 * (pRfd->Status.TimeStampHigh is updated)
3951 * (pRfd->Status.TimeStampLow is updated)
3952 * Return:
3953 * None
3954 */
3955 void 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 //by amy 080606
3969
3970 long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
3971 {
3972 long signal_power; // in dBm.
3973
3974 // Translate to dBm (x=0.5y-95).
3975 signal_power = (long)((signal_strength_index + 1) >> 1);
3976 signal_power -= 95;
3977
3978 return signal_power;
3979 }
3980
3981
3982 /* 2008/01/22 MH We can not declare RSSI/EVM total value of sliding window to
3983 be a local static. Otherwise, it may increase when we return from S3/S4. The
3984 value will be kept in memory or disk. Declare the value in the adaptor
3985 and it will be reinitialized when returned from S3/S4. */
3986 void 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 //cosa add 04292008 to record the sequence number
4006 pcurrent_stats->Seq_Num = seq;
4007 //
4008 // Check whether we should take the previous packet into accounting
4009 //
4010 if (!pprevious_stats->bIsAMPDU) {
4011 // if previous packet is not aggregated packet
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 // <1> Showed on UI for user, in dbm
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 // If the previous packet does not match the criteria, neglect it
4032 //
4033 if (!pprevious_stats->bPacketMatchBSSID) {
4034 if (!pprevious_stats->bToSelfBA)
4035 return;
4036 }
4037
4038 if (!bcheck)
4039 return;
4040
4041
4042 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
4043
4044 //
4045 // Check RSSI
4046 //
4047 priv->stats.num_process_phyinfo++;
4048
4049 /* record the general signal strength to the sliding window. */
4050
4051
4052 // <2> Showed on UI for engineering
4053 // hardware does not provide rssi information for each rf path in CCK
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 //Fixed by Jacken 2008-03-20
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 // Check PWDB.
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 /* record the beacon pwdb to the sliding window. */
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) // initialize
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 // Check EVM
4124 //
4125 /* record the general EVM to the sliding window. */
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 // <1> Showed on UI for user, in percentage.
4141 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
4142 priv->stats.signal_quality = tmp_val;
4143 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4144 priv->stats.last_signal_strength_inpercent = tmp_val;
4145 }
4146
4147 // <2> Showed on UI for engineering
4148 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
4149 for (nspatial_stream = 0; nspatial_stream < 2; nspatial_stream++) { // 2 spatial stream
4150 if (pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1) {
4151 if (priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
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 * Function: rtl819x_query_rxpwrpercentage()
4166 *
4167 * Overview:
4168 *
4169 * Input: char antpower
4170 *
4171 * Output: NONE
4172 *
4173 * Return: 0-100 percentage
4174 *
4175 * Revised History:
4176 * When Who Remark
4177 * 05/26/2008 amy Create Version 0 porting from windows code.
4178 *
4179 *---------------------------------------------------------------------------*/
4180 static 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 } /* QueryRxPwrPercentage */
4190
4191 static 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 // Description:
4209 // We want good-looking for signal strength/quality
4210 // 2007/7/19 01:09, by cosa.
4211 //
4212 long rtl819x_signal_scale_mapping(long currsig)
4213 {
4214 long retsig;
4215
4216 // Step 1. Scale mapping.
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
4241 static 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
4257 static 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 // Record it for next packet processing
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 /* Move pointer to the 16th bytes. Phy status start address. */
4295 prxpkt += sizeof(rx_drvinfo_819x_usb);
4296
4297 /* Initial the cck and ofdm buffer pointer */
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 // (1)Hardware does not provide RSSI for CCK
4309 //
4310
4311 //
4312 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
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 //Fixed by Jacken from Bryant 2008-03-20
4323 //Original value is -38 , -26 , -14 , -2
4324 //Fixed value is -35 , -23 , -11 , 6
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 // (3) Get Signal Quality (EVM)
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 // (1)Get RSSI for HT rate
4385 //
4386 for (i = RF90_PATH_A; i < priv->NumTotalRFPath; i++) {
4387 // 2008/01/30 MH we will judge RF RX path now.
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 //Fixed by Jacken from Bryant 2008-03-20
4397 //Original value is 106
4398 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
4399
4400 //Get Rx snr value in DB
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 /* Translate DBM to percentage. */
4407 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
4408 total_rssi += RSSI;
4409
4410 /* Record Signal Strength for next packet */
4411 pstats->RxMIMOSignalStrength[i] = (u8) RSSI;
4412 precord_stats->RxMIMOSignalStrength[i] = (u8) RSSI;
4413 }
4414
4415
4416 //
4417 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4418 //
4419 //Fixed by Jacken from Bryant 2008-03-20
4420 //Original value is 106
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 // (3)EVM of HT rate
4429 //
4430 if (pdrvinfo->RxHT && pdrvinfo->RxRate >= DESC90_RATEMCS8 &&
4431 pdrvinfo->RxRate <= DESC90_RATEMCS15)
4432 max_spatial_stream = 2; //both spatial stream make sense
4433 else
4434 max_spatial_stream = 1; //only spatial stream 1 makes sense
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 // Do not use shift operation like "rx_evmX >>= 1" because the compiler of free build environment
4441 // will set the most significant bit to "zero" when doing shifting operation which may change a negative
4442 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
4443 rx_evmX /= 2; //dbm
4444
4445 evm = rtl819x_evm_dbtopercentage(rx_evmX);
4446 if (i == 0) // Fill value in RFD, Get the first spatial stream only
4447 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
4448 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
4449 }
4450
4451
4452 /* record rx statistics for debug */
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) //40M channel
4456 priv->stats.received_bwtype[1+prxsc->rxsc]++;
4457 else //20M channel
4458 priv->stats.received_bwtype[0]++;
4459 }
4460
4461 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
4462 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
4463 if (is_cck_rate) {
4464 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));
4465 } else {
4466 // We can judge RX path number now.
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 } /* QueryRxPhyStatus8190Pci */
4471
4472 void 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
4481 void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
4482 struct ieee80211_rx_stats *pstats,
4483 rx_drvinfo_819x_usb *pdrvinfo)
4484 {
4485 // TODO: We must only check packet for current MAC address. Not finish
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;//by amy
4493 u16 fc, type;
4494
4495 // Get Signal Quality for only RX data queue (but not command queue)
4496
4497 u8 *tmp_buf;
4498 u8 *praddr;
4499
4500 /* Get MAC frame start address. */
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 /* Check if the received packet is acceptable. */
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 // Process PHY information for previous packet (RSSI/PWDB/EVM)
4529 //
4530 // Because phy information is contained in the last packet of AMPDU only, so driver
4531 // should process phy information of previous packet
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 * Function: UpdateReceivedRateHistogramStatistics
4540 * Overview: Record the received data rate
4541 *
4542 * Input:
4543 * struct net_device *dev
4544 * struct ieee80211_rx_stats *stats
4545 *
4546 * Output:
4547 *
4548 * (priv->stats.ReceivedRateHistogram[] is updated)
4549 * Return:
4550 * None
4551 */
4552 void 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; //0: Total, 1:OK, 2:CRC, 3:ICV
4557 u32 rateIndex;
4558 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
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;// short
4568 else
4569 preamble_guardinterval = 0;// long
4570
4571 switch (stats->rate) {
4572 //
4573 // CCK rate
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 // Legacy OFDM rate
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 // 11n High throughput rate
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]++; //total
4613 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
4614 }
4615
4616
4617 void 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 //Get Rx Descriptor Information
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; //RxBufShift = 2 in RxDesc, but usb didn't shift bytes in fact.
4633 stats->bICV = desc->ICV;
4634 stats->bCRC = desc->CRC32;
4635 stats->bHwError = stats->bCRC|stats->bICV;
4636 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
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 //RTL8190 set this bit to indicate that Hw does not decrypt packet
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 //Get Driver Info
4661 //
4662 // TODO: Need to verify it on FGPA platform
4663 //Driver info are written to the RxBuffer following rx desc
4664 if (stats->RxDrvInfoSize != 0) {
4665 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) +
4666 stats->RxBufShift);
4667 /* unit: 0.5M */
4668 /* TODO */
4669 if (!stats->bHwError) {
4670 u8 ret_rate;
4671 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
4672 if (ret_rate == 0xff) {
4673 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
4674 // Special Error Handling here, 2008.05.16, by Emily
4675
4676 stats->bHwError = 1;
4677 stats->rate = MGN_1M; //Set 1M rate by default
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 // xiong mask it, 070514
4694
4695 UpdateRxPktTimeStamp8190(dev, stats);
4696
4697 //
4698 // Rx A-MPDU
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 // Get Total offset of MPDU Frame Body
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 /* for the rx aggregated sub frame, the redundant space truly contained in the packet */
4717 if (bIsRxAggrSubframe)
4718 skb_pull(skb, 8);
4719 #endif
4720 /* for debug 2008.5.29 */
4721
4722 //added by vivi, for MP, 20080108
4723 stats->RxIs40MHzPacket = driver_info->BW;
4724 if (stats->RxDrvInfoSize != 0)
4725 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
4726
4727 }
4728
4729 u32 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
4741 void 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 //add just for testing
4766 u8 testing;
4767
4768 #endif
4769
4770 /* 20 is for ps-poll */
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 /* first packet should not contain Rx aggregation header */
4776 query_rxdesc_status(skb, &stats, false);
4777 /* TODO */
4778 /* hardware related info */
4779 #ifdef USB_RX_AGGREGATION_SUPPORT
4780 if (TempByte & BIT0) {
4781 agg_skb = skb;
4782 TotalLength = stats.Length - 4; /*sCrcLng*/
4783 /* though the head pointer has passed this position */
4784 TempDWord = *(u32 *)(agg_skb->data - 4);
4785 PacketLength = (u16)(TempDWord & 0x3FFF); /*sCrcLng*/
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 /* Process the MPDU received */
4792 skb_trim(skb, skb->len - 4/*sCrcLng*/);
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 //TODO
4799 } else if (is_multicast_ether_addr(ieee80211_hdr->addr1)) {
4800 //TODO
4801 } else {
4802 /* unicast packet */
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; /*- PacketLength */
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 /* Process the MPDU received */
4846 skb = dev_alloc_skb(PacketLength);
4847 memcpy(skb_put(skb, PacketLength), agg_skb->data, PacketLength);
4848 skb_trim(skb, skb->len - 4/*sCrcLng*/);
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 //TODO
4855 } else if (is_multicast_ether_addr(ieee80211_hdr->addr1)) {
4856 //TODO
4857 } else {
4858 /* unicast packet */
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 /* should trim the packet which has been copied to target skb */
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
4891 void 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 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
4899 //porting by amy 080508
4900 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
4901 frame = pstats->virtual_address;
4902 frame_len = pstats->packetlength;
4903 #ifdef TODO // by amy about HCT
4904 if (!Adapter->bInHctTest)
4905 CountRxErrStatistics(Adapter, pRfd);
4906 #endif
4907 #ifdef ENABLE_PS //by amy for adding ps function in future
4908 RT_RF_POWER_STATE rtState;
4909 // When RF is off, we should not count the packet for hw/sw synchronize
4910 // reason, ie. there may be a duration while sw switch is changed and hw
4911 // switch is being changed. 2006.12.04, by shien chang.
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 /* 2007/01/16 MH Add RX command packet handle here. */
4922 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
4923 if (rtl819xusb_rx_command_packet(dev, pstats))
4924 return;
4925
4926 #ifdef SW_CRC_CHECK
4927 SwCrcCheck();
4928 #endif
4929
4930
4931 }
4932
4933 void 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 //Get Rx Descriptor Information
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
4951 void 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 /* TODO */
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 // this is to be done by amy 080508 prfd->queue_id = 1;
4967
4968
4969 //
4970 // Process the command packet received.
4971 //
4972
4973 rtl819xusb_process_received_packet(dev, &stats);
4974
4975 dev_kfree_skb_any(skb);
4976 }
4977 }
4978
4979 void 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 /* Nomal packet pipe */
4988 case 3:
4989 priv->IrpPendingCount--;
4990 rtl8192_rx_nomal(skb);
4991 break;
4992
4993 /* Command packet pipe */
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: /* should never get here! */
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
5011 static 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 ---------------------------- USB_STUFF---------------------------
5027 *****************************************************************************/
5028
5029 static 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; //modified by john, 0805
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
5086 fail2:
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);
5093 fail:
5094 free_ieee80211(dev);
5095
5096 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
5097 return ret;
5098 }
5099
5100 //detach all the work and timer structure declared or inititialize in r8192U_init function.
5101 void 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
5111 static 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 /* fun with the built-in ieee80211 stack... */
5136 extern int ieee80211_debug_init(void);
5137 extern void ieee80211_debug_exit(void);
5138 extern int ieee80211_crypto_init(void);
5139 extern void ieee80211_crypto_deinit(void);
5140 extern int ieee80211_crypto_tkip_init(void);
5141 extern void ieee80211_crypto_tkip_exit(void);
5142 extern int ieee80211_crypto_ccmp_init(void);
5143 extern void ieee80211_crypto_ccmp_exit(void);
5144 extern int ieee80211_crypto_wep_init(void);
5145 extern void ieee80211_crypto_wep_exit(void);
5146
5147 static 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
5191 static void __exit rtl8192_usb_module_exit(void)
5192 {
5193 usb_deregister(&rtl8192_usb_driver);
5194
5195 RT_TRACE(COMP_DOWN, "Exiting");
5196 }
5197
5198
5199 void 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
5213 void 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 //add HWSec active enable here.
5227 //default using hwsec. when peer AP is in N mode only and pairwise_key_type is none_aes(which HT_IOT_ACT_PURE_N_MODE indicates it), use software security. when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes, use g mode hw security. WB on 2008.7.4
5228
5229 ieee->hwsec_active = 1;
5230
5231 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep) { //add hwsec_support flag to totol control hw_sec on/off
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
5241 void 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) { //MAC|Config
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) { //MAC
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 //Key Material
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 ------------------- module init / exit stubs ----------------
5290 ****************************************************************************/
5291 module_init(rtl8192_usb_module_init);
5292 module_exit(rtl8192_usb_module_exit);
Linus' kernel tree