drivers/staging/rtl8192u/r8192U_core.c

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