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         int ret = 0;
1915         unsigned long flags;
1916         u32 size = sizeof(struct ieee80211_qos_parameters);
1917         int set_qos_param = 0;
1918
1919         if ((priv == NULL) || (network == NULL))
1920                 return ret;
1921
1922         if (priv->ieee80211->state != IEEE80211_LINKED)
1923                 return ret;
1924
1925         if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1926                 return ret;
1927
1928         spin_lock_irqsave(&priv->ieee80211->lock, flags);
1929         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1930                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1931                        &network->qos_data.parameters,
1932                        sizeof(struct ieee80211_qos_parameters));
1933                 priv->ieee80211->current_network.qos_data.active = 1;
1934                 set_qos_param = 1;
1935                 /* update qos parameter for current network */
1936                 priv->ieee80211->current_network.qos_data.old_param_count =
1937                         priv->ieee80211->current_network.qos_data.param_count;
1938                 priv->ieee80211->current_network.qos_data.param_count =
1939                         network->qos_data.param_count;
1940         } else {
1941                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1942                        &def_qos_parameters, size);
1943                 priv->ieee80211->current_network.qos_data.active = 0;
1944                 priv->ieee80211->current_network.qos_data.supported = 0;
1945                 set_qos_param = 1;
1946         }
1947
1948         spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
1949
1950         RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __func__, network->flags, priv->ieee80211->current_network.qos_data.active);
1951         if (set_qos_param == 1)
1952                 queue_work(priv->priv_wq, &priv->qos_activate);
1953
1954
1955         return ret;
1956 }
1957
1958
1959 static int rtl8192_handle_assoc_response(struct net_device *dev,
1960                                          struct ieee80211_assoc_response_frame *resp,
1961                                          struct ieee80211_network *network)
1962 {
1963         struct r8192_priv *priv = ieee80211_priv(dev);
1964         rtl8192_qos_association_resp(priv, network);
1965         return 0;
1966 }
1967
1968
1969 void rtl8192_update_ratr_table(struct net_device *dev)
1970 {
1971         struct r8192_priv *priv = ieee80211_priv(dev);
1972         struct ieee80211_device *ieee = priv->ieee80211;
1973         u8 *pMcsRate = ieee->dot11HTOperationalRateSet;
1974         u32 ratr_value = 0;
1975         u8 rate_index = 0;
1976         rtl8192_config_rate(dev, (u16 *)(&ratr_value));
1977         ratr_value |= (*(u16 *)(pMcsRate)) << 12;
1978         switch (ieee->mode) {
1979         case IEEE_A:
1980                 ratr_value &= 0x00000FF0;
1981                 break;
1982         case IEEE_B:
1983                 ratr_value &= 0x0000000F;
1984                 break;
1985         case IEEE_G:
1986                 ratr_value &= 0x00000FF7;
1987                 break;
1988         case IEEE_N_24G:
1989         case IEEE_N_5G:
1990                 if (ieee->pHTInfo->PeerMimoPs == 0) { /* MIMO_PS_STATIC */
1991                         ratr_value &= 0x0007F007;
1992                 } else {
1993                         if (priv->rf_type == RF_1T2R)
1994                                 ratr_value &= 0x000FF007;
1995                         else
1996                                 ratr_value &= 0x0F81F007;
1997                 }
1998                 break;
1999         default:
2000                 break;
2001         }
2002         ratr_value &= 0x0FFFFFFF;
2003         if (ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz)
2004                 ratr_value |= 0x80000000;
2005         else if (!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)
2006                 ratr_value |= 0x80000000;
2007         write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2008         write_nic_byte(dev, UFWP, 1);
2009 }
2010
2011 static u8 ccmp_ie[4] = {0x00, 0x50, 0xf2, 0x04};
2012 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2013 static bool GetNmodeSupportBySecCfg8192(struct net_device *dev)
2014 {
2015         struct r8192_priv *priv = ieee80211_priv(dev);
2016         struct ieee80211_device *ieee = priv->ieee80211;
2017         struct ieee80211_network *network = &ieee->current_network;
2018         int wpa_ie_len = ieee->wpa_ie_len;
2019         struct ieee80211_crypt_data *crypt;
2020         int encrypt;
2021
2022         crypt = ieee->crypt[ieee->tx_keyidx];
2023         //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
2024         encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name, "WEP")));
2025
2026         /* simply judge  */
2027         if (encrypt && (wpa_ie_len == 0)) {
2028                 /* wep encryption, no N mode setting */
2029                 return false;
2030         } else if ((wpa_ie_len != 0)) {
2031                 /* parse pairwise key type */
2032                 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))))
2033                         return true;
2034                 else
2035                         return false;
2036         } else {
2037                 return true;
2038         }
2039
2040         return true;
2041 }
2042
2043 static bool GetHalfNmodeSupportByAPs819xUsb(struct net_device *dev)
2044 {
2045         bool                    Reval;
2046         struct r8192_priv *priv = ieee80211_priv(dev);
2047         struct ieee80211_device *ieee = priv->ieee80211;
2048
2049         if (ieee->bHalfWirelessN24GMode == true)
2050                 Reval = true;
2051         else
2052                 Reval =  false;
2053
2054         return Reval;
2055 }
2056
2057 static void rtl8192_refresh_supportrate(struct r8192_priv *priv)
2058 {
2059         struct ieee80211_device *ieee = priv->ieee80211;
2060         //we do not consider set support rate for ABG mode, only HT MCS rate is set here.
2061         if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2062                 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2063         else
2064                 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2065         return;
2066 }
2067
2068 static u8 rtl8192_getSupportedWireleeMode(struct net_device *dev)
2069 {
2070         struct r8192_priv *priv = ieee80211_priv(dev);
2071         u8 ret = 0;
2072         switch (priv->rf_chip) {
2073         case RF_8225:
2074         case RF_8256:
2075         case RF_PSEUDO_11N:
2076                 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2077                 break;
2078         case RF_8258:
2079                 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2080                 break;
2081         default:
2082                 ret = WIRELESS_MODE_B;
2083                 break;
2084         }
2085         return ret;
2086 }
2087 static void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode)
2088 {
2089         struct r8192_priv *priv = ieee80211_priv(dev);
2090         u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2091
2092         if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode) == 0)) {
2093                 if (bSupportMode & WIRELESS_MODE_N_24G) {
2094                         wireless_mode = WIRELESS_MODE_N_24G;
2095                 } else if (bSupportMode & WIRELESS_MODE_N_5G) {
2096                         wireless_mode = WIRELESS_MODE_N_5G;
2097                 } else if ((bSupportMode & WIRELESS_MODE_A)) {
2098                         wireless_mode = WIRELESS_MODE_A;
2099                 } else if ((bSupportMode & WIRELESS_MODE_G)) {
2100                         wireless_mode = WIRELESS_MODE_G;
2101                 } else if ((bSupportMode & WIRELESS_MODE_B)) {
2102                         wireless_mode = WIRELESS_MODE_B;
2103                 } else {
2104                         RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __func__, bSupportMode);
2105                         wireless_mode = WIRELESS_MODE_B;
2106                 }
2107         }
2108 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2109         ActUpdateChannelAccessSetting(pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting);
2110 #endif
2111         priv->ieee80211->mode = wireless_mode;
2112
2113         if ((wireless_mode == WIRELESS_MODE_N_24G) ||  (wireless_mode == WIRELESS_MODE_N_5G))
2114                 priv->ieee80211->pHTInfo->bEnableHT = 1;
2115         else
2116                 priv->ieee80211->pHTInfo->bEnableHT = 0;
2117         RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2118         rtl8192_refresh_supportrate(priv);
2119
2120 }
2121 //init priv variables here. only non_zero value should be initialized here.
2122 static void rtl8192_init_priv_variable(struct net_device *dev)
2123 {
2124         struct r8192_priv *priv = ieee80211_priv(dev);
2125         u8 i;
2126         priv->card_8192 = NIC_8192U;
2127         priv->chan = 1; //set to channel 1
2128         priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2129         priv->ieee80211->iw_mode = IW_MODE_INFRA;
2130         priv->ieee80211->ieee_up = 0;
2131         priv->retry_rts = DEFAULT_RETRY_RTS;
2132         priv->retry_data = DEFAULT_RETRY_DATA;
2133         priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2134         priv->ieee80211->rate = 110; //11 mbps
2135         priv->ieee80211->short_slot = 1;
2136         priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2137         priv->CckPwEnl = 6;
2138         //for silent reset
2139         priv->IrpPendingCount = 1;
2140         priv->ResetProgress = RESET_TYPE_NORESET;
2141         priv->bForcedSilentReset = 0;
2142         priv->bDisableNormalResetCheck = false;
2143         priv->force_reset = false;
2144
2145         priv->ieee80211->FwRWRF = 0;    //we don't use FW read/write RF until stable firmware is available.
2146         priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2147         priv->ieee80211->softmac_features  = IEEE_SOFTMAC_SCAN |
2148                 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2149                 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2150                 IEEE_SOFTMAC_BEACONS;//added by amy 080604
2151
2152         priv->ieee80211->active_scan = 1;
2153         priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2154         priv->ieee80211->host_encrypt = 1;
2155         priv->ieee80211->host_decrypt = 1;
2156         priv->ieee80211->start_send_beacons = NULL; //-by amy 080604
2157         priv->ieee80211->stop_send_beacons = NULL;  //-by amy 080604
2158         priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2159         priv->ieee80211->set_chan = rtl8192_set_chan;
2160         priv->ieee80211->link_change = rtl8192_link_change;
2161         priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2162         priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2163         priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2164         priv->ieee80211->init_wmmparam_flag = 0;
2165         priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2166         priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2167         priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2168         priv->ieee80211->qos_support = 1;
2169
2170         //added by WB
2171         priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2172         priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2173         priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2174         //added by david
2175         priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2176         priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2177         priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2178         //added by amy
2179         priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2180         priv->card_type = USB;
2181 #ifdef TO_DO_LIST
2182         if (Adapter->bInHctTest) {
2183                 pHalData->ShortRetryLimit = 7;
2184                 pHalData->LongRetryLimit = 7;
2185         }
2186 #endif
2187         priv->ShortRetryLimit = 0x30;
2188         priv->LongRetryLimit = 0x30;
2189         priv->EarlyRxThreshold = 7;
2190         priv->enable_gpio0 = 0;
2191         priv->TransmitConfig =
2192                 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)|  // Max DMA Burst Size per Tx DMA Burst, 7: reserved.
2193                 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)|        // Short retry limit
2194                 (priv->LongRetryLimit<<TCR_LRL_OFFSET) |        // Long retry limit
2195                 (false ? TCR_SAT : 0);  // FALSE: HW provides PLCP length and LENGEXT, TRUE: SW provides them
2196 #ifdef TO_DO_LIST
2197         if (Adapter->bInHctTest)
2198                 pHalData->ReceiveConfig =       pHalData->CSMethod |
2199                                                 RCR_AMF | RCR_ADF |     //accept management/data
2200                                                 //guangan200710
2201                                                 RCR_ACF |       //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2202                                                 RCR_AB | RCR_AM | RCR_APM |             //accept BC/MC/UC
2203                                                 RCR_AICV | RCR_ACRC32 |                 //accept ICV/CRC error packet
2204                                                 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2205                                                 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2206                                                 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt : 0);
2207         else
2208
2209 #endif
2210         priv->ReceiveConfig     =
2211                 RCR_AMF | RCR_ADF |             //accept management/data
2212                 RCR_ACF |                       //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2213                 RCR_AB | RCR_AM | RCR_APM |     //accept BC/MC/UC
2214                 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2215                 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2216                 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT : 0);
2217
2218         priv->AcmControl = 0;
2219         priv->pFirmware = kzalloc(sizeof(rt_firmware), GFP_KERNEL);
2220
2221         /* rx related queue */
2222         skb_queue_head_init(&priv->rx_queue);
2223         skb_queue_head_init(&priv->skb_queue);
2224
2225         /* Tx related queue */
2226         for (i = 0; i < MAX_QUEUE_SIZE; i++)
2227                 skb_queue_head_init(&priv->ieee80211->skb_waitQ[i]);
2228         for (i = 0; i < MAX_QUEUE_SIZE; i++)
2229                 skb_queue_head_init(&priv->ieee80211->skb_aggQ[i]);
2230         for (i = 0; i < MAX_QUEUE_SIZE; i++)
2231                 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ[i]);
2232         priv->rf_set_chan = rtl8192_phy_SwChnl;
2233 }
2234
2235 //init lock here
2236 static void rtl8192_init_priv_lock(struct r8192_priv *priv)
2237 {
2238         spin_lock_init(&priv->tx_lock);
2239         spin_lock_init(&priv->irq_lock);//added by thomas
2240         sema_init(&priv->wx_sem, 1);
2241         sema_init(&priv->rf_sem, 1);
2242         mutex_init(&priv->mutex);
2243 }
2244
2245 extern  void    rtl819x_watchdog_wqcallback(struct work_struct *work);
2246
2247 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2248 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2249 #define DRV_NAME "wlan0"
2250 static void rtl8192_init_priv_task(struct net_device *dev)
2251 {
2252         struct r8192_priv *priv = ieee80211_priv(dev);
2253
2254         priv->priv_wq = create_workqueue(DRV_NAME);
2255
2256         INIT_WORK(&priv->reset_wq, rtl8192_restart);
2257
2258         INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2259         INIT_DELAYED_WORK(&priv->txpower_tracking_wq,  dm_txpower_trackingcallback);
2260         INIT_DELAYED_WORK(&priv->rfpath_check_wq,  dm_rf_pathcheck_workitemcallback);
2261         INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2262         INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2263         INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2264
2265         tasklet_init(&priv->irq_rx_tasklet,
2266                      (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2267                      (unsigned long)priv);
2268 }
2269
2270 static void rtl8192_get_eeprom_size(struct net_device *dev)
2271 {
2272         u16 curCR = 0;
2273         struct r8192_priv *priv = ieee80211_priv(dev);
2274         RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
2275         read_nic_word_E(dev, EPROM_CMD, &curCR);
2276         RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2277         //whether need I consider BIT5?
2278         priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2279         RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __func__, priv->epromtype);
2280 }
2281
2282 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2283 static inline u16 endian_swap(u16 *data)
2284 {
2285         u16 tmp = *data;
2286         *data = (tmp >> 8) | (tmp << 8);
2287         return *data;
2288 }
2289 static void rtl8192_read_eeprom_info(struct net_device *dev)
2290 {
2291         u16 wEPROM_ID = 0;
2292         u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2293         u8 bLoad_From_EEPOM = false;
2294         struct r8192_priv *priv = ieee80211_priv(dev);
2295         u16 tmpValue = 0;
2296         int i;
2297         RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
2298         wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2299         RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2300
2301         if (wEPROM_ID != RTL8190_EEPROM_ID) {
2302                 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2303         } else {
2304                 bLoad_From_EEPOM = true;
2305         }
2306
2307         if (bLoad_From_EEPOM) {
2308                 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2309                 priv->eeprom_vid = endian_swap(&tmpValue);
2310                 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2311                 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2312                 priv->eeprom_ChannelPlan = ((tmpValue&0xff00)>>8);
2313                 priv->btxpowerdata_readfromEEPORM = true;
2314                 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2315         } else {
2316                 priv->eeprom_vid = 0;
2317                 priv->eeprom_pid = 0;
2318                 priv->card_8192_version = VERSION_819xU_B;
2319                 priv->eeprom_ChannelPlan = 0;
2320                 priv->eeprom_CustomerID = 0;
2321         }
2322         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);
2323         //set channelplan from eeprom
2324         priv->ChannelPlan = priv->eeprom_ChannelPlan;
2325         if (bLoad_From_EEPOM) {
2326                 int i;
2327                 for (i = 0; i < 6; i += 2) {
2328                         u16 tmp = 0;
2329                         tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2330                         *(u16 *)(&dev->dev_addr[i]) = tmp;
2331                 }
2332         } else {
2333                 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2334                 //should I set IDR0 here?
2335         }
2336         RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2337         priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2338         priv->rf_chip = RF_8256;
2339
2340         if (priv->card_8192_version == (u8)VERSION_819xU_A) {
2341                 //read Tx power gain offset of legacy OFDM to HT rate
2342                 if (bLoad_From_EEPOM)
2343                         priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2344                 else
2345                         priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2346                 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2347                 //read ThermalMeter from EEPROM
2348                 if (bLoad_From_EEPOM)
2349                         priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2350                 else
2351                         priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2352                 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2353                 //vivi, for tx power track
2354                 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2355                 //read antenna tx power offset of B/C/D to A from EEPROM
2356                 if (bLoad_From_EEPOM)
2357                         priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2358                 else
2359                         priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2360                 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2361                 // Read CrystalCap from EEPROM
2362                 if (bLoad_From_EEPOM)
2363                         priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2364                 else
2365                         priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2366                 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2367                 //get per-channel Tx power level
2368                 if (bLoad_From_EEPOM)
2369                         priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2370                 else
2371                         priv->EEPROM_Def_Ver = 1;
2372                 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
2373                 if (priv->EEPROM_Def_Ver == 0) { /* old eeprom definition */
2374                         int i;
2375                         if (bLoad_From_EEPOM)
2376                                 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
2377                         else
2378                                 priv->EEPROMTxPowerLevelCCK = 0x10;
2379                         RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
2380                         for (i = 0; i < 3; i++) {
2381                                 if (bLoad_From_EEPOM) {
2382                                         tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
2383                                         if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
2384                                                 tmpValue = tmpValue & 0x00ff;
2385                                         else
2386                                                 tmpValue = (tmpValue & 0xff00) >> 8;
2387                                 } else {
2388                                         tmpValue = 0x10;
2389                                 }
2390                                 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
2391                                 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
2392                         }
2393                 } else if (priv->EEPROM_Def_Ver == 1) {
2394                         if (bLoad_From_EEPOM) {
2395                                 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
2396                                 tmpValue = (tmpValue & 0xff00) >> 8;
2397                         } else {
2398                                 tmpValue = 0x10;
2399                         }
2400                         priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
2401
2402                         if (bLoad_From_EEPOM)
2403                                 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
2404                         else
2405                                 tmpValue = 0x1010;
2406                         *((u16 *)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
2407                         if (bLoad_From_EEPOM)
2408                                 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
2409                         else
2410                                 tmpValue = 0x1010;
2411                         *((u16 *)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
2412                         if (bLoad_From_EEPOM)
2413                                 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
2414                         else
2415                                 tmpValue = 0x10;
2416                         priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
2417                 }//endif EEPROM_Def_Ver == 1
2418
2419                 //update HAL variables
2420                 //
2421                 for (i = 0; i < 14; i++) {
2422                         if (i <= 3)
2423                                 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
2424                         else if (i >= 4 && i <= 9)
2425                                 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
2426                         else
2427                                 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
2428                 }
2429
2430                 for (i = 0; i < 14; i++) {
2431                         if (priv->EEPROM_Def_Ver == 0) {
2432                                 if (i <= 3)
2433                                         priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2434                                 else if (i >= 4 && i <= 9)
2435                                         priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
2436                                 else
2437                                         priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2438                         } else if (priv->EEPROM_Def_Ver == 1) {
2439                                 if (i <= 3)
2440                                         priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
2441                                 else if (i >= 4 && i <= 9)
2442                                         priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
2443                                 else
2444                                         priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
2445                         }
2446                 }
2447                 priv->TxPowerDiff = priv->EEPROMPwDiff;
2448                 // Antenna B gain offset to antenna A, bit0~3
2449                 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
2450                 // Antenna C gain offset to antenna A, bit4~7
2451                 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
2452                 // CrystalCap, bit12~15
2453                 priv->CrystalCap = priv->EEPROMCrystalCap;
2454                 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2455                 // 92U does not enable TX power tracking.
2456                 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
2457         }//end if VersionID == VERSION_819xU_A
2458
2459         //added by vivi, for dlink led, 20080416
2460         switch (priv->eeprom_CustomerID) {
2461         case EEPROM_CID_RUNTOP:
2462                 priv->CustomerID = RT_CID_819x_RUNTOP;
2463                 break;
2464
2465         case EEPROM_CID_DLINK:
2466                 priv->CustomerID = RT_CID_DLINK;
2467                 break;
2468
2469         default:
2470                 priv->CustomerID = RT_CID_DEFAULT;
2471                 break;
2472
2473         }
2474
2475         switch (priv->CustomerID) {
2476         case RT_CID_819x_RUNTOP:
2477                 priv->LedStrategy = SW_LED_MODE2;
2478                 break;
2479
2480         case RT_CID_DLINK:
2481                 priv->LedStrategy = SW_LED_MODE4;
2482                 break;
2483
2484         default:
2485                 priv->LedStrategy = SW_LED_MODE0;
2486                 break;
2487
2488         }
2489
2490
2491         if (priv->rf_type == RF_1T2R) {
2492                 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
2493         } else {
2494                 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
2495         }
2496
2497         // 2008/01/16 MH We can only know RF type in the function. So we have to init
2498         // DIG RATR table again.
2499         init_rate_adaptive(dev);
2500         //we need init DIG RATR table here again.
2501
2502         RT_TRACE(COMP_EPROM, "<===========%s()\n", __func__);
2503         return;
2504 }
2505
2506 static short rtl8192_get_channel_map(struct net_device *dev)
2507 {
2508         struct r8192_priv *priv = ieee80211_priv(dev);
2509         if (priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN) {
2510                 netdev_err(dev, "rtl8180_init: Error channel plan! Set to default.\n");
2511                 priv->ChannelPlan = 0;
2512         }
2513         RT_TRACE(COMP_INIT, "Channel plan is %d\n", priv->ChannelPlan);
2514
2515         rtl819x_set_channel_map(priv->ChannelPlan, priv);
2516         return 0;
2517 }
2518
2519 static short rtl8192_init(struct net_device *dev)
2520 {
2521
2522         struct r8192_priv *priv = ieee80211_priv(dev);
2523
2524         memset(&(priv->stats), 0, sizeof(struct Stats));
2525         memset(priv->txqueue_to_outpipemap, 0, 9);
2526 #ifdef PIPE12
2527         {
2528                 int i = 0;
2529                 u8 queuetopipe[] = {3, 2, 1, 0, 4, 8, 7, 6, 5};
2530                 memcpy(priv->txqueue_to_outpipemap, queuetopipe, 9);
2531         }
2532 #else
2533         {
2534                 u8 queuetopipe[] = {3, 2, 1, 0, 4, 4, 0, 4, 4};
2535                 memcpy(priv->txqueue_to_outpipemap, queuetopipe, 9);
2536         }
2537 #endif
2538         rtl8192_init_priv_variable(dev);
2539         rtl8192_init_priv_lock(priv);
2540         rtl8192_init_priv_task(dev);
2541         rtl8192_get_eeprom_size(dev);
2542         rtl8192_read_eeprom_info(dev);
2543         rtl8192_get_channel_map(dev);
2544         init_hal_dm(dev);
2545         init_timer(&priv->watch_dog_timer);
2546         priv->watch_dog_timer.data = (unsigned long)dev;
2547         priv->watch_dog_timer.function = watch_dog_timer_callback;
2548         if (rtl8192_usb_initendpoints(dev) != 0) {
2549                 DMESG("Endopoints initialization failed");
2550                 return -ENOMEM;
2551         }
2552
2553         return 0;
2554 }
2555
2556 /******************************************************************************
2557  *function:  This function actually only set RRSR, RATR and BW_OPMODE registers
2558  *           not to do all the hw config as its name says
2559  *   input:  net_device dev
2560  *  output:  none
2561  *  return:  none
2562  *  notice:  This part need to modified according to the rate set we filtered
2563  * ****************************************************************************/
2564 static void rtl8192_hwconfig(struct net_device *dev)
2565 {
2566         u32 regRATR = 0, regRRSR = 0;
2567         u8 regBwOpMode = 0, regTmp = 0;
2568         struct r8192_priv *priv = ieee80211_priv(dev);
2569         u32 ratr_value = 0;
2570
2571         // Set RRSR, RATR, and BW_OPMODE registers
2572         //
2573         switch (priv->ieee80211->mode) {
2574         case WIRELESS_MODE_B:
2575                 regBwOpMode = BW_OPMODE_20MHZ;
2576                 regRATR = RATE_ALL_CCK;
2577                 regRRSR = RATE_ALL_CCK;
2578                 break;
2579         case WIRELESS_MODE_A:
2580                 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
2581                 regRATR = RATE_ALL_OFDM_AG;
2582                 regRRSR = RATE_ALL_OFDM_AG;
2583                 break;
2584         case WIRELESS_MODE_G:
2585                 regBwOpMode = BW_OPMODE_20MHZ;
2586                 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2587                 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2588                 break;
2589         case WIRELESS_MODE_AUTO:
2590 #ifdef TO_DO_LIST
2591                 if (Adapter->bInHctTest) {
2592                         regBwOpMode = BW_OPMODE_20MHZ;
2593                         regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2594                         regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2595                 }
2596                 else
2597 #endif
2598                 {
2599                         regBwOpMode = BW_OPMODE_20MHZ;
2600                         regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2601                         regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2602                 }
2603                 break;
2604         case WIRELESS_MODE_N_24G:
2605                 // It support CCK rate by default.
2606                 // CCK rate will be filtered out only when associated AP does not support it.
2607                 regBwOpMode = BW_OPMODE_20MHZ;
2608                 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2609                 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2610                 break;
2611         case WIRELESS_MODE_N_5G:
2612                 regBwOpMode = BW_OPMODE_5G;
2613                 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2614                 regRRSR = RATE_ALL_OFDM_AG;
2615                 break;
2616         }
2617
2618         write_nic_byte(dev, BW_OPMODE, regBwOpMode);
2619         ratr_value = regRATR;
2620         if (priv->rf_type == RF_1T2R)
2621                 ratr_value &= ~(RATE_ALL_OFDM_2SS);
2622         write_nic_dword(dev, RATR0, ratr_value);
2623         write_nic_byte(dev, UFWP, 1);
2624         read_nic_byte(dev, 0x313, &regTmp);
2625         regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2626         write_nic_dword(dev, RRSR, regRRSR);
2627
2628         //
2629         // Set Retry Limit here
2630         //
2631         write_nic_word(dev, RETRY_LIMIT,
2632                        priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
2633                        priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
2634         // Set Contention Window here
2635
2636         // Set Tx AGC
2637
2638         // Set Tx Antenna including Feedback control
2639
2640         // Set Auto Rate fallback control
2641
2642
2643 }
2644
2645
2646 //InitializeAdapter and PhyCfg
2647 static bool rtl8192_adapter_start(struct net_device *dev)
2648 {
2649         struct r8192_priv *priv = ieee80211_priv(dev);
2650         u32 dwRegRead = 0;
2651         bool init_status = true;
2652         u8 SECR_value = 0x0;
2653         u8 tmp;
2654         RT_TRACE(COMP_INIT, "====>%s()\n", __func__);
2655         priv->Rf_Mode = RF_OP_By_SW_3wire;
2656         //for ASIC power on sequence
2657         write_nic_byte_E(dev, 0x5f, 0x80);
2658         mdelay(50);
2659         write_nic_byte_E(dev, 0x5f, 0xf0);
2660         write_nic_byte_E(dev, 0x5d, 0x00);
2661         write_nic_byte_E(dev, 0x5e, 0x80);
2662         write_nic_byte(dev, 0x17, 0x37);
2663         mdelay(10);
2664         priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
2665         //config CPUReset Register
2666         //Firmware Reset or not?
2667         read_nic_dword(dev, CPU_GEN, &dwRegRead);
2668         if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
2669                 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
2670         else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
2671                 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
2672         else
2673                 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __func__,   priv->pFirmware->firmware_status);
2674
2675         write_nic_dword(dev, CPU_GEN, dwRegRead);
2676         //config BB.
2677         rtl8192_BBConfig(dev);
2678
2679         //Loopback mode or not
2680         priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
2681
2682         read_nic_dword(dev, CPU_GEN, &dwRegRead);
2683         if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
2684                 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
2685         else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
2686                 dwRegRead |= CPU_CCK_LOOPBACK;
2687         else
2688                 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __func__,  priv->LoopbackMode);
2689
2690         write_nic_dword(dev, CPU_GEN, dwRegRead);
2691
2692         //after reset cpu, we need wait for a seconds to write in register.
2693         udelay(500);
2694
2695         //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
2696         read_nic_byte_E(dev, 0x5f, &tmp);
2697         write_nic_byte_E(dev, 0x5f, tmp|0x20);
2698
2699         //Set Hardware
2700         rtl8192_hwconfig(dev);
2701
2702         //turn on Tx/Rx
2703         write_nic_byte(dev, CMDR, CR_RE|CR_TE);
2704
2705         //set IDR0 here
2706         write_nic_dword(dev, MAC0, ((u32 *)dev->dev_addr)[0]);
2707         write_nic_word(dev, MAC4, ((u16 *)(dev->dev_addr + 4))[0]);
2708
2709         //set RCR
2710         write_nic_dword(dev, RCR, priv->ReceiveConfig);
2711
2712         //Initialize Number of Reserved Pages in Firmware Queue
2713         write_nic_dword(dev, RQPN1,  NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
2714                         NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
2715                         NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
2716                         NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
2717         write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |
2718                         NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
2719         write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
2720                         NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT);
2721         write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
2722
2723         //Set AckTimeout
2724         // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
2725         write_nic_byte(dev, ACK_TIMEOUT, 0x30);
2726
2727         if (priv->ResetProgress == RESET_TYPE_NORESET)
2728                 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
2729         if (priv->ResetProgress == RESET_TYPE_NORESET) {
2730                 CamResetAllEntry(dev);
2731                 SECR_value |= SCR_TxEncEnable;
2732                 SECR_value |= SCR_RxDecEnable;
2733                 SECR_value |= SCR_NoSKMC;
2734                 write_nic_byte(dev, SECR, SECR_value);
2735         }
2736
2737         //Beacon related
2738         write_nic_word(dev, ATIMWND, 2);
2739         write_nic_word(dev, BCN_INTERVAL, 100);
2740
2741 #define DEFAULT_EDCA 0x005e4332
2742         {
2743                 int i;
2744                 for (i = 0; i < QOS_QUEUE_NUM; i++)
2745                         write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
2746         }
2747
2748         rtl8192_phy_configmac(dev);
2749
2750         if (priv->card_8192_version == (u8) VERSION_819xU_A) {
2751                 rtl8192_phy_getTxPower(dev);
2752                 rtl8192_phy_setTxPower(dev, priv->chan);
2753         }
2754
2755         //Firmware download
2756         init_status = init_firmware(dev);
2757         if (!init_status) {
2758                 RT_TRACE(COMP_ERR, "ERR!!! %s(): Firmware download is failed\n", __func__);
2759                 return init_status;
2760         }
2761         RT_TRACE(COMP_INIT, "%s():after firmware download\n", __func__);
2762         //
2763 #ifdef TO_DO_LIST
2764         if (Adapter->ResetProgress == RESET_TYPE_NORESET) {
2765                 if (pMgntInfo->RegRfOff == TRUE) { /* User disable RF via registry. */
2766                         RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
2767                         MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
2768                         // Those actions will be discard in MgntActSet_RF_State because of the same state
2769                         for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)
2770                                 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
2771                 } else if (pMgntInfo->RfOffReason > RF_CHANGE_BY_PS) { /* H/W or S/W RF OFF before sleep. */
2772                         RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
2773                         MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
2774                 } else {
2775                         pHalData->eRFPowerState = eRfOn;
2776                         pMgntInfo->RfOffReason = 0;
2777                         RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
2778                 }
2779         } else {
2780                 if (pHalData->eRFPowerState == eRfOff) {
2781                         MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
2782                         // Those actions will be discard in MgntActSet_RF_State because of the same state
2783                         for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)
2784                                 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
2785                 }
2786         }
2787 #endif
2788         //config RF.
2789         if (priv->ResetProgress == RESET_TYPE_NORESET) {
2790                 rtl8192_phy_RFConfig(dev);
2791                 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __func__);
2792         }
2793
2794
2795         if (priv->ieee80211->FwRWRF)
2796                 // We can force firmware to do RF-R/W
2797                 priv->Rf_Mode = RF_OP_By_FW;
2798         else
2799                 priv->Rf_Mode = RF_OP_By_SW_3wire;
2800
2801
2802         rtl8192_phy_updateInitGain(dev);
2803         /*--set CCK and OFDM Block "ON"--*/
2804         rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
2805         rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
2806
2807         if (priv->ResetProgress == RESET_TYPE_NORESET) {
2808                 //if D or C cut
2809                 u8 tmpvalue;
2810                 read_nic_byte(dev, 0x301, &tmpvalue);
2811                 if (tmpvalue == 0x03) {
2812                         priv->bDcut = TRUE;
2813                         RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
2814                 } else {
2815                         priv->bDcut = FALSE;
2816                         RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
2817                 }
2818                 dm_initialize_txpower_tracking(dev);
2819
2820                 if (priv->bDcut == TRUE) {
2821                         u32 i, TempCCk;
2822                         u32 tmpRegA = rtl8192_QueryBBReg(dev, rOFDM0_XATxIQImbalance, bMaskDWord);
2823                         for (i = 0; i < TxBBGainTableLength; i++) {
2824                                 if (tmpRegA == priv->txbbgain_table[i].txbbgain_value) {
2825                                         priv->rfa_txpowertrackingindex = (u8)i;
2826                                         priv->rfa_txpowertrackingindex_real = (u8)i;
2827                                         priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
2828                                         break;
2829                                 }
2830                         }
2831
2832                         TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
2833
2834                         for (i = 0; i < CCKTxBBGainTableLength; i++) {
2835
2836                                 if (TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0]) {
2837                                         priv->cck_present_attentuation_20Mdefault = (u8) i;
2838                                         break;
2839                                 }
2840                         }
2841                         priv->cck_present_attentuation_40Mdefault = 0;
2842                         priv->cck_present_attentuation_difference = 0;
2843                         priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
2844
2845                 }
2846         }
2847         write_nic_byte(dev, 0x87, 0x0);
2848
2849
2850         return init_status;
2851 }
2852
2853 /* this configures registers for beacon tx and enables it via
2854  * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
2855  * be used to stop beacon transmission
2856  */
2857 /***************************************************************************
2858     -------------------------------NET STUFF---------------------------
2859 ***************************************************************************/
2860
2861 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
2862 {
2863         struct r8192_priv *priv = ieee80211_priv(dev);
2864
2865         return &priv->ieee80211->stats;
2866 }
2867
2868 static bool HalTxCheckStuck819xUsb(struct net_device *dev)
2869 {
2870         struct r8192_priv *priv = ieee80211_priv(dev);
2871         u16             RegTxCounter;
2872         bool            bStuck = FALSE;
2873         read_nic_word(dev, 0x128, &RegTxCounter);
2874         RT_TRACE(COMP_RESET, "%s():RegTxCounter is %d,TxCounter is %d\n", __func__, RegTxCounter, priv->TxCounter);
2875         if (priv->TxCounter == RegTxCounter)
2876                 bStuck = TRUE;
2877
2878         priv->TxCounter = RegTxCounter;
2879
2880         return bStuck;
2881 }
2882
2883 /*
2884 *       <Assumption: RT_TX_SPINLOCK is acquired.>
2885 *       First added: 2006.11.19 by emily
2886 */
2887 static RESET_TYPE TxCheckStuck(struct net_device *dev)
2888 {
2889         struct r8192_priv *priv = ieee80211_priv(dev);
2890         u8                      QueueID;
2891         bool                    bCheckFwTxCnt = false;
2892
2893         //
2894         // Decide such threshold according to current power save mode
2895         //
2896
2897         for (QueueID = 0; QueueID <= BEACON_QUEUE; QueueID++) {
2898                 if (QueueID == TXCMD_QUEUE)
2899                         continue;
2900                 if ((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0)  && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
2901                         continue;
2902
2903                 bCheckFwTxCnt = true;
2904         }
2905         if (bCheckFwTxCnt) {
2906                 if (HalTxCheckStuck819xUsb(dev)) {
2907                         RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
2908                         return RESET_TYPE_SILENT;
2909                 }
2910         }
2911         return RESET_TYPE_NORESET;
2912 }
2913
2914 static bool HalRxCheckStuck819xUsb(struct net_device *dev)
2915 {
2916         u16     RegRxCounter;
2917         struct r8192_priv *priv = ieee80211_priv(dev);
2918         bool bStuck = FALSE;
2919         static u8       rx_chk_cnt;
2920         read_nic_word(dev, 0x130, &RegRxCounter);
2921         RT_TRACE(COMP_RESET, "%s(): RegRxCounter is %d,RxCounter is %d\n", __func__, RegRxCounter, priv->RxCounter);
2922         // If rssi is small, we should check rx for long time because of bad rx.
2923         // or maybe it will continuous silent reset every 2 seconds.
2924         rx_chk_cnt++;
2925         if (priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5)) {
2926                 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
2927         } else if (priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
2928                    ((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_40M) ||
2929                     (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_20M))) {
2930                 if (rx_chk_cnt < 2)
2931                         return bStuck;
2932                 else
2933                         rx_chk_cnt = 0;
2934         } else if (((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_40M) ||
2935                     (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_20M)) &&
2936                      priv->undecorated_smoothed_pwdb >= VeryLowRSSI) {
2937                 if (rx_chk_cnt < 4)
2938                         return bStuck;
2939                 else
2940                         rx_chk_cnt = 0;
2941         } else {
2942                 if (rx_chk_cnt < 8)
2943                         return bStuck;
2944                 else
2945                         rx_chk_cnt = 0;
2946         }
2947
2948         if (priv->RxCounter == RegRxCounter)
2949                 bStuck = TRUE;
2950
2951         priv->RxCounter = RegRxCounter;
2952
2953         return bStuck;
2954 }
2955
2956 static RESET_TYPE RxCheckStuck(struct net_device *dev)
2957 {
2958         struct r8192_priv *priv = ieee80211_priv(dev);
2959         bool        bRxCheck = FALSE;
2960
2961         if (priv->IrpPendingCount > 1)
2962                 bRxCheck = TRUE;
2963
2964         if (bRxCheck) {
2965                 if (HalRxCheckStuck819xUsb(dev)) {
2966                         RT_TRACE(COMP_RESET, "RxStuck Condition\n");
2967                         return RESET_TYPE_SILENT;
2968                 }
2969         }
2970         return RESET_TYPE_NORESET;
2971 }
2972
2973
2974 /**
2975 *       This function is called by Checkforhang to check whether we should ask OS to reset driver
2976 *
2977 *       \param pAdapter The adapter context for this miniport
2978 *
2979 *       Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
2980 *       to judge whether there is tx stuck.
2981 *       Note: This function may be required to be rewrite for Vista OS.
2982 *       <<<Assumption: Tx spinlock has been acquired >>>
2983 *
2984 *       8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
2985 */
2986 static RESET_TYPE rtl819x_ifcheck_resetornot(struct net_device *dev)
2987 {
2988         struct r8192_priv *priv = ieee80211_priv(dev);
2989         RESET_TYPE      TxResetType = RESET_TYPE_NORESET;
2990         RESET_TYPE      RxResetType = RESET_TYPE_NORESET;
2991         RT_RF_POWER_STATE       rfState;
2992
2993         rfState = priv->ieee80211->eRFPowerState;
2994
2995         TxResetType = TxCheckStuck(dev);
2996         if (rfState != eRfOff ||
2997             (priv->ieee80211->iw_mode != IW_MODE_ADHOC)) {
2998                 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
2999                 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3000                 // if driver is in firmware download failure status, driver should initialize RF in the following
3001                 // silent reset procedure Emily, 2008.01.21
3002
3003                 // Driver should not check RX stuck in IBSS mode because it is required to
3004                 // set Check BSSID in order to send beacon, however, if check BSSID is
3005                 // set, STA cannot hear any packet at all. Emily, 2008.04.12
3006                 RxResetType = RxCheckStuck(dev);
3007         }
3008         if (TxResetType == RESET_TYPE_NORMAL || RxResetType == RESET_TYPE_NORMAL) {
3009                 return RESET_TYPE_NORMAL;
3010         } else if (TxResetType == RESET_TYPE_SILENT || RxResetType == RESET_TYPE_SILENT) {
3011                 RT_TRACE(COMP_RESET, "%s():silent reset\n", __func__);
3012                 return RESET_TYPE_SILENT;
3013         } else {
3014                 return RESET_TYPE_NORESET;
3015         }
3016
3017 }
3018
3019 void rtl8192_cancel_deferred_work(struct r8192_priv *priv);
3020 int _rtl8192_up(struct net_device *dev);
3021 int rtl8192_close(struct net_device *dev);
3022
3023
3024
3025 static void CamRestoreAllEntry(struct net_device *dev)
3026 {
3027         u8 EntryId = 0;
3028         struct r8192_priv *priv = ieee80211_priv(dev);
3029         u8      *MacAddr = priv->ieee80211->current_network.bssid;
3030
3031         static u8       CAM_CONST_ADDR[4][6] = {
3032                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3033                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3034                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3035                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} };
3036         static u8       CAM_CONST_BROAD[] = {
3037                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3038
3039         RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3040
3041
3042         if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40) ||
3043             (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104)) {
3044
3045                 for (EntryId = 0; EntryId < 4; EntryId++) {
3046                         MacAddr = CAM_CONST_ADDR[EntryId];
3047                         setKey(dev, EntryId, EntryId,
3048                                priv->ieee80211->pairwise_key_type,
3049                                MacAddr, 0, NULL);
3050                 }
3051
3052         } else if (priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP) {
3053
3054                 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3055                         setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3056                                (u8 *)dev->dev_addr, 0, NULL);
3057                 else
3058                         setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3059                                MacAddr, 0, NULL);
3060         } else if (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP) {
3061
3062                 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3063                         setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3064                                (u8 *)dev->dev_addr, 0, NULL);
3065                 else
3066                         setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3067                                MacAddr, 0, NULL);
3068         }
3069
3070
3071
3072         if (priv->ieee80211->group_key_type == KEY_TYPE_TKIP) {
3073                 MacAddr = CAM_CONST_BROAD;
3074                 for (EntryId = 1; EntryId < 4; EntryId++) {
3075                         setKey(dev, EntryId, EntryId,
3076                                priv->ieee80211->group_key_type,
3077                                MacAddr, 0, NULL);
3078                 }
3079                 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3080                         setKey(dev, 0, 0, priv->ieee80211->group_key_type,
3081                                CAM_CONST_ADDR[0], 0, NULL);
3082         } else if (priv->ieee80211->group_key_type == KEY_TYPE_CCMP) {
3083                 MacAddr = CAM_CONST_BROAD;
3084                 for (EntryId = 1; EntryId < 4; EntryId++) {
3085                         setKey(dev, EntryId, EntryId,
3086                                priv->ieee80211->group_key_type,
3087                                MacAddr, 0, NULL);
3088                 }
3089
3090                 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3091                         setKey(dev, 0, 0, priv->ieee80211->group_key_type,
3092                                CAM_CONST_ADDR[0], 0, NULL);
3093         }
3094 }
3095 //////////////////////////////////////////////////////////////
3096 // This function is used to fix Tx/Rx stop bug temporarily.
3097 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3098 // The method checking Tx/Rx stuck of this function is supported by FW,
3099 // which reports Tx and Rx counter to register 0x128 and 0x130.
3100 //////////////////////////////////////////////////////////////
3101 static void rtl819x_ifsilentreset(struct net_device *dev)
3102 {
3103         struct r8192_priv *priv = ieee80211_priv(dev);
3104         u8      reset_times = 0;
3105         int reset_status = 0;
3106         struct ieee80211_device *ieee = priv->ieee80211;
3107
3108
3109         // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3110         //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3111
3112         if (priv->ResetProgress == RESET_TYPE_NORESET) {
3113 RESET_START:
3114
3115                 RT_TRACE(COMP_RESET, "=========>Reset progress!! \n");
3116
3117                 // Set the variable for reset.
3118                 priv->ResetProgress = RESET_TYPE_SILENT;
3119                 down(&priv->wx_sem);
3120                 if (priv->up == 0) {
3121                         RT_TRACE(COMP_ERR, "%s():the driver is not up! return\n", __func__);
3122                         up(&priv->wx_sem);
3123                         return;
3124                 }
3125                 priv->up = 0;
3126                 RT_TRACE(COMP_RESET, "%s():======>start to down the driver\n", __func__);
3127
3128                 rtl8192_rtx_disable(dev);
3129                 rtl8192_cancel_deferred_work(priv);
3130                 deinit_hal_dm(dev);
3131                 del_timer_sync(&priv->watch_dog_timer);
3132
3133                 ieee->sync_scan_hurryup = 1;
3134                 if (ieee->state == IEEE80211_LINKED) {
3135                         down(&ieee->wx_sem);
3136                         netdev_dbg(dev, "ieee->state is IEEE80211_LINKED\n");
3137                         ieee80211_stop_send_beacons(priv->ieee80211);
3138                         del_timer_sync(&ieee->associate_timer);
3139                         cancel_delayed_work(&ieee->associate_retry_wq);
3140                         ieee80211_stop_scan(ieee);
3141                         netif_carrier_off(dev);
3142                         up(&ieee->wx_sem);
3143                 } else {
3144                         netdev_dbg(dev, "ieee->state is NOT LINKED\n");
3145                         ieee80211_softmac_stop_protocol(priv->ieee80211);
3146                 }
3147                 up(&priv->wx_sem);
3148                 RT_TRACE(COMP_RESET, "%s():<==========down process is finished\n", __func__);
3149                 RT_TRACE(COMP_RESET, "%s():===========>start up the driver\n", __func__);
3150                 reset_status = _rtl8192_up(dev);
3151
3152                 RT_TRACE(COMP_RESET, "%s():<===========up process is finished\n", __func__);
3153                 if (reset_status == -EAGAIN) {
3154                         if (reset_times < 3) {
3155                                 reset_times++;
3156                                 goto RESET_START;
3157                         } else {
3158                                 RT_TRACE(COMP_ERR, " ERR!!! %s():  Reset Failed!!\n", __func__);
3159                         }
3160                 }
3161                 ieee->is_silent_reset = 1;
3162                 EnableHWSecurityConfig8192(dev);
3163                 if (ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
3164                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
3165
3166                         queue_work(ieee->wq, &ieee->associate_complete_wq);
3167
3168                 } else if (ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC) {
3169                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
3170                         ieee->link_change(ieee->dev);
3171
3172                         ieee80211_start_send_beacons(ieee);
3173
3174                         if (ieee->data_hard_resume)
3175                                 ieee->data_hard_resume(ieee->dev);
3176                         netif_carrier_on(ieee->dev);
3177                 }
3178
3179                 CamRestoreAllEntry(dev);
3180
3181                 priv->ResetProgress = RESET_TYPE_NORESET;
3182                 priv->reset_count++;
3183
3184                 priv->bForcedSilentReset = false;
3185                 priv->bResetInProgress = false;
3186
3187                 // For test --> force write UFWP.
3188                 write_nic_byte(dev, UFWP, 1);
3189                 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
3190         }
3191 }
3192
3193 void CAM_read_entry(struct net_device *dev, u32 iIndex)
3194 {
3195         u32 target_command = 0;
3196         u32 target_content = 0;
3197         u8 entry_i = 0;
3198         u32 ulStatus;
3199         s32 i = 100;
3200         for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
3201                 // polling bit, and No Write enable, and address
3202                 target_command = entry_i+CAM_CONTENT_COUNT*iIndex;
3203                 target_command = target_command | BIT31;
3204
3205                 //Check polling bit is clear
3206                 while ((i--) >= 0) {
3207                         read_nic_dword(dev, RWCAM, &ulStatus);
3208                         if (ulStatus & BIT31)
3209                                 continue;
3210                         else
3211                                 break;
3212                 }
3213                 write_nic_dword(dev, RWCAM, target_command);
3214                 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A0: %x \n", target_command);
3215                 read_nic_dword(dev, RCAMO, &target_content);
3216                 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n", target_content);
3217         }
3218         printk("\n");
3219 }
3220
3221 static void rtl819x_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum,
3222                              u32 *TotalRxDataNum)
3223 {
3224         u16                     SlotIndex;
3225         u8                      i;
3226
3227         *TotalRxBcnNum = 0;
3228         *TotalRxDataNum = 0;
3229
3230         SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
3231         priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
3232         priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
3233         for (i = 0; i < priv->ieee80211->LinkDetectInfo.SlotNum; i++) {
3234                 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
3235                 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
3236         }
3237 }
3238
3239
3240 void rtl819x_watchdog_wqcallback(struct work_struct *work)
3241 {
3242         struct delayed_work *dwork = container_of(work, struct delayed_work, work);
3243         struct r8192_priv *priv = container_of(dwork, struct r8192_priv, watch_dog_wq);
3244         struct net_device *dev = priv->ieee80211->dev;
3245         struct ieee80211_device *ieee = priv->ieee80211;
3246         RESET_TYPE      ResetType = RESET_TYPE_NORESET;
3247         static u8       check_reset_cnt;
3248         bool bBusyTraffic = false;
3249         u32     TotalRxBcnNum = 0;
3250         u32     TotalRxDataNum = 0;
3251
3252         if (!priv->up)
3253                 return;
3254         hal_dm_watchdog(dev);
3255
3256         //to get busy traffic condition
3257         if (ieee->state == IEEE80211_LINKED) {
3258                 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 666 ||
3259                     ieee->LinkDetectInfo.NumTxOkInPeriod > 666 ) {
3260                         bBusyTraffic = true;
3261                 }
3262                 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
3263                 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
3264                 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
3265         }
3266         //added by amy for AP roaming
3267         if (priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA) {
3268
3269                 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
3270                 if ((TotalRxBcnNum+TotalRxDataNum) == 0) {
3271 #ifdef TODO
3272                         if (rfState == eRfOff)
3273                                 RT_TRACE(COMP_ERR, "========>%s()\n", __func__);
3274 #endif
3275                         netdev_dbg(dev, "===>%s(): AP is power off, connect another one\n", __func__);
3276                         priv->ieee80211->state = IEEE80211_ASSOCIATING;
3277                         notify_wx_assoc_event(priv->ieee80211);
3278                         RemovePeerTS(priv->ieee80211, priv->ieee80211->current_network.bssid);
3279                         priv->ieee80211->link_change(dev);
3280                         queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
3281
3282                 }
3283         }
3284         priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod = 0;
3285         priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod = 0;
3286         //check if reset the driver
3287         if (check_reset_cnt++ >= 3) {
3288                 ResetType = rtl819x_ifcheck_resetornot(dev);
3289                 check_reset_cnt = 3;
3290         }
3291         if ((priv->force_reset) || (priv->ResetProgress == RESET_TYPE_NORESET &&
3292             (priv->bForcedSilentReset ||
3293             (!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_SILENT)))) { /* This is control by OID set in Pomelo */
3294                 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);
3295                 rtl819x_ifsilentreset(dev);
3296         }
3297         priv->force_reset = false;
3298         priv->bForcedSilentReset = false;
3299         priv->bResetInProgress = false;
3300         RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
3301
3302 }
3303
3304 void watch_dog_timer_callback(unsigned long data)
3305 {
3306         struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
3307         queue_delayed_work(priv->priv_wq, &priv->watch_dog_wq, 0);
3308         mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
3309 }
3310 int _rtl8192_up(struct net_device *dev)
3311 {
3312         struct r8192_priv *priv = ieee80211_priv(dev);
3313         int init_status = 0;
3314         priv->up = 1;
3315         priv->ieee80211->ieee_up = 1;
3316         RT_TRACE(COMP_INIT, "Bringing up iface");
3317         init_status = rtl8192_adapter_start(dev);
3318         if (!init_status) {
3319                 RT_TRACE(COMP_ERR, "ERR!!! %s(): initialization failed!\n", __func__);
3320                 priv->up = priv->ieee80211->ieee_up = 0;
3321                 return -EAGAIN;
3322         }
3323         RT_TRACE(COMP_INIT, "start adapter finished\n");
3324         rtl8192_rx_enable(dev);
3325         if (priv->ieee80211->state != IEEE80211_LINKED)
3326                 ieee80211_softmac_start_protocol(priv->ieee80211);
3327         ieee80211_reset_queue(priv->ieee80211);
3328         watch_dog_timer_callback((unsigned long) dev);
3329         if (!netif_queue_stopped(dev))
3330                 netif_start_queue(dev);
3331         else
3332                 netif_wake_queue(dev);
3333
3334         return 0;
3335 }
3336
3337
3338 static int rtl8192_open(struct net_device *dev)
3339 {
3340         struct r8192_priv *priv = ieee80211_priv(dev);
3341         int ret;
3342         down(&priv->wx_sem);
3343         ret = rtl8192_up(dev);
3344         up(&priv->wx_sem);
3345         return ret;
3346
3347 }
3348
3349
3350 int rtl8192_up(struct net_device *dev)
3351 {
3352         struct r8192_priv *priv = ieee80211_priv(dev);
3353
3354         if (priv->up == 1)
3355                 return -1;
3356
3357         return _rtl8192_up(dev);
3358 }
3359
3360
3361 int rtl8192_close(struct net_device *dev)
3362 {
3363         struct r8192_priv *priv = ieee80211_priv(dev);
3364         int ret;
3365
3366         down(&priv->wx_sem);
3367
3368         ret = rtl8192_down(dev);
3369
3370         up(&priv->wx_sem);
3371
3372         return ret;
3373
3374 }
3375
3376 int rtl8192_down(struct net_device *dev)
3377 {
3378         struct r8192_priv *priv = ieee80211_priv(dev);
3379         int i;
3380
3381         if (priv->up == 0)
3382                 return -1;
3383
3384         priv->up = 0;
3385         priv->ieee80211->ieee_up = 0;
3386         RT_TRACE(COMP_DOWN, "==========>%s()\n", __func__);
3387         /* FIXME */
3388         if (!netif_queue_stopped(dev))
3389                 netif_stop_queue(dev);
3390
3391         rtl8192_rtx_disable(dev);
3392
3393         /* Tx related queue release */
3394         for (i = 0; i < MAX_QUEUE_SIZE; i++)
3395                 skb_queue_purge(&priv->ieee80211->skb_waitQ[i]);
3396         for (i = 0; i < MAX_QUEUE_SIZE; i++)
3397                 skb_queue_purge(&priv->ieee80211->skb_aggQ[i]);
3398
3399         for (i = 0; i < MAX_QUEUE_SIZE; i++)
3400                 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ[i]);
3401
3402         //as cancel_delayed_work will del work->timer, so if work is not defined as struct delayed_work, it will corrupt
3403         rtl8192_cancel_deferred_work(priv);
3404         deinit_hal_dm(dev);
3405         del_timer_sync(&priv->watch_dog_timer);
3406
3407
3408         ieee80211_softmac_stop_protocol(priv->ieee80211);
3409         memset(&priv->ieee80211->current_network, 0, offsetof(struct ieee80211_network, list));
3410         RT_TRACE(COMP_DOWN, "<==========%s()\n", __func__);
3411
3412         return 0;
3413 }
3414
3415
3416 void rtl8192_commit(struct net_device *dev)
3417 {
3418         struct r8192_priv *priv = ieee80211_priv(dev);
3419         int reset_status = 0;
3420         if (priv->up == 0)
3421                 return;
3422         priv->up = 0;
3423
3424         rtl8192_cancel_deferred_work(priv);
3425         del_timer_sync(&priv->watch_dog_timer);
3426
3427         ieee80211_softmac_stop_protocol(priv->ieee80211);
3428
3429         rtl8192_rtx_disable(dev);
3430         reset_status = _rtl8192_up(dev);
3431
3432 }
3433
3434 void rtl8192_restart(struct work_struct *work)
3435 {
3436         struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
3437         struct net_device *dev = priv->ieee80211->dev;
3438
3439         down(&priv->wx_sem);
3440
3441         rtl8192_commit(dev);
3442
3443         up(&priv->wx_sem);
3444 }
3445
3446 static void r8192_set_multicast(struct net_device *dev)
3447 {
3448         struct r8192_priv *priv = ieee80211_priv(dev);
3449         short promisc;
3450
3451         /* FIXME FIXME */
3452
3453         promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
3454
3455         if (promisc != priv->promisc)
3456
3457                 priv->promisc = promisc;
3458 }
3459
3460
3461 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
3462 {
3463         struct r8192_priv *priv = ieee80211_priv(dev);
3464         struct sockaddr *addr = mac;
3465
3466         down(&priv->wx_sem);
3467
3468         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3469
3470         schedule_work(&priv->reset_wq);
3471         up(&priv->wx_sem);
3472
3473         return 0;
3474 }
3475
3476 /* based on ipw2200 driver */
3477 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3478 {
3479         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3480         struct iwreq *wrq = (struct iwreq *)rq;
3481         int ret = -1;
3482         struct ieee80211_device *ieee = priv->ieee80211;
3483         u32 key[4];
3484         u8 broadcast_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3485         struct iw_point *p = &wrq->u.data;
3486         struct ieee_param *ipw = NULL;
3487
3488         down(&priv->wx_sem);
3489
3490
3491         if (p->length < sizeof(struct ieee_param) || !p->pointer) {
3492                 ret = -EINVAL;
3493                 goto out;
3494         }
3495
3496         ipw = memdup_user(p->pointer, p->length);
3497         if (IS_ERR(ipw)) {
3498                 ret = PTR_ERR(ipw);
3499                 goto out;
3500         }
3501
3502         switch (cmd) {
3503         case RTL_IOCTL_WPA_SUPPLICANT:
3504                 //parse here for HW security
3505                 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION) {
3506                         if (ipw->u.crypt.set_tx) {
3507                                 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
3508                                         ieee->pairwise_key_type = KEY_TYPE_CCMP;
3509                                 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
3510                                         ieee->pairwise_key_type = KEY_TYPE_TKIP;
3511                                 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
3512                                         if (ipw->u.crypt.key_len == 13)
3513                                                 ieee->pairwise_key_type = KEY_TYPE_WEP104;
3514                                         else if (ipw->u.crypt.key_len == 5)
3515                                                 ieee->pairwise_key_type = KEY_TYPE_WEP40;
3516                                 } else {
3517                                         ieee->pairwise_key_type = KEY_TYPE_NA;
3518                                 }
3519
3520                                 if (ieee->pairwise_key_type) {
3521                                         memcpy((u8 *)key, ipw->u.crypt.key, 16);
3522                                         EnableHWSecurityConfig8192(dev);
3523                                         //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!
3524                                         //added by WB.
3525                                         setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key);
3526                                         if (ieee->auth_mode != 2)
3527                                                 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key);
3528                                 }
3529                         } else {
3530                                 memcpy((u8 *)key, ipw->u.crypt.key, 16);
3531                                 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
3532                                         ieee->group_key_type = KEY_TYPE_CCMP;
3533                                 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
3534                                         ieee->group_key_type = KEY_TYPE_TKIP;
3535                                 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
3536                                         if (ipw->u.crypt.key_len == 13)
3537                                                 ieee->group_key_type = KEY_TYPE_WEP104;
3538                                         else if (ipw->u.crypt.key_len == 5)
3539                                                 ieee->group_key_type = KEY_TYPE_WEP40;
3540                                 } else {
3541                                         ieee->group_key_type = KEY_TYPE_NA;
3542                                 }
3543
3544                                 if (ieee->group_key_type) {
3545                                         setKey(dev, ipw->u.crypt.idx,
3546                                                ipw->u.crypt.idx,                //KeyIndex
3547                                                ieee->group_key_type,    //KeyType
3548                                                broadcast_addr,  //MacAddr
3549                                                0,               //DefaultKey
3550                                                key);            //KeyContent
3551                                 }
3552                         }
3553                 }
3554                 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
3555                 break;
3556
3557         default:
3558                 ret = -EOPNOTSUPP;
3559                 break;
3560         }
3561         kfree(ipw);
3562         ipw = NULL;
3563 out:
3564         up(&priv->wx_sem);
3565         return ret;
3566 }
3567
3568 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
3569 {
3570         u8  ret_rate = 0xff;
3571
3572         if (!bIsHT) {
3573                 switch (rate) {
3574                         case DESC90_RATE1M:
3575                                 ret_rate = MGN_1M;
3576                                 break;
3577                         case DESC90_RATE2M:
3578                                 ret_rate = MGN_2M;
3579                                 break;
3580                         case DESC90_RATE5_5M:
3581                                 ret_rate = MGN_5_5M;
3582                                 break;
3583                         case DESC90_RATE11M:
3584                                 ret_rate = MGN_11M;
3585                                 break;
3586                         case DESC90_RATE6M:
3587                                 ret_rate = MGN_6M;
3588                                 break;
3589                         case DESC90_RATE9M:
3590                                 ret_rate = MGN_9M;
3591                                 break;
3592                         case DESC90_RATE12M:
3593                                 ret_rate = MGN_12M;
3594                                 break;
3595                         case DESC90_RATE18M:
3596                                 ret_rate = MGN_18M;
3597                                 break;
3598                         case DESC90_RATE24M:
3599                                 ret_rate = MGN_24M;
3600                                 break;
3601                         case DESC90_RATE36M:
3602                                 ret_rate = MGN_36M;
3603                                 break;
3604                         case DESC90_RATE48M:
3605                                 ret_rate = MGN_48M;
3606                                 break;
3607                         case DESC90_RATE54M:
3608                                 ret_rate = MGN_54M;
3609                                 break;
3610
3611                         default:
3612                                 ret_rate = 0xff;
3613                                 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
3614                                 break;
3615                 }
3616
3617         } else {
3618                 switch (rate) {
3619                         case DESC90_RATEMCS0:
3620                                 ret_rate = MGN_MCS0;
3621                                 break;
3622                         case DESC90_RATEMCS1:
3623                                 ret_rate = MGN_MCS1;
3624                                 break;
3625                         case DESC90_RATEMCS2:
3626                                 ret_rate = MGN_MCS2;
3627                                 break;
3628                         case DESC90_RATEMCS3:
3629                                 ret_rate = MGN_MCS3;
3630                                 break;
3631                         case DESC90_RATEMCS4:
3632                                 ret_rate = MGN_MCS4;
3633                                 break;
3634                         case DESC90_RATEMCS5:
3635                                 ret_rate = MGN_MCS5;
3636                                 break;
3637                         case DESC90_RATEMCS6:
3638                                 ret_rate = MGN_MCS6;
3639                                 break;
3640                         case DESC90_RATEMCS7:
3641                                 ret_rate = MGN_MCS7;
3642                                 break;
3643                         case DESC90_RATEMCS8:
3644                                 ret_rate = MGN_MCS8;
3645                                 break;
3646                         case DESC90_RATEMCS9:
3647                                 ret_rate = MGN_MCS9;
3648                                 break;
3649                         case DESC90_RATEMCS10:
3650                                 ret_rate = MGN_MCS10;
3651                                 break;
3652                         case DESC90_RATEMCS11:
3653                                 ret_rate = MGN_MCS11;
3654                                 break;
3655                         case DESC90_RATEMCS12:
3656                                 ret_rate = MGN_MCS12;
3657                                 break;
3658                         case DESC90_RATEMCS13:
3659                                 ret_rate = MGN_MCS13;
3660                                 break;
3661                         case DESC90_RATEMCS14:
3662                                 ret_rate = MGN_MCS14;
3663                                 break;
3664                         case DESC90_RATEMCS15:
3665                                 ret_rate = MGN_MCS15;
3666                                 break;
3667                         case DESC90_RATEMCS32:
3668                                 ret_rate = (0x80|0x20);
3669                                 break;
3670
3671                         default:
3672                                 ret_rate = 0xff;
3673                                 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
3674                                 break;
3675                 }
3676         }
3677
3678         return ret_rate;
3679 }
3680
3681 /**
3682  * Function:     UpdateRxPktTimeStamp
3683  * Overview:     Record the TSF time stamp when receiving a packet
3684  *
3685  * Input:
3686  *       PADAPTER        Adapter
3687  *       PRT_RFD         pRfd,
3688  *
3689  * Output:
3690  *       PRT_RFD         pRfd
3691  *                               (pRfd->Status.TimeStampHigh is updated)
3692  *                               (pRfd->Status.TimeStampLow is updated)
3693  * Return:
3694  *               None
3695  */
3696 static void UpdateRxPktTimeStamp8190(struct net_device *dev,
3697                                      struct ieee80211_rx_stats *stats)
3698 {
3699         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3700
3701         if (stats->bIsAMPDU && !stats->bFirstMPDU) {
3702                 stats->mac_time[0] = priv->LastRxDescTSFLow;
3703                 stats->mac_time[1] = priv->LastRxDescTSFHigh;
3704         } else {
3705                 priv->LastRxDescTSFLow = stats->mac_time[0];
3706                 priv->LastRxDescTSFHigh = stats->mac_time[1];
3707         }
3708 }
3709
3710 //by amy 080606
3711
3712 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
3713 {
3714         long    signal_power; // in dBm.
3715
3716         // Translate to dBm (x=0.5y-95).
3717         signal_power = (long)((signal_strength_index + 1) >> 1);
3718         signal_power -= 95;
3719
3720         return signal_power;
3721 }
3722
3723
3724 /* 2008/01/22 MH We can not declare RSSI/EVM total value of sliding window to
3725     be a local static. Otherwise, it may increase when we return from S3/S4. The
3726     value will be kept in memory or disk. Declare the value in the adaptor
3727     and it will be reinitialized when returned from S3/S4. */
3728 static void rtl8192_process_phyinfo(struct r8192_priv *priv, u8 *buffer,
3729                                     struct ieee80211_rx_stats *pprevious_stats,
3730                                     struct ieee80211_rx_stats *pcurrent_stats)
3731 {
3732         bool bcheck = false;
3733         u8      rfpath;
3734         u32     nspatial_stream, tmp_val;
3735         static u32 slide_rssi_index, slide_rssi_statistics;
3736         static u32 slide_evm_index, slide_evm_statistics;
3737         static u32 last_rssi, last_evm;
3738
3739         static u32 slide_beacon_adc_pwdb_index, slide_beacon_adc_pwdb_statistics;
3740         static u32 last_beacon_adc_pwdb;
3741
3742         struct ieee80211_hdr_3addr *hdr;
3743         u16 sc;
3744         unsigned int frag, seq;
3745         hdr = (struct ieee80211_hdr_3addr *)buffer;
3746         sc = le16_to_cpu(hdr->seq_ctl);
3747         frag = WLAN_GET_SEQ_FRAG(sc);
3748         seq = WLAN_GET_SEQ_SEQ(sc);
3749         //cosa add 04292008 to record the sequence number
3750         pcurrent_stats->Seq_Num = seq;
3751         //
3752         // Check whether we should take the previous packet into accounting
3753         //
3754         if (!pprevious_stats->bIsAMPDU) {
3755                 // if previous packet is not aggregated packet
3756                 bcheck = true;
3757         }
3758
3759         if (slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX) {
3760                 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
3761                 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
3762                 priv->stats.slide_rssi_total -= last_rssi;
3763         }
3764         priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
3765
3766         priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
3767         if (slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
3768                 slide_rssi_index = 0;
3769
3770         // <1> Showed on UI for user, in dbm
3771         tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
3772         priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
3773         pcurrent_stats->rssi = priv->stats.signal_strength;
3774         //
3775         // If the previous packet does not match the criteria, neglect it
3776         //
3777         if (!pprevious_stats->bPacketMatchBSSID) {
3778                 if (!pprevious_stats->bToSelfBA)
3779                         return;
3780         }
3781
3782         if (!bcheck)
3783                 return;
3784
3785
3786         //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
3787
3788         //
3789         // Check RSSI
3790         //
3791         priv->stats.num_process_phyinfo++;
3792
3793         /* record the general signal strength to the sliding window. */
3794
3795
3796         // <2> Showed on UI for engineering
3797         // hardware does not provide rssi information for each rf path in CCK
3798         if (!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA)) {
3799                 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++) {
3800                         if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
3801                                 continue;
3802
3803                         //Fixed by Jacken 2008-03-20
3804                         if (priv->stats.rx_rssi_percentage[rfpath] == 0)
3805                                 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
3806                         if (pprevious_stats->RxMIMOSignalStrength[rfpath]  > priv->stats.rx_rssi_percentage[rfpath]) {
3807                                 priv->stats.rx_rssi_percentage[rfpath] =
3808                                         ((priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
3809                                          (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
3810                                 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath]  + 1;
3811                         } else {
3812                                 priv->stats.rx_rssi_percentage[rfpath] =
3813                                         ((priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
3814                                          (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
3815                         }
3816                         RT_TRACE(COMP_DBG, "priv->stats.rx_rssi_percentage[rfPath]  = %d \n", priv->stats.rx_rssi_percentage[rfpath]);
3817                 }
3818         }
3819
3820
3821         //
3822         // Check PWDB.
3823         //
3824         RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
3825                  pprevious_stats->bIsCCK ? "CCK" : "OFDM",
3826                  pprevious_stats->RxPWDBAll);
3827
3828         if (pprevious_stats->bPacketBeacon) {
3829                 /* record the beacon pwdb to the sliding window. */
3830                 if (slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX) {
3831                         slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
3832                         last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
3833                         priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
3834                 }
3835                 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
3836                 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
3837                 slide_beacon_adc_pwdb_index++;
3838                 if (slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
3839                         slide_beacon_adc_pwdb_index = 0;
3840                 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
3841                 if (pprevious_stats->RxPWDBAll >= 3)
3842                         pprevious_stats->RxPWDBAll -= 3;
3843         }
3844
3845         RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
3846                  pprevious_stats->bIsCCK ? "CCK" : "OFDM",
3847                  pprevious_stats->RxPWDBAll);
3848
3849
3850         if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3851                 if (priv->undecorated_smoothed_pwdb < 0)        /* initialize */
3852                         priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
3853                 if (pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb) {
3854                         priv->undecorated_smoothed_pwdb =
3855                                 (((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
3856                                  (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
3857                         priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
3858                 } else {
3859                         priv->undecorated_smoothed_pwdb =
3860                                 (((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
3861                                  (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
3862                 }
3863
3864         }
3865
3866         //
3867         // Check EVM
3868         //
3869         /* record the general EVM to the sliding window. */
3870         if (pprevious_stats->SignalQuality) {
3871                 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3872                         if (slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX) {
3873                                 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
3874                                 last_evm = priv->stats.slide_evm[slide_evm_index];
3875                                 priv->stats.slide_evm_total -= last_evm;
3876                         }
3877
3878                         priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
3879
3880                         priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
3881                         if (slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
3882                                 slide_evm_index = 0;
3883
3884                         // <1> Showed on UI for user, in percentage.
3885                         tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
3886                         priv->stats.signal_quality = tmp_val;
3887                         //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
3888                         priv->stats.last_signal_strength_inpercent = tmp_val;
3889                 }
3890
3891                 // <2> Showed on UI for engineering
3892                 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3893                         for (nspatial_stream = 0; nspatial_stream < 2; nspatial_stream++) { /* 2 spatial stream */
3894                                 if (pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1) {
3895                                         if (priv->stats.rx_evm_percentage[nspatial_stream] == 0) /* initialize */
3896                                                 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
3897                                         priv->stats.rx_evm_percentage[nspatial_stream] =
3898                                                 ((priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
3899                                                  (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
3900                                 }
3901                         }
3902                 }
3903         }
3904
3905
3906 }
3907
3908 /*-----------------------------------------------------------------------------
3909  * Function:    rtl819x_query_rxpwrpercentage()
3910  *
3911  * Overview:
3912  *
3913  * Input:               char            antpower
3914  *
3915  * Output:              NONE
3916  *
3917  * Return:              0-100 percentage
3918  *
3919  * Revised History:
3920  *      When            Who             Remark
3921  *      05/26/2008      amy             Create Version 0 porting from windows code.
3922  *
3923  *---------------------------------------------------------------------------*/
3924 static u8 rtl819x_query_rxpwrpercentage(char antpower)
3925 {
3926         if ((antpower <= -100) || (antpower >= 20))
3927                 return  0;
3928         else if (antpower >= 0)
3929                 return  100;
3930         else
3931                 return  100 + antpower;
3932
3933 }       /* QueryRxPwrPercentage */
3934
3935 static u8 rtl819x_evm_dbtopercentage(char value)
3936 {
3937         char ret_val;
3938
3939         ret_val = value;
3940
3941         if (ret_val >= 0)
3942                 ret_val = 0;
3943         if (ret_val <= -33)
3944                 ret_val = -33;
3945         ret_val = 0 - ret_val;
3946         ret_val *= 3;
3947         if (ret_val == 99)
3948                 ret_val = 100;
3949         return ret_val;
3950 }
3951 //
3952 //      Description:
3953 //      We want good-looking for signal strength/quality
3954 //      2007/7/19 01:09, by cosa.
3955 //
3956 static long rtl819x_signal_scale_mapping(long currsig)
3957 {
3958         long retsig;
3959
3960         // Step 1. Scale mapping.
3961         if (currsig >= 61 && currsig <= 100)
3962                 retsig = 90 + ((currsig - 60) / 4);
3963         else if (currsig >= 41 && currsig <= 60)
3964                 retsig = 78 + ((currsig - 40) / 2);
3965         else if (currsig >= 31 && currsig <= 40)
3966                 retsig = 66 + (currsig - 30);
3967         else if (currsig >= 21 && currsig <= 30)
3968                 retsig = 54 + (currsig - 20);
3969         else if (currsig >= 5 && currsig <= 20)
3970                 retsig = 42 + (((currsig - 5) * 2) / 3);
3971         else if (currsig == 4)
3972                 retsig = 36;
3973         else if (currsig == 3)
3974                 retsig = 27;
3975         else if (currsig == 2)
3976                 retsig = 18;
3977         else if (currsig == 1)
3978                 retsig = 9;
3979         else
3980                 retsig = currsig;
3981
3982         return retsig;
3983 }
3984
3985 static inline bool rx_hal_is_cck_rate(struct rx_drvinfo_819x_usb *pdrvinfo)
3986 {
3987         if (pdrvinfo->RxHT)
3988                 return false;
3989
3990         switch (pdrvinfo->RxRate) {
3991         case DESC90_RATE1M:
3992         case DESC90_RATE2M:
3993         case DESC90_RATE5_5M:
3994         case DESC90_RATE11M:
3995                 return true;
3996         default:
3997                 return false;
3998         }
3999 }
4000
4001 static void rtl8192_query_rxphystatus(struct r8192_priv *priv,
4002                                       struct ieee80211_rx_stats *pstats,
4003                                       rx_drvinfo_819x_usb  *pdrvinfo,
4004                                       struct ieee80211_rx_stats *precord_stats,
4005                                       bool bpacket_match_bssid,
4006                                       bool bpacket_toself,
4007                                       bool bPacketBeacon,
4008                                       bool bToSelfBA)
4009 {
4010         phy_sts_ofdm_819xusb_t *pofdm_buf;
4011         phy_sts_cck_819xusb_t   *pcck_buf;
4012         phy_ofdm_rx_status_rxsc_sgien_exintfflag *prxsc;
4013         u8                              *prxpkt;
4014         u8                              i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
4015         char                            rx_pwr[4], rx_pwr_all = 0;
4016         char                            rx_snrX, rx_evmX;
4017         u8                              evm, pwdb_all;
4018         u32                             RSSI, total_rssi = 0;
4019         u8                              is_cck_rate = 0;
4020         u8                              rf_rx_num = 0;
4021         u8                              sq;
4022
4023
4024         priv->stats.numqry_phystatus++;
4025
4026         is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4027
4028         // Record it for next packet processing
4029         memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4030         pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4031         pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4032         pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;
4033         pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4034         pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4035
4036         prxpkt = (u8 *)pdrvinfo;
4037
4038         /* Move pointer to the 16th bytes. Phy status start address. */
4039         prxpkt += sizeof(rx_drvinfo_819x_usb);
4040
4041         /* Initial the cck and ofdm buffer pointer */
4042         pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4043         pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4044
4045         pstats->RxMIMOSignalQuality[0] = -1;
4046         pstats->RxMIMOSignalQuality[1] = -1;
4047         precord_stats->RxMIMOSignalQuality[0] = -1;
4048         precord_stats->RxMIMOSignalQuality[1] = -1;
4049
4050         if (is_cck_rate) {
4051                 //
4052                 // (1)Hardware does not provide RSSI for CCK
4053                 //
4054
4055                 //
4056                 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4057                 //
4058                 u8 report;
4059
4060                 priv->stats.numqry_phystatusCCK++;
4061
4062                 if (!priv->bCckHighPower) {
4063                         report = pcck_buf->cck_agc_rpt & 0xc0;
4064                         report = report>>6;
4065                         switch (report) {
4066                                 //Fixed by Jacken from Bryant 2008-03-20
4067                                 //Original value is -38 , -26 , -14 , -2
4068                                 //Fixed value is -35 , -23 , -11 , 6
4069                         case 0x3:
4070                                 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4071                                 break;
4072                         case 0x2:
4073                                 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4074                                 break;
4075                         case 0x1:
4076                                 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4077                                 break;
4078                         case 0x0:
4079                                 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4080                                 break;
4081                         }
4082                 } else {
4083                         report = pcck_buf->cck_agc_rpt & 0x60;
4084                         report = report>>5;
4085                         switch (report) {
4086                         case 0x3:
4087                                 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4088                                 break;
4089                         case 0x2:
4090                                 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4091                                 break;
4092                         case 0x1:
4093                                 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4094                                 break;
4095                         case 0x0:
4096                                 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4097                                 break;
4098                         }
4099                 }
4100
4101                 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4102                 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4103                 pstats->RecvSignalPower = pwdb_all;
4104
4105                 //
4106                 // (3) Get Signal Quality (EVM)
4107                 //
4108
4109                 if (pstats->RxPWDBAll > 40) {
4110                         sq = 100;
4111                 } else {
4112                         sq = pcck_buf->sq_rpt;
4113
4114                         if (pcck_buf->sq_rpt > 64)
4115                                 sq = 0;
4116                         else if (pcck_buf->sq_rpt < 20)
4117                                 sq = 100;
4118                         else
4119                                 sq = ((64-sq) * 100) / 44;
4120                 }
4121                 pstats->SignalQuality = precord_stats->SignalQuality = sq;
4122                 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
4123                 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
4124
4125         } else {
4126                 priv->stats.numqry_phystatusHT++;
4127                 //
4128                 // (1)Get RSSI for HT rate
4129                 //
4130                 for (i = RF90_PATH_A; i < priv->NumTotalRFPath; i++) {
4131                         // 2008/01/30 MH we will judge RF RX path now.
4132                         if (priv->brfpath_rxenable[i])
4133                                 rf_rx_num++;
4134                         else
4135                                 continue;
4136
4137                         if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
4138                                 continue;
4139
4140                         //Fixed by Jacken from Bryant 2008-03-20
4141                         //Original value is 106
4142                         rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
4143
4144                         //Get Rx snr value in DB
4145                         tmp_rxsnr =     pofdm_buf->rxsnr_X[i];
4146                         rx_snrX = (char)(tmp_rxsnr);
4147                         rx_snrX /= 2;
4148                         priv->stats.rxSNRdB[i] = (long)rx_snrX;
4149
4150                         /* Translate DBM to percentage. */
4151                         RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
4152                         total_rssi += RSSI;
4153
4154                         /* Record Signal Strength for next packet */
4155                         pstats->RxMIMOSignalStrength[i] = (u8) RSSI;
4156                         precord_stats->RxMIMOSignalStrength[i] = (u8) RSSI;
4157                 }
4158
4159
4160                 //
4161                 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4162                 //
4163                 //Fixed by Jacken from Bryant 2008-03-20
4164                 //Original value is 106
4165                 rx_pwr_all = (((pofdm_buf->pwdb_all) >> 1)& 0x7f) -106;
4166                 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4167
4168                 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4169                 pstats->RxPower = precord_stats->RxPower =  rx_pwr_all;
4170
4171                 //
4172                 // (3)EVM of HT rate
4173                 //
4174                 if (pdrvinfo->RxHT && pdrvinfo->RxRate >= DESC90_RATEMCS8 &&
4175                     pdrvinfo->RxRate <= DESC90_RATEMCS15)
4176                         max_spatial_stream = 2; //both spatial stream make sense
4177                 else
4178                         max_spatial_stream = 1; //only spatial stream 1 makes sense
4179
4180                 for (i = 0; i < max_spatial_stream; i++) {
4181                         tmp_rxevm =     pofdm_buf->rxevm_X[i];
4182                         rx_evmX = (char)(tmp_rxevm);
4183
4184                         // Do not use shift operation like "rx_evmX >>= 1" because the compiler of free build environment
4185                         // will set the most significant bit to "zero" when doing shifting operation which may change a negative
4186                         // value to positive one, then the dbm value (which is supposed to be negative)  is not correct anymore.
4187                         rx_evmX /= 2;   //dbm
4188
4189                         evm = rtl819x_evm_dbtopercentage(rx_evmX);
4190                         if (i == 0) /* Fill value in RFD, Get the first spatial stream only */
4191                                 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
4192                         pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
4193                 }
4194
4195
4196                 /* record rx statistics for debug */
4197                 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
4198                 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
4199                 if (pdrvinfo->BW)       /* 40M channel */
4200                         priv->stats.received_bwtype[1+prxsc->rxsc]++;
4201                 else                            //20M channel
4202                         priv->stats.received_bwtype[0]++;
4203         }
4204
4205         //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
4206         //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
4207         if (is_cck_rate) {
4208                 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));
4209         } else {
4210                 // We can judge RX path number now.
4211                 if (rf_rx_num != 0)
4212                         pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi /= rf_rx_num)));
4213         }
4214 }       /* QueryRxPhyStatus8190Pci */
4215
4216 static void rtl8192_record_rxdesc_forlateruse(struct ieee80211_rx_stats *psrc_stats,
4217                                               struct ieee80211_rx_stats *ptarget_stats)
4218 {
4219         ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
4220         ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
4221         ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
4222 }
4223
4224
4225 static void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
4226                                           struct ieee80211_rx_stats *pstats,
4227                                           rx_drvinfo_819x_usb  *pdrvinfo)
4228 {
4229         // TODO: We must only check packet for current MAC address. Not finish
4230         rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4231         struct net_device *dev = info->dev;
4232         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4233         bool bpacket_match_bssid, bpacket_toself;
4234         bool bPacketBeacon = FALSE, bToSelfBA = FALSE;
4235         static struct ieee80211_rx_stats  previous_stats;
4236         struct ieee80211_hdr_3addr *hdr;//by amy
4237         u16 fc, type;
4238
4239         // Get Signal Quality for only RX data queue (but not command queue)
4240
4241         u8 *tmp_buf;
4242         u8  *praddr;
4243
4244         /* Get MAC frame start address. */
4245         tmp_buf = (u8 *)skb->data;
4246
4247         hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
4248         fc = le16_to_cpu(hdr->frame_ctl);
4249         type = WLAN_FC_GET_TYPE(fc);
4250         praddr = hdr->addr1;
4251
4252         /* Check if the received packet is acceptable. */
4253         bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
4254                                (eqMacAddr(priv->ieee80211->current_network.bssid,  (fc & IEEE80211_FCTL_TODS) ? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 : hdr->addr3))
4255                                && (!pstats->bHwError) && (!pstats->bCRC) && (!pstats->bICV));
4256         bpacket_toself =  bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
4257
4258         if (WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BEACON)
4259                 bPacketBeacon = true;
4260         if (WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK) {
4261                 if ((eqMacAddr(praddr, dev->dev_addr)))
4262                         bToSelfBA = true;
4263         }
4264
4265
4266
4267         if (bpacket_match_bssid)
4268                 priv->stats.numpacket_matchbssid++;
4269         if (bpacket_toself)
4270                 priv->stats.numpacket_toself++;
4271         //
4272         // Process PHY information for previous packet (RSSI/PWDB/EVM)
4273         //
4274         // Because phy information is contained in the last packet of AMPDU only, so driver
4275         // should process phy information of previous packet
4276         rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
4277         rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid, bpacket_toself, bPacketBeacon, bToSelfBA);
4278         rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
4279
4280 }
4281
4282 /**
4283 * Function:     UpdateReceivedRateHistogramStatistics
4284 * Overview:     Record the received data rate
4285 *
4286 * Input:
4287 *       struct net_device *dev
4288 *       struct ieee80211_rx_stats *stats
4289 *
4290 * Output:
4291 *
4292 *                       (priv->stats.ReceivedRateHistogram[] is updated)
4293 * Return:
4294 *               None
4295 */
4296 static void
4297 UpdateReceivedRateHistogramStatistics8190(struct net_device *dev,
4298                                           struct ieee80211_rx_stats *stats)
4299 {
4300         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4301         u32 rcvType = 1;   //0: Total, 1:OK, 2:CRC, 3:ICV
4302         u32 rateIndex;
4303         u32 preamble_guardinterval;  //1: short preamble/GI, 0: long preamble/GI
4304
4305
4306         if (stats->bCRC)
4307                 rcvType = 2;
4308         else if (stats->bICV)
4309                 rcvType = 3;
4310
4311         if (stats->bShortPreamble)
4312                 preamble_guardinterval = 1;// short
4313         else
4314                 preamble_guardinterval = 0;// long
4315
4316         switch (stats->rate) {
4317         /* CCK rate */
4318         case MGN_1M:
4319                 rateIndex = 0;
4320                 break;
4321         case MGN_2M:
4322                 rateIndex = 1;
4323                 break;
4324         case MGN_5_5M:
4325                 rateIndex = 2;
4326                 break;
4327         case MGN_11M:
4328                 rateIndex = 3;
4329                 break;
4330         /* Legacy OFDM rate */
4331         case MGN_6M:
4332                 rateIndex = 4;
4333                 break;
4334         case MGN_9M:
4335                 rateIndex = 5;
4336                 break;
4337         case MGN_12M:
4338                 rateIndex = 6;
4339                 break;
4340         case MGN_18M:
4341                 rateIndex = 7;
4342                 break;
4343         case MGN_24M:
4344                 rateIndex = 8;
4345                 break;
4346         case MGN_36M:
4347                 rateIndex = 9;
4348                 break;
4349         case MGN_48M:
4350                 rateIndex = 10;
4351                 break;
4352         case MGN_54M:
4353                 rateIndex = 11;
4354                 break;
4355         /* 11n High throughput rate */
4356         case MGN_MCS0:
4357                 rateIndex = 12;
4358                 break;
4359         case MGN_MCS1:
4360                 rateIndex = 13;
4361                 break;
4362         case MGN_MCS2:
4363                 rateIndex = 14;
4364                 break;
4365         case MGN_MCS3:
4366                 rateIndex = 15;
4367                 break;
4368         case MGN_MCS4:
4369                 rateIndex = 16;
4370                 break;
4371         case MGN_MCS5:
4372                 rateIndex = 17;
4373                 break;
4374         case MGN_MCS6:
4375                 rateIndex = 18;
4376                 break;
4377         case MGN_MCS7:
4378                 rateIndex = 19;
4379                 break;
4380         case MGN_MCS8:
4381                 rateIndex = 20;
4382                 break;
4383         case MGN_MCS9:
4384                 rateIndex = 21;
4385                 break;
4386         case MGN_MCS10:
4387                 rateIndex = 22;
4388                 break;
4389         case MGN_MCS11:
4390                 rateIndex = 23;
4391                 break;
4392         case MGN_MCS12:
4393                 rateIndex = 24;
4394                 break;
4395         case MGN_MCS13:
4396                 rateIndex = 25;
4397                 break;
4398         case MGN_MCS14:
4399                 rateIndex = 26;
4400                 break;
4401         case MGN_MCS15:
4402                 rateIndex = 27;
4403                 break;
4404         default:
4405                 rateIndex = 28;
4406                 break;
4407         }
4408         priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
4409         priv->stats.received_rate_histogram[0][rateIndex]++; //total
4410         priv->stats.received_rate_histogram[rcvType][rateIndex]++;
4411 }
4412
4413
4414 static void query_rxdesc_status(struct sk_buff *skb,
4415                                 struct ieee80211_rx_stats *stats,
4416                                 bool bIsRxAggrSubframe)
4417 {
4418         rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4419         struct net_device *dev = info->dev;
4420         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4421         rx_drvinfo_819x_usb  *driver_info = NULL;
4422
4423         //
4424         //Get Rx Descriptor Information
4425         //
4426         rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
4427
4428         stats->Length = desc->Length;
4429         stats->RxDrvInfoSize = desc->RxDrvInfoSize;
4430         stats->RxBufShift = 0;
4431         stats->bICV = desc->ICV;
4432         stats->bCRC = desc->CRC32;
4433         stats->bHwError = stats->bCRC|stats->bICV;
4434         /* RTL8190 set this bit to indicate that Hw does not decrypt packet */
4435         stats->Decrypted = !desc->SWDec;
4436
4437         if ((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
4438                 stats->bHwError = false;
4439         else
4440                 stats->bHwError = stats->bCRC|stats->bICV;
4441
4442         if (stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
4443                 stats->bHwError |= 1;
4444         //
4445         //Get Driver Info
4446         //
4447         // TODO: Need to verify it on FGPA platform
4448         //Driver info are written to the RxBuffer following rx desc
4449         if (stats->RxDrvInfoSize != 0) {
4450                 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) +
4451                                                       stats->RxBufShift);
4452                 /* unit: 0.5M */
4453                 /* TODO */
4454                 if (!stats->bHwError) {
4455                         u8      ret_rate;
4456                         ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
4457                         if (ret_rate == 0xff) {
4458                                 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
4459                                 // Special Error Handling here, 2008.05.16, by Emily
4460
4461                                 stats->bHwError = 1;
4462                                 stats->rate = MGN_1M;   //Set 1M rate by default
4463                         } else {
4464                                 stats->rate = ret_rate;
4465                         }
4466                 } else {
4467                         stats->rate = 0x02;
4468                 }
4469
4470                 stats->bShortPreamble = driver_info->SPLCP;
4471
4472
4473                 UpdateReceivedRateHistogramStatistics8190(dev, stats);
4474
4475                 stats->bIsAMPDU = (driver_info->PartAggr == 1);
4476                 stats->bFirstMPDU = (driver_info->PartAggr == 1) && (driver_info->FirstAGGR == 1);
4477                 stats->TimeStampLow = driver_info->TSFL;
4478                 // xiong mask it, 070514
4479
4480                 UpdateRxPktTimeStamp8190(dev, stats);
4481
4482                 //
4483                 // Rx A-MPDU
4484                 //
4485                 if (driver_info->FirstAGGR == 1 || driver_info->PartAggr == 1)
4486                         RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
4487                                  driver_info->FirstAGGR, driver_info->PartAggr);
4488
4489         }
4490
4491         skb_pull(skb, sizeof(rx_desc_819x_usb));
4492         //
4493         // Get Total offset of MPDU Frame Body
4494         //
4495         if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
4496                 stats->bShift = 1;
4497                 skb_pull(skb, stats->RxBufShift + stats->RxDrvInfoSize);
4498         }
4499
4500         /* for debug 2008.5.29 */
4501
4502         //added by vivi, for MP, 20080108
4503         stats->RxIs40MHzPacket = driver_info->BW;
4504         if (stats->RxDrvInfoSize != 0)
4505                 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
4506
4507 }
4508
4509 static void rtl8192_rx_nomal(struct sk_buff *skb)
4510 {
4511         rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4512         struct net_device *dev = info->dev;
4513         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4514         struct ieee80211_rx_stats stats = {
4515                 .signal = 0,
4516                 .noise = -98,
4517                 .rate = 0,
4518                 .freq = IEEE80211_24GHZ_BAND,
4519         };
4520         u32 rx_pkt_len = 0;
4521         struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
4522         bool unicast_packet = false;
4523
4524         /* 20 is for ps-poll */
4525         if ((skb->len >= (20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
4526                 /* first packet should not contain Rx aggregation header */
4527                 query_rxdesc_status(skb, &stats, false);
4528                 /* TODO */
4529                 /* hardware related info */
4530                 /* Process the MPDU received */
4531                 skb_trim(skb, skb->len - 4/*sCrcLng*/);
4532
4533                 rx_pkt_len = skb->len;
4534                 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
4535                 unicast_packet = false;
4536                 if (is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
4537                         //TODO
4538                 } else if (is_multicast_ether_addr(ieee80211_hdr->addr1)) {
4539                         //TODO
4540                 } else {
4541                         /* unicast packet */
4542                         unicast_packet = true;
4543                 }
4544
4545                 if (!ieee80211_rx(priv->ieee80211, skb, &stats)) {
4546                         dev_kfree_skb_any(skb);
4547                 } else {
4548                         priv->stats.rxoktotal++;
4549                         if (unicast_packet)
4550                                 priv->stats.rxbytesunicast += rx_pkt_len;
4551                 }
4552         } else {
4553                 priv->stats.rxurberr++;
4554                 netdev_dbg(dev, "actual_length: %d\n", skb->len);
4555                 dev_kfree_skb_any(skb);
4556         }
4557
4558 }
4559
4560 static void rtl819xusb_process_received_packet(struct net_device *dev,
4561                                                struct ieee80211_rx_stats *pstats)
4562 {
4563         u8      *frame;
4564         u16     frame_len = 0;
4565         struct r8192_priv *priv = ieee80211_priv(dev);
4566
4567         // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
4568         //porting by amy 080508
4569         pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
4570         frame = pstats->virtual_address;
4571         frame_len = pstats->packetlength;
4572 #ifdef TODO     // by amy about HCT
4573         if (!Adapter->bInHctTest)
4574                 CountRxErrStatistics(Adapter, pRfd);
4575 #endif
4576 #ifdef ENABLE_PS  //by amy for adding ps function in future
4577         RT_RF_POWER_STATE rtState;
4578         // When RF is off, we should not count the packet for hw/sw synchronize
4579         // reason, ie. there may be a duration while sw switch is changed and hw
4580         // switch is being changed. 2006.12.04, by shien chang.
4581         Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8 *)(&rtState));
4582         if (rtState == eRfOff)
4583                 return;
4584 #endif
4585         priv->stats.rxframgment++;
4586
4587 #ifdef TODO
4588         RmMonitorSignalStrength(Adapter, pRfd);
4589 #endif
4590         /* 2007/01/16 MH Add RX command packet handle here. */
4591         /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
4592         if (rtl819xusb_rx_command_packet(dev, pstats))
4593                 return;
4594
4595 #ifdef SW_CRC_CHECK
4596         SwCrcCheck();
4597 #endif
4598
4599
4600 }
4601
4602 static void query_rx_cmdpkt_desc_status(struct sk_buff *skb,
4603                                         struct ieee80211_rx_stats *stats)
4604 {
4605         rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
4606
4607         //
4608         //Get Rx Descriptor Information
4609         //
4610         stats->virtual_address = (u8 *)skb->data;
4611         stats->Length = desc->Length;
4612         stats->RxDrvInfoSize = 0;
4613         stats->RxBufShift = 0;
4614         stats->packetlength = stats->Length-scrclng;
4615         stats->fraglength = stats->packetlength;
4616         stats->fragoffset = 0;
4617         stats->ntotalfrag = 1;
4618 }
4619
4620
4621 static void rtl8192_rx_cmd(struct sk_buff *skb)
4622 {
4623         struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4624         struct net_device *dev = info->dev;
4625         /* TODO */
4626         struct ieee80211_rx_stats stats = {
4627                 .signal = 0,
4628                 .noise = -98,
4629                 .rate = 0,
4630                 .freq = IEEE80211_24GHZ_BAND,
4631         };
4632
4633         if ((skb->len >= (20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
4634
4635                 query_rx_cmdpkt_desc_status(skb, &stats);
4636                 // this is to be done by amy 080508     prfd->queue_id = 1;
4637
4638
4639                 //
4640                 //  Process the command packet received.
4641                 //
4642
4643                 rtl819xusb_process_received_packet(dev, &stats);
4644
4645                 dev_kfree_skb_any(skb);
4646         }
4647 }
4648
4649 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
4650 {
4651         struct sk_buff *skb;
4652         struct rtl8192_rx_info *info;
4653
4654         while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
4655                 info = (struct rtl8192_rx_info *)skb->cb;
4656                 switch (info->out_pipe) {
4657                 /* Nomal packet pipe */
4658                 case 3:
4659                         priv->IrpPendingCount--;
4660                         rtl8192_rx_nomal(skb);
4661                         break;
4662
4663                 /* Command packet pipe */
4664                 case 9:
4665                         RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",
4666                                  info->out_pipe);
4667
4668                         rtl8192_rx_cmd(skb);
4669                         break;
4670
4671                 default: /* should never get here! */
4672                         RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",
4673                                  info->out_pipe);
4674                         dev_kfree_skb(skb);
4675                         break;
4676
4677                 }
4678         }
4679 }
4680
4681 static const struct net_device_ops rtl8192_netdev_ops = {
4682         .ndo_open               = rtl8192_open,
4683         .ndo_stop               = rtl8192_close,
4684         .ndo_get_stats          = rtl8192_stats,
4685         .ndo_tx_timeout         = tx_timeout,
4686         .ndo_do_ioctl           = rtl8192_ioctl,
4687         .ndo_set_rx_mode        = r8192_set_multicast,
4688         .ndo_set_mac_address    = r8192_set_mac_adr,
4689         .ndo_validate_addr      = eth_validate_addr,
4690         .ndo_change_mtu         = eth_change_mtu,
4691         .ndo_start_xmit         = ieee80211_xmit,
4692 };
4693
4694
4695 /****************************************************************************
4696      ---------------------------- USB_STUFF---------------------------
4697 *****************************************************************************/
4698
4699 static int rtl8192_usb_probe(struct usb_interface *intf,
4700                              const struct usb_device_id *id)
4701 {
4702         struct net_device *dev = NULL;
4703         struct r8192_priv *priv = NULL;
4704         struct usb_device *udev = interface_to_usbdev(intf);
4705         int ret;
4706         RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
4707
4708         dev = alloc_ieee80211(sizeof(struct r8192_priv));
4709         if (dev == NULL)
4710                 return -ENOMEM;
4711
4712         usb_set_intfdata(intf, dev);
4713         SET_NETDEV_DEV(dev, &intf->dev);
4714         priv = ieee80211_priv(dev);
4715         priv->ieee80211 = netdev_priv(dev);
4716         priv->udev = udev;
4717
4718         dev->netdev_ops = &rtl8192_netdev_ops;
4719
4720         dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
4721
4722         dev->type = ARPHRD_ETHER;
4723
4724         dev->watchdog_timeo = HZ*3;     //modified by john, 0805
4725
4726         if (dev_alloc_name(dev, ifname) < 0) {
4727                 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
4728                 ifname = "wlan%d";
4729                 dev_alloc_name(dev, ifname);
4730         }
4731
4732         RT_TRACE(COMP_INIT, "Driver probe completed1\n");
4733         if (rtl8192_init(dev) != 0) {
4734                 RT_TRACE(COMP_ERR, "Initialization failed");
4735                 ret = -ENODEV;
4736                 goto fail;
4737         }
4738         netif_carrier_off(dev);
4739         netif_stop_queue(dev);
4740
4741         ret = register_netdev(dev);
4742         if (ret)
4743                 goto fail2;
4744
4745         RT_TRACE(COMP_INIT, "dev name=======> %s\n", dev->name);
4746         rtl8192_proc_init_one(dev);
4747
4748
4749         RT_TRACE(COMP_INIT, "Driver probe completed\n");
4750         return 0;
4751
4752 fail2:
4753         rtl8192_down(dev);
4754         kfree(priv->pFirmware);
4755         priv->pFirmware = NULL;
4756         rtl8192_usb_deleteendpoints(dev);
4757         destroy_workqueue(priv->priv_wq);
4758         mdelay(10);
4759 fail:
4760         free_ieee80211(dev);
4761
4762         RT_TRACE(COMP_ERR, "wlan driver load failed\n");
4763         return ret;
4764 }
4765
4766 //detach all the work and timer structure declared or inititialize in r8192U_init function.
4767 void rtl8192_cancel_deferred_work(struct r8192_priv *priv)
4768 {
4769
4770         cancel_work_sync(&priv->reset_wq);
4771         cancel_delayed_work(&priv->watch_dog_wq);
4772         cancel_delayed_work(&priv->update_beacon_wq);
4773         cancel_work_sync(&priv->qos_activate);
4774 }
4775
4776
4777 static void rtl8192_usb_disconnect(struct usb_interface *intf)
4778 {
4779         struct net_device *dev = usb_get_intfdata(intf);
4780
4781         struct r8192_priv *priv = ieee80211_priv(dev);
4782         if (dev) {
4783
4784                 unregister_netdev(dev);
4785
4786                 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
4787                 rtl8192_proc_remove_one(dev);
4788
4789                 rtl8192_down(dev);
4790                 kfree(priv->pFirmware);
4791                 priv->pFirmware = NULL;
4792                 rtl8192_usb_deleteendpoints(dev);
4793                 destroy_workqueue(priv->priv_wq);
4794                 mdelay(10);
4795
4796         }
4797         free_ieee80211(dev);
4798         RT_TRACE(COMP_DOWN, "wlan driver removed\n");
4799 }
4800
4801 static int __init rtl8192_usb_module_init(void)
4802 {
4803         int ret;
4804
4805 #ifdef CONFIG_IEEE80211_DEBUG
4806         ret = ieee80211_debug_init();
4807         if (ret) {
4808                 pr_err("ieee80211_debug_init() failed %d\n", ret);
4809                 return ret;
4810         }
4811 #endif
4812         ret = ieee80211_crypto_init();
4813         if (ret) {
4814                 pr_err("ieee80211_crypto_init() failed %d\n", ret);
4815                 return ret;
4816         }
4817
4818         ret = ieee80211_crypto_tkip_init();
4819         if (ret) {
4820                 pr_err("ieee80211_crypto_tkip_init() failed %d\n", ret);
4821                 return ret;
4822         }
4823
4824         ret = ieee80211_crypto_ccmp_init();
4825         if (ret) {
4826                 pr_err("ieee80211_crypto_ccmp_init() failed %d\n", ret);
4827                 return ret;
4828         }
4829
4830         ret = ieee80211_crypto_wep_init();
4831         if (ret) {
4832                 pr_err("ieee80211_crypto_wep_init() failed %d\n", ret);
4833                 return ret;
4834         }
4835
4836         pr_info("\nLinux kernel driver for RTL8192 based WLAN cards\n");
4837         pr_info("Copyright (c) 2007-2008, Realsil Wlan\n");
4838         RT_TRACE(COMP_INIT, "Initializing module");
4839         RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
4840         rtl8192_proc_module_init();
4841         return usb_register(&rtl8192_usb_driver);
4842 }
4843
4844
4845 static void __exit rtl8192_usb_module_exit(void)
4846 {
4847         usb_deregister(&rtl8192_usb_driver);
4848
4849         RT_TRACE(COMP_DOWN, "Exiting");
4850 }
4851
4852
4853 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
4854 {
4855         unsigned long flags;
4856         short enough_desc;
4857         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4858
4859         spin_lock_irqsave(&priv->tx_lock, flags);
4860         enough_desc = check_nic_enough_desc(dev, pri);
4861         spin_unlock_irqrestore(&priv->tx_lock, flags);
4862
4863         if (enough_desc)
4864                 ieee80211_wake_queue(priv->ieee80211);
4865 }
4866
4867 void EnableHWSecurityConfig8192(struct net_device *dev)
4868 {
4869         u8 SECR_value = 0x0;
4870         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4871         struct ieee80211_device *ieee = priv->ieee80211;
4872         SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
4873         if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2)) {
4874                 SECR_value |= SCR_RxUseDK;
4875                 SECR_value |= SCR_TxUseDK;
4876         } else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP))) {
4877                 SECR_value |= SCR_RxUseDK;
4878                 SECR_value |= SCR_TxUseDK;
4879         }
4880         //add HWSec active enable here.
4881         //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
4882
4883         ieee->hwsec_active = 1;
4884
4885         if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep) { /* add hwsec_support flag to totol control hw_sec on/off */
4886                 ieee->hwsec_active = 0;
4887                 SECR_value &= ~SCR_RxDecEnable;
4888         }
4889         RT_TRACE(COMP_SEC, "%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __func__,
4890                  ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
4891         write_nic_byte(dev, SECR,  SECR_value);
4892 }
4893
4894
4895 void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType,
4896             u8 *MacAddr, u8 DefaultKey, u32 *KeyContent)
4897 {
4898         u32 TargetCommand = 0;
4899         u32 TargetContent = 0;
4900         u16 usConfig = 0;
4901         u8 i;
4902         if (EntryNo >= TOTAL_CAM_ENTRY)
4903                 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
4904
4905         RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev, EntryNo, KeyIndex, KeyType, MacAddr);
4906
4907         if (DefaultKey)
4908                 usConfig |= BIT15 | (KeyType<<2);
4909         else
4910                 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
4911
4912
4913         for (i = 0; i < CAM_CONTENT_COUNT; i++) {
4914                 TargetCommand  = i+CAM_CONTENT_COUNT*EntryNo;
4915                 TargetCommand |= BIT31|BIT16;
4916
4917                 if (i == 0) { /* MAC|Config */
4918                         TargetContent = (u32)(*(MacAddr+0)) << 16|
4919                                         (u32)(*(MacAddr+1)) << 24|
4920                                         (u32)usConfig;
4921
4922                         write_nic_dword(dev, WCAMI, TargetContent);
4923                         write_nic_dword(dev, RWCAM, TargetCommand);
4924                 } else if (i == 1) { /* MAC */
4925                         TargetContent = (u32)(*(MacAddr+2))      |
4926                                         (u32)(*(MacAddr+3)) <<  8|
4927                                         (u32)(*(MacAddr+4)) << 16|
4928                                         (u32)(*(MacAddr+5)) << 24;
4929                         write_nic_dword(dev, WCAMI, TargetContent);
4930                         write_nic_dword(dev, RWCAM, TargetCommand);
4931                 } else {
4932                         //Key Material
4933                         if (KeyContent != NULL) {
4934                                 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)));
4935                                 write_nic_dword(dev, RWCAM, TargetCommand);
4936                         }
4937                 }
4938         }
4939
4940 }
4941
4942 /***************************************************************************
4943      ------------------- module init / exit stubs ----------------
4944 ****************************************************************************/
4945 module_init(rtl8192_usb_module_init);
4946 module_exit(rtl8192_usb_module_exit);