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