Pileus Git - ~andy/linux/blob - drivers/staging/rtl8192u/r8192U_core.c

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