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