Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/staging/rtl8192u/r8192U_core.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us