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

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