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