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