Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

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

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