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