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