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