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

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

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