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