Version:  2.0.40 2.2.26 2.4.37 3.10 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

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

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