drivers/staging/rtl8192e/r8192E_core.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  * Linux device driver for RTL8190P / RTL8192E
   4  *
   5  * Based on the r8180 driver, which is:
   6  * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of version 2 of the GNU General Public License as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  19  *
  20  * The full GNU General Public License is included in this distribution in the
  21  * file called LICENSE.
  22  *
  23  * Contact Information:
  24  * Jerry chuang <wlanfae@realtek.com>
  25  */
  26
  27
  28 #undef RX_DONT_PASS_UL
  29 #undef DEBUG_EPROM
  30 #undef DEBUG_RX_VERBOSE
  31 #undef DUMMY_RX
  32 #undef DEBUG_ZERO_RX
  33 #undef DEBUG_RX_SKB
  34 #undef DEBUG_TX_FRAG
  35 #undef DEBUG_RX_FRAG
  36 #undef DEBUG_TX_FILLDESC
  37 #undef DEBUG_TX
  38 #undef DEBUG_IRQ
  39 #undef DEBUG_RX
  40 #undef DEBUG_RXALLOC
  41 #undef DEBUG_REGISTERS
  42 #undef DEBUG_RING
  43 #undef DEBUG_IRQ_TASKLET
  44 #undef DEBUG_TX_ALLOC
  45 #undef DEBUG_TX_DESC
  46
  47 //#define CONFIG_RTL8192_IO_MAP
  48 #include <linux/vmalloc.h>
  49 #include <linux/slab.h>
  50 #include <asm/uaccess.h>
  51 #include "r8192E_hw.h"
  52 #include "r8192E.h"
  53 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
  54 #include "r8180_93cx6.h"   /* Card EEPROM */
  55 #include "r8192E_wx.h"
  56 #include "r819xE_phy.h" //added by WB 4.30.2008
  57 #include "r819xE_phyreg.h"
  58 #include "r819xE_cmdpkt.h"
  59 #include "r8192E_dm.h"
  60
  61 #ifdef CONFIG_PM
  62 #include "r8192_pm.h"
  63 #endif
  64
  65 #ifdef ENABLE_DOT11D
  66 #include "ieee80211/dot11d.h"
  67 #endif
  68
  69 //set here to open your trace code. //WB
  70 u32 rt_global_debug_component =
  71                 //              COMP_INIT       |
  72                         //      COMP_EPROM      |
  73                 //              COMP_PHY        |
  74                 //              COMP_RF         |
  75 //                              COMP_FIRMWARE   |
  76                         //      COMP_TRACE      |
  77                 //              COMP_DOWN       |
  78                 //              COMP_SWBW       |
  79                 //              COMP_SEC        |
  80 //                              COMP_QOS        |
  81 //                              COMP_RATE       |
  82                 //              COMP_RECV       |
  83                 //              COMP_SEND       |
  84                 //              COMP_POWER      |
  85                         //      COMP_EVENTS     |
  86                         //      COMP_RESET      |
  87                         //      COMP_CMDPKT     |
  88                         //      COMP_POWER_TRACKING     |
  89                         //      COMP_INTR       |
  90                                 COMP_ERR ; //always open err flags on
  91
  92 static const struct pci_device_id rtl8192_pci_id_tbl[] __devinitdata = {
  93 #ifdef RTL8190P
  94         /* Realtek */
  95         /* Dlink */
  96         { PCI_DEVICE(0x10ec, 0x8190) },
  97         /* Corega */
  98         { PCI_DEVICE(0x07aa, 0x0045) },
  99         { PCI_DEVICE(0x07aa, 0x0046) },
 100 #else
 101         /* Realtek */
 102         { PCI_DEVICE(0x10ec, 0x8192) },
 103
 104         /* Corega */
 105         { PCI_DEVICE(0x07aa, 0x0044) },
 106         { PCI_DEVICE(0x07aa, 0x0047) },
 107 #endif
 108         {}
 109 };
 110
 111 static char ifname[IFNAMSIZ] = "wlan%d";
 112 static int hwwep = 1; //default use hw. set 0 to use software security
 113 static int channels = 0x3fff;
 114
 115 MODULE_LICENSE("GPL");
 116 MODULE_VERSION("V 1.1");
 117 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
 118 //MODULE_AUTHOR("Andrea Merello <andreamrl@tiscali.it>");
 119 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
 120
 121
 122 module_param_string(ifname, ifname, sizeof(ifname), S_IRUGO|S_IWUSR);
 123 module_param(hwwep,int, S_IRUGO|S_IWUSR);
 124 module_param(channels,int, S_IRUGO|S_IWUSR);
 125
 126 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
 127 MODULE_PARM_DESC(hwwep," Try to use hardware WEP support. Still broken and not available on all cards");
 128 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
 129
 130 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
 131                          const struct pci_device_id *id);
 132 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev);
 133
 134 static struct pci_driver rtl8192_pci_driver = {
 135         .name           = RTL819xE_MODULE_NAME,           /* Driver name   */
 136         .id_table       = rtl8192_pci_id_tbl,             /* PCI_ID table  */
 137         .probe          = rtl8192_pci_probe,              /* probe fn      */
 138         .remove         = __devexit_p(rtl8192_pci_disconnect),    /* remove fn     */
 139 #ifdef CONFIG_PM
 140         .suspend        = rtl8192E_suspend,               /* PM suspend fn */
 141         .resume         = rtl8192E_resume,                 /* PM resume fn  */
 142 #else
 143         .suspend        = NULL,                           /* PM suspend fn */
 144         .resume         = NULL,                           /* PM resume fn  */
 145 #endif
 146 };
 147
 148 static void rtl8192_start_beacon(struct net_device *dev);
 149 static void rtl8192_stop_beacon(struct net_device *dev);
 150 static void rtl819x_watchdog_wqcallback(struct work_struct *work);
 151 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
 152 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv);
 153 static void rtl8192_prepare_beacon(struct r8192_priv *priv);
 154 static irqreturn_t rtl8192_interrupt(int irq, void *netdev);
 155 static void rtl8192_try_wake_queue(struct net_device *dev, int pri);
 156 static void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb);
 157 static void rtl8192_update_ratr_table(struct net_device* dev);
 158 static void rtl8192_restart(struct work_struct *work);
 159 static void watch_dog_timer_callback(unsigned long data);
 160 static int _rtl8192_up(struct net_device *dev);
 161 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
 162
 163 #ifdef ENABLE_DOT11D
 164
 165 typedef struct _CHANNEL_LIST
 166 {
 167         u8      Channel[32];
 168         u8      Len;
 169 }CHANNEL_LIST, *PCHANNEL_LIST;
 170
 171 static const CHANNEL_LIST ChannelPlan[] = {
 172         {{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
 173         {{1,2,3,4,5,6,7,8,9,10,11},11},                                                 //IC
 174         {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21},   //ETSI
 175         {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},    //Spain. Change to ETSI.
 176         {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},   //France. Change to ETSI.
 177         {{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
 178         {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
 179         {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},   //Israel.
 180         {{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
 181         {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22},    //MIC
 182         {{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
 183 };
 184
 185 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
 186 {
 187         int i, max_chan=-1, min_chan=-1;
 188         struct ieee80211_device* ieee = priv->ieee80211;
 189         switch (channel_plan)
 190         {
 191                 case COUNTRY_CODE_FCC:
 192                 case COUNTRY_CODE_IC:
 193                 case COUNTRY_CODE_ETSI:
 194                 case COUNTRY_CODE_SPAIN:
 195                 case COUNTRY_CODE_FRANCE:
 196                 case COUNTRY_CODE_MKK:
 197                 case COUNTRY_CODE_MKK1:
 198                 case COUNTRY_CODE_ISRAEL:
 199                 case COUNTRY_CODE_TELEC:
 200                 case COUNTRY_CODE_MIC:
 201                 {
 202                         Dot11d_Init(ieee);
 203                         ieee->bGlobalDomain = false;
 204                         //acturally 8225 & 8256 rf chip only support B,G,24N mode
 205                         if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
 206                         {
 207                                 min_chan = 1;
 208                                 max_chan = 14;
 209                         }
 210                         else
 211                         {
 212                                 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
 213                         }
 214                         if (ChannelPlan[channel_plan].Len != 0){
 215                                 // Clear old channel map
 216                                 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
 217                                 // Set new channel map
 218                                 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
 219                                 {
 220                                         if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
 221                                             break;
 222                                         GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
 223                                 }
 224                         }
 225                         break;
 226                 }
 227                 case COUNTRY_CODE_GLOBAL_DOMAIN:
 228                 {
 229                         GET_DOT11D_INFO(ieee)->bEnabled = 0; //this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain setting
 230                         Dot11d_Reset(ieee);
 231                         ieee->bGlobalDomain = true;
 232                         break;
 233                 }
 234                 default:
 235                         break;
 236         }
 237 }
 238 #endif
 239
 240 static inline bool rx_hal_is_cck_rate(prx_fwinfo_819x_pci pdrvinfo)
 241 {
 242         return (pdrvinfo->RxRate == DESC90_RATE1M ||
 243                 pdrvinfo->RxRate == DESC90_RATE2M ||
 244                 pdrvinfo->RxRate == DESC90_RATE5_5M ||
 245                 pdrvinfo->RxRate == DESC90_RATE11M) &&
 246                 !pdrvinfo->RxHT;
 247 }
 248
 249 void CamResetAllEntry(struct net_device *dev)
 250 {
 251         write_nic_dword(dev, RWCAM, BIT31|BIT30);
 252 }
 253
 254
 255 void write_cam(struct net_device *dev, u8 addr, u32 data)
 256 {
 257         write_nic_dword(dev, WCAMI, data);
 258         write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
 259 }
 260 u32 read_cam(struct net_device *dev, u8 addr)
 261 {
 262         write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
 263         return read_nic_dword(dev, 0xa8);
 264 }
 265
 266 #ifdef CONFIG_RTL8180_IO_MAP
 267
 268 u8 read_nic_byte(struct net_device *dev, int x)
 269 {
 270         return 0xff&inb(dev->base_addr +x);
 271 }
 272
 273 u32 read_nic_dword(struct net_device *dev, int x)
 274 {
 275         return inl(dev->base_addr +x);
 276 }
 277
 278 u16 read_nic_word(struct net_device *dev, int x)
 279 {
 280         return inw(dev->base_addr +x);
 281 }
 282
 283 void write_nic_byte(struct net_device *dev, int x,u8 y)
 284 {
 285         outb(y&0xff,dev->base_addr +x);
 286 }
 287
 288 void write_nic_word(struct net_device *dev, int x,u16 y)
 289 {
 290         outw(y,dev->base_addr +x);
 291 }
 292
 293 void write_nic_dword(struct net_device *dev, int x,u32 y)
 294 {
 295         outl(y,dev->base_addr +x);
 296 }
 297
 298 #else /* RTL_IO_MAP */
 299
 300 u8 read_nic_byte(struct net_device *dev, int x)
 301 {
 302         return 0xff&readb((u8*)dev->mem_start +x);
 303 }
 304
 305 u32 read_nic_dword(struct net_device *dev, int x)
 306 {
 307         return readl((u8*)dev->mem_start +x);
 308 }
 309
 310 u16 read_nic_word(struct net_device *dev, int x)
 311 {
 312         return readw((u8*)dev->mem_start +x);
 313 }
 314
 315 void write_nic_byte(struct net_device *dev, int x,u8 y)
 316 {
 317         writeb(y,(u8*)dev->mem_start +x);
 318         udelay(20);
 319 }
 320
 321 void write_nic_dword(struct net_device *dev, int x,u32 y)
 322 {
 323         writel(y,(u8*)dev->mem_start +x);
 324         udelay(20);
 325 }
 326
 327 void write_nic_word(struct net_device *dev, int x,u16 y)
 328 {
 329         writew(y,(u8*)dev->mem_start +x);
 330         udelay(20);
 331 }
 332
 333 #endif /* RTL_IO_MAP */
 334
 335 u8 rtl8192e_ap_sec_type(struct ieee80211_device *ieee)
 336 {
 337         static const u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
 338         static const u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
 339         int wpa_ie_len= ieee->wpa_ie_len;
 340         struct ieee80211_crypt_data* crypt;
 341         int encrypt;
 342
 343         crypt = ieee->crypt[ieee->tx_keyidx];
 344
 345         encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY) ||
 346                   (ieee->host_encrypt && crypt && crypt->ops &&
 347                    (0 == strcmp(crypt->ops->name,"WEP")));
 348
 349         /* simply judge  */
 350         if(encrypt && (wpa_ie_len == 0)) {
 351                 // wep encryption, no N mode setting */
 352                 return SEC_ALG_WEP;
 353         } else if((wpa_ie_len != 0)) {
 354                 // parse pairwise key type */
 355                 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) ||
 356                                 ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10],ccmp_rsn_ie, 4))))
 357                         return SEC_ALG_CCMP;
 358                 else
 359                         return SEC_ALG_TKIP;
 360         } else {
 361                 return SEC_ALG_NONE;
 362         }
 363 }
 364
 365 void
 366 rtl8192e_SetHwReg(struct net_device *dev,u8 variable,u8* val)
 367 {
 368         struct r8192_priv* priv = ieee80211_priv(dev);
 369
 370         switch(variable)
 371         {
 372
 373                 case HW_VAR_BSSID:
 374                         write_nic_dword(dev, BSSIDR, ((u32*)(val))[0]);
 375                         write_nic_word(dev, BSSIDR+2, ((u16*)(val+2))[0]);
 376                 break;
 377
 378                 case HW_VAR_MEDIA_STATUS:
 379                 {
 380                         RT_OP_MODE      OpMode = *((RT_OP_MODE *)(val));
 381                         u8              btMsr = read_nic_byte(dev, MSR);
 382
 383                         btMsr &= 0xfc;
 384
 385                         switch(OpMode)
 386                         {
 387                         case RT_OP_MODE_INFRASTRUCTURE:
 388                                 btMsr |= MSR_INFRA;
 389                                 break;
 390
 391                         case RT_OP_MODE_IBSS:
 392                                 btMsr |= MSR_ADHOC;
 393                                 break;
 394
 395                         case RT_OP_MODE_AP:
 396                                 btMsr |= MSR_AP;
 397                                 break;
 398
 399                         default:
 400                                 btMsr |= MSR_NOLINK;
 401                                 break;
 402                         }
 403
 404                         write_nic_byte(dev, MSR, btMsr);
 405                 }
 406                 break;
 407
 408                 case HW_VAR_CECHK_BSSID:
 409                 {
 410                         u32     RegRCR, Type;
 411
 412                         Type = ((u8*)(val))[0];
 413                         RegRCR = read_nic_dword(dev,RCR);
 414                         priv->ReceiveConfig = RegRCR;
 415
 416                         if (Type == true)
 417                                 RegRCR |= (RCR_CBSSID);
 418                         else if (Type == false)
 419                                 RegRCR &= (~RCR_CBSSID);
 420
 421                         write_nic_dword(dev, RCR,RegRCR);
 422                         priv->ReceiveConfig = RegRCR;
 423
 424                 }
 425                 break;
 426
 427                 case HW_VAR_SLOT_TIME:
 428                 {
 429                         priv->slot_time = val[0];
 430                         write_nic_byte(dev, SLOT_TIME, val[0]);
 431
 432                 }
 433                 break;
 434
 435                 case HW_VAR_ACK_PREAMBLE:
 436                 {
 437                         u32 regTmp = 0;
 438                         priv->short_preamble = (bool)(*(u8*)val );
 439                         regTmp = priv->basic_rate;
 440                         if (priv->short_preamble)
 441                                 regTmp |= BRSR_AckShortPmb;
 442                         write_nic_dword(dev, RRSR, regTmp);
 443                 }
 444                 break;
 445
 446                 case HW_VAR_CPU_RST:
 447                         write_nic_dword(dev, CPU_GEN, ((u32*)(val))[0]);
 448                 break;
 449
 450                 default:
 451                 break;
 452         }
 453
 454 }
 455
 456 static struct proc_dir_entry *rtl8192_proc = NULL;
 457
 458 static int proc_get_stats_ap(char *page, char **start,
 459                           off_t offset, int count,
 460                           int *eof, void *data)
 461 {
 462         struct net_device *dev = data;
 463         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 464         struct ieee80211_device *ieee = priv->ieee80211;
 465         struct ieee80211_network *target;
 466         int len = 0;
 467
 468         list_for_each_entry(target, &ieee->network_list, list) {
 469
 470                 len += snprintf(page + len, count - len,
 471                 "%s ", target->ssid);
 472
 473                 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
 474                         len += snprintf(page + len, count - len,
 475                         "WPA\n");
 476                 }
 477                 else{
 478                         len += snprintf(page + len, count - len,
 479                         "non_WPA\n");
 480                 }
 481
 482         }
 483
 484         *eof = 1;
 485         return len;
 486 }
 487
 488 static int proc_get_registers(char *page, char **start,
 489                           off_t offset, int count,
 490                           int *eof, void *data)
 491 {
 492         struct net_device *dev = data;
 493         int len = 0;
 494         int i,n;
 495         int max=0xff;
 496
 497         /* This dump the current register page */
 498         len += snprintf(page + len, count - len,
 499                         "\n####################page 0##################\n ");
 500
 501         for(n=0;n<=max;)
 502         {
 503                 len += snprintf(page + len, count - len,
 504                         "\nD:  %2x > ",n);
 505
 506                 for(i=0;i<16 && n<=max;i++,n++)
 507                 len += snprintf(page + len, count - len,
 508                         "%2x ",read_nic_byte(dev,n));
 509         }
 510         len += snprintf(page + len, count - len,"\n");
 511         len += snprintf(page + len, count - len,
 512                         "\n####################page 1##################\n ");
 513         for(n=0;n<=max;)
 514         {
 515                 len += snprintf(page + len, count - len,
 516                         "\nD:  %2x > ",n);
 517
 518                 for(i=0;i<16 && n<=max;i++,n++)
 519                 len += snprintf(page + len, count - len,
 520                         "%2x ",read_nic_byte(dev,0x100|n));
 521         }
 522
 523         len += snprintf(page + len, count - len,
 524                         "\n####################page 3##################\n ");
 525         for(n=0;n<=max;)
 526         {
 527                 len += snprintf(page + len, count - len,
 528                         "\nD:  %2x > ",n);
 529
 530                 for(i=0;i<16 && n<=max;i++,n++)
 531                 len += snprintf(page + len, count - len,
 532                         "%2x ",read_nic_byte(dev,0x300|n));
 533         }
 534
 535         *eof = 1;
 536         return len;
 537
 538 }
 539
 540 static int proc_get_stats_tx(char *page, char **start,
 541                           off_t offset, int count,
 542                           int *eof, void *data)
 543 {
 544         struct net_device *dev = data;
 545         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 546
 547         int len = 0;
 548
 549         len += snprintf(page + len, count - len,
 550                 "TX VI priority ok int: %lu\n"
 551 //              "TX VI priority error int: %lu\n"
 552                 "TX VO priority ok int: %lu\n"
 553 //              "TX VO priority error int: %lu\n"
 554                 "TX BE priority ok int: %lu\n"
 555 //              "TX BE priority error int: %lu\n"
 556                 "TX BK priority ok int: %lu\n"
 557 //              "TX BK priority error int: %lu\n"
 558                 "TX MANAGE priority ok int: %lu\n"
 559 //              "TX MANAGE priority error int: %lu\n"
 560                 "TX BEACON priority ok int: %lu\n"
 561                 "TX BEACON priority error int: %lu\n"
 562                 "TX CMDPKT priority ok int: %lu\n"
 563 //              "TX high priority ok int: %lu\n"
 564 //              "TX high priority failed error int: %lu\n"
 565 //              "TX queue resume: %lu\n"
 566                 "TX queue stopped?: %d\n"
 567                 "TX fifo overflow: %lu\n"
 568 //              "TX beacon: %lu\n"
 569 //              "TX VI queue: %d\n"
 570 //              "TX VO queue: %d\n"
 571 //              "TX BE queue: %d\n"
 572 //              "TX BK queue: %d\n"
 573 //              "TX HW queue: %d\n"
 574 //              "TX VI dropped: %lu\n"
 575 //              "TX VO dropped: %lu\n"
 576 //              "TX BE dropped: %lu\n"
 577 //              "TX BK dropped: %lu\n"
 578                 "TX total data packets %lu\n"
 579                 "TX total data bytes :%lu\n",
 580 //              "TX beacon aborted: %lu\n",
 581                 priv->stats.txviokint,
 582 //              priv->stats.txvierr,
 583                 priv->stats.txvookint,
 584 //              priv->stats.txvoerr,
 585                 priv->stats.txbeokint,
 586 //              priv->stats.txbeerr,
 587                 priv->stats.txbkokint,
 588 //              priv->stats.txbkerr,
 589                 priv->stats.txmanageokint,
 590 //              priv->stats.txmanageerr,
 591                 priv->stats.txbeaconokint,
 592                 priv->stats.txbeaconerr,
 593                 priv->stats.txcmdpktokint,
 594 //              priv->stats.txhpokint,
 595 //              priv->stats.txhperr,
 596 //              priv->stats.txresumed,
 597                 netif_queue_stopped(dev),
 598                 priv->stats.txoverflow,
 599 //              priv->stats.txbeacon,
 600 //              atomic_read(&(priv->tx_pending[VI_QUEUE])),
 601 //              atomic_read(&(priv->tx_pending[VO_QUEUE])),
 602 //              atomic_read(&(priv->tx_pending[BE_QUEUE])),
 603 //              atomic_read(&(priv->tx_pending[BK_QUEUE])),
 604 //              read_nic_byte(dev, TXFIFOCOUNT),
 605 //              priv->stats.txvidrop,
 606 //              priv->stats.txvodrop,
 607                 priv->ieee80211->stats.tx_packets,
 608                 priv->ieee80211->stats.tx_bytes
 609
 610
 611 //              priv->stats.txbedrop,
 612 //              priv->stats.txbkdrop
 613                         //      priv->stats.txdatapkt
 614 //              priv->stats.txbeaconerr
 615                 );
 616
 617         *eof = 1;
 618         return len;
 619 }
 620
 621
 622
 623 static int proc_get_stats_rx(char *page, char **start,
 624                           off_t offset, int count,
 625                           int *eof, void *data)
 626 {
 627         struct net_device *dev = data;
 628         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 629
 630         int len = 0;
 631
 632         len += snprintf(page + len, count - len,
 633                 "RX packets: %lu\n"
 634                 "RX desc err: %lu\n"
 635                 "RX rx overflow error: %lu\n"
 636                 "RX invalid urb error: %lu\n",
 637                 priv->stats.rxint,
 638                 priv->stats.rxrdu,
 639                 priv->stats.rxoverflow,
 640                 priv->stats.rxurberr);
 641
 642         *eof = 1;
 643         return len;
 644 }
 645
 646 static void rtl8192_proc_module_init(void)
 647 {
 648         RT_TRACE(COMP_INIT, "Initializing proc filesystem");
 649         rtl8192_proc=create_proc_entry(RTL819xE_MODULE_NAME, S_IFDIR, init_net.proc_net);
 650 }
 651
 652
 653 static void rtl8192_proc_module_remove(void)
 654 {
 655         remove_proc_entry(RTL819xE_MODULE_NAME, init_net.proc_net);
 656 }
 657
 658
 659 static void rtl8192_proc_remove_one(struct net_device *dev)
 660 {
 661         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 662
 663         printk("dev name=======> %s\n",dev->name);
 664
 665         if (priv->dir_dev) {
 666         //      remove_proc_entry("stats-hw", priv->dir_dev);
 667                 remove_proc_entry("stats-tx", priv->dir_dev);
 668                 remove_proc_entry("stats-rx", priv->dir_dev);
 669         //      remove_proc_entry("stats-ieee", priv->dir_dev);
 670                 remove_proc_entry("stats-ap", priv->dir_dev);
 671                 remove_proc_entry("registers", priv->dir_dev);
 672         //      remove_proc_entry("cck-registers",priv->dir_dev);
 673         //      remove_proc_entry("ofdm-registers",priv->dir_dev);
 674                 //remove_proc_entry(dev->name, rtl8192_proc);
 675                 remove_proc_entry("wlan0", rtl8192_proc);
 676                 priv->dir_dev = NULL;
 677         }
 678 }
 679
 680
 681 static void rtl8192_proc_init_one(struct net_device *dev)
 682 {
 683         struct proc_dir_entry *e;
 684         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 685         priv->dir_dev = create_proc_entry(dev->name,
 686                                           S_IFDIR | S_IRUGO | S_IXUGO,
 687                                           rtl8192_proc);
 688         if (!priv->dir_dev) {
 689                 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
 690                       dev->name);
 691                 return;
 692         }
 693         e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
 694                                    priv->dir_dev, proc_get_stats_rx, dev);
 695
 696         if (!e) {
 697                 RT_TRACE(COMP_ERR,"Unable to initialize "
 698                       "/proc/net/rtl8192/%s/stats-rx\n",
 699                       dev->name);
 700         }
 701
 702
 703         e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
 704                                    priv->dir_dev, proc_get_stats_tx, dev);
 705
 706         if (!e) {
 707                 RT_TRACE(COMP_ERR, "Unable to initialize "
 708                       "/proc/net/rtl8192/%s/stats-tx\n",
 709                       dev->name);
 710         }
 711
 712         e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
 713                                    priv->dir_dev, proc_get_stats_ap, dev);
 714
 715         if (!e) {
 716                 RT_TRACE(COMP_ERR, "Unable to initialize "
 717                       "/proc/net/rtl8192/%s/stats-ap\n",
 718                       dev->name);
 719         }
 720
 721         e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
 722                                    priv->dir_dev, proc_get_registers, dev);
 723         if (!e) {
 724                 RT_TRACE(COMP_ERR, "Unable to initialize "
 725                       "/proc/net/rtl8192/%s/registers\n",
 726                       dev->name);
 727         }
 728 }
 729
 730 short check_nic_enough_desc(struct net_device *dev, int prio)
 731 {
 732     struct r8192_priv *priv = ieee80211_priv(dev);
 733     struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
 734
 735     /* for now we reserve two free descriptor as a safety boundary
 736      * between the tail and the head
 737      */
 738     return (ring->entries - skb_queue_len(&ring->queue) >= 2);
 739 }
 740
 741 static void tx_timeout(struct net_device *dev)
 742 {
 743         struct r8192_priv *priv = ieee80211_priv(dev);
 744
 745         schedule_work(&priv->reset_wq);
 746         printk("TXTIMEOUT");
 747 }
 748
 749 static void rtl8192_irq_enable(struct net_device *dev)
 750 {
 751         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 752         priv->irq_enabled = 1;
 753         write_nic_dword(dev,INTA_MASK, priv->irq_mask);
 754 }
 755
 756 void rtl8192_irq_disable(struct net_device *dev)
 757 {
 758         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 759
 760         write_nic_dword(dev,INTA_MASK,0);
 761         priv->irq_enabled = 0;
 762 }
 763
 764 void rtl8192_update_msr(struct net_device *dev)
 765 {
 766         struct r8192_priv *priv = ieee80211_priv(dev);
 767         u8 msr;
 768
 769         msr  = read_nic_byte(dev, MSR);
 770         msr &= ~ MSR_LINK_MASK;
 771
 772         /* do not change in link_state != WLAN_LINK_ASSOCIATED.
 773          * msr must be updated if the state is ASSOCIATING.
 774          * this is intentional and make sense for ad-hoc and
 775          * master (see the create BSS/IBSS func)
 776          */
 777         if (priv->ieee80211->state == IEEE80211_LINKED){
 778
 779                 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
 780                         msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
 781                 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
 782                         msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
 783                 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
 784                         msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
 785
 786         }else
 787                 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
 788
 789         write_nic_byte(dev, MSR, msr);
 790 }
 791
 792 void rtl8192_set_chan(struct net_device *dev,short ch)
 793 {
 794         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 795
 796         priv->chan = ch;
 797
 798         /* need to implement rf set channel here WB */
 799
 800         if (priv->rf_set_chan)
 801                 priv->rf_set_chan(dev, priv->chan);
 802 }
 803
 804 void rtl8192_rx_enable(struct net_device *dev)
 805 {
 806         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 807
 808         write_nic_dword(dev, RDQDA,priv->rx_ring_dma);
 809 }
 810
 811 /* the TX_DESC_BASE setting is according to the following queue index
 812  *  BK_QUEUE       ===>                        0
 813  *  BE_QUEUE       ===>                        1
 814  *  VI_QUEUE       ===>                        2
 815  *  VO_QUEUE       ===>                        3
 816  *  HCCA_QUEUE     ===>                        4
 817  *  TXCMD_QUEUE    ===>                        5
 818  *  MGNT_QUEUE     ===>                        6
 819  *  HIGH_QUEUE     ===>                        7
 820  *  BEACON_QUEUE   ===>                        8
 821  *  */
 822 static const u32 TX_DESC_BASE[] = {BKQDA, BEQDA, VIQDA, VOQDA, HCCAQDA, CQDA, MQDA, HQDA, BQDA};
 823 void rtl8192_tx_enable(struct net_device *dev)
 824 {
 825         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 826         u32 i;
 827
 828         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
 829                 write_nic_dword(dev, TX_DESC_BASE[i], priv->tx_ring[i].dma);
 830
 831         ieee80211_reset_queue(priv->ieee80211);
 832 }
 833
 834
 835 static void rtl8192_free_rx_ring(struct net_device *dev)
 836 {
 837         struct r8192_priv *priv = ieee80211_priv(dev);
 838         int i;
 839
 840         for (i = 0; i < priv->rxringcount; i++) {
 841                 struct sk_buff *skb = priv->rx_buf[i];
 842                 if (!skb)
 843                         continue;
 844
 845                 pci_unmap_single(priv->pdev,
 846                                  *((dma_addr_t *)skb->cb),
 847                                  priv->rxbuffersize, PCI_DMA_FROMDEVICE);
 848                 kfree_skb(skb);
 849         }
 850
 851         pci_free_consistent(priv->pdev, sizeof(*priv->rx_ring) * priv->rxringcount,
 852                             priv->rx_ring, priv->rx_ring_dma);
 853         priv->rx_ring = NULL;
 854 }
 855
 856 static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
 857 {
 858         struct r8192_priv *priv = ieee80211_priv(dev);
 859         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
 860
 861         while (skb_queue_len(&ring->queue)) {
 862                 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
 863                 struct sk_buff *skb = __skb_dequeue(&ring->queue);
 864
 865                 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
 866                                  skb->len, PCI_DMA_TODEVICE);
 867                 kfree_skb(skb);
 868                 ring->idx = (ring->idx + 1) % ring->entries;
 869         }
 870
 871         pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
 872                             ring->desc, ring->dma);
 873         ring->desc = NULL;
 874 }
 875
 876 void PHY_SetRtl8192eRfOff(struct net_device* dev)
 877 {
 878         //disable RF-Chip A/B
 879         rtl8192_setBBreg(dev, rFPGA0_XA_RFInterfaceOE, BIT4, 0x0);
 880         //analog to digital off, for power save
 881         rtl8192_setBBreg(dev, rFPGA0_AnalogParameter4, 0x300, 0x0);
 882         //digital to analog off, for power save
 883         rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x18, 0x0);
 884         //rx antenna off
 885         rtl8192_setBBreg(dev, rOFDM0_TRxPathEnable, 0xf, 0x0);
 886         //rx antenna off
 887         rtl8192_setBBreg(dev, rOFDM1_TRxPathEnable, 0xf, 0x0);
 888         //analog to digital part2 off, for power save
 889         rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x60, 0x0);
 890         rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x4, 0x0);
 891         // Analog parameter!!Change bias and Lbus control.
 892         write_nic_byte(dev, ANAPAR_FOR_8192PciE, 0x07);
 893
 894 }
 895
 896 void rtl8192_halt_adapter(struct net_device *dev, bool reset)
 897 {
 898         struct r8192_priv *priv = ieee80211_priv(dev);
 899         int i;
 900         u8 OpMode;
 901         u32 ulRegRead;
 902
 903         OpMode = RT_OP_MODE_NO_LINK;
 904         priv->ieee80211->SetHwRegHandler(dev, HW_VAR_MEDIA_STATUS, &OpMode);
 905
 906         if (!priv->ieee80211->bSupportRemoteWakeUp) {
 907                 /*
 908                  * disable tx/rx. In 8185 we write 0x10 (Reset bit),
 909                  * but here we make reference to WMAC and wirte 0x0
 910                  */
 911                 write_nic_byte(dev, CMDR, 0);
 912         }
 913
 914         mdelay(20);
 915
 916         if (!reset) {
 917                 mdelay(150);
 918
 919 #ifdef RTL8192E
 920                 priv->bHwRfOffAction = 2;
 921 #endif
 922
 923                 /*
 924                  * Call MgntActSet_RF_State instead to
 925                  * prevent RF config race condition.
 926                  */
 927                 if (!priv->ieee80211->bSupportRemoteWakeUp) {
 928                         PHY_SetRtl8192eRfOff(dev);
 929                         ulRegRead = read_nic_dword(dev,CPU_GEN);
 930                         ulRegRead |= CPU_GEN_SYSTEM_RESET;
 931                         write_nic_dword(dev,CPU_GEN, ulRegRead);
 932                 } else {
 933                         /* for WOL */
 934                         write_nic_dword(dev, WFCRC0, 0xffffffff);
 935                         write_nic_dword(dev, WFCRC1, 0xffffffff);
 936                         write_nic_dword(dev, WFCRC2, 0xffffffff);
 937
 938                         /* Write PMR register */
 939                         write_nic_byte(dev, PMR, 0x5);
 940                         /* Disable tx, enanble rx */
 941                         write_nic_byte(dev, MacBlkCtrl, 0xa);
 942                 }
 943         }
 944
 945         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
 946                 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
 947         }
 948         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
 949                 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
 950         }
 951
 952         skb_queue_purge(&priv->skb_queue);
 953 }
 954
 955 static const u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
 956 inline u16 rtl8192_rate2rate(short rate)
 957 {
 958         if (rate >11) return 0;
 959         return rtl_rate[rate];
 960 }
 961
 962 static void rtl8192_data_hard_stop(struct net_device *dev)
 963 {
 964 }
 965
 966 static void rtl8192_data_hard_resume(struct net_device *dev)
 967 {
 968 }
 969
 970 /*
 971  * this function TX data frames when the ieee80211 stack requires this.
 972  * It checks also if we need to stop the ieee tx queue, eventually do it
 973  */
 974 static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
 975 {
 976         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
 977         int ret;
 978         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
 979         u8 queue_index = tcb_desc->queue_index;
 980
 981         /* shall not be referred by command packet */
 982         assert(queue_index != TXCMD_QUEUE);
 983
 984         if (priv->bHwRadioOff || (!priv->up))
 985         {
 986                 kfree_skb(skb);
 987                 return;
 988         }
 989
 990         memcpy(skb->cb, &dev, sizeof(dev));
 991
 992         skb_push(skb, priv->ieee80211->tx_headroom);
 993         ret = rtl8192_tx(dev, skb);
 994         if (ret != 0) {
 995                 kfree_skb(skb);
 996         }
 997
 998         if (queue_index != MGNT_QUEUE) {
 999                 priv->ieee80211->stats.tx_bytes += (skb->len - priv->ieee80211->tx_headroom);
1000                 priv->ieee80211->stats.tx_packets++;
1001         }
1002 }
1003
1004 /*
1005  * This is a rough attempt to TX a frame
1006  * This is called by the ieee 80211 stack to TX management frames.
1007  * If the ring is full packet are dropped (for data frame the queue
1008  * is stopped before this can happen).
1009  */
1010 static int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1011 {
1012         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1013         int ret;
1014         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1015         u8 queue_index = tcb_desc->queue_index;
1016
1017         if (queue_index != TXCMD_QUEUE) {
1018                 if (priv->bHwRadioOff || (!priv->up))
1019                 {
1020                         kfree_skb(skb);
1021                         return 0;
1022                 }
1023         }
1024
1025         memcpy(skb->cb, &dev, sizeof(dev));
1026         if (queue_index == TXCMD_QUEUE) {
1027                 rtl819xE_tx_cmd(dev, skb);
1028                 ret = 0;
1029                 return ret;
1030         } else {
1031                 tcb_desc->RATRIndex = 7;
1032                 tcb_desc->bTxDisableRateFallBack = 1;
1033                 tcb_desc->bTxUseDriverAssingedRate = 1;
1034                 tcb_desc->bTxEnableFwCalcDur = 1;
1035                 skb_push(skb, priv->ieee80211->tx_headroom);
1036                 ret = rtl8192_tx(dev, skb);
1037                 if (ret != 0) {
1038                         kfree_skb(skb);
1039                 }
1040         }
1041
1042         return ret;
1043 }
1044
1045
1046 static void rtl8192_tx_isr(struct net_device *dev, int prio)
1047 {
1048         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1049         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1050
1051         while (skb_queue_len(&ring->queue)) {
1052                 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1053                 struct sk_buff *skb;
1054
1055                 /*
1056                  * beacon packet will only use the first descriptor defaultly,
1057                  * and the OWN may not be cleared by the hardware
1058                  */
1059                 if (prio != BEACON_QUEUE) {
1060                         if (entry->OWN)
1061                                 return;
1062                         ring->idx = (ring->idx + 1) % ring->entries;
1063                 }
1064
1065                 skb = __skb_dequeue(&ring->queue);
1066                 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1067                                  skb->len, PCI_DMA_TODEVICE);
1068
1069                 kfree_skb(skb);
1070         }
1071         if (prio == MGNT_QUEUE) {
1072                 if (priv->ieee80211->ack_tx_to_ieee) {
1073                         if (rtl8192_is_tx_queue_empty(dev)) {
1074                                 priv->ieee80211->ack_tx_to_ieee = 0;
1075                                 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1076                         }
1077                 }
1078         }
1079
1080         if (prio != BEACON_QUEUE) {
1081                 /* try to deal with the pending packets  */
1082                 tasklet_schedule(&priv->irq_tx_tasklet);
1083         }
1084 }
1085
1086 static void rtl8192_stop_beacon(struct net_device *dev)
1087 {
1088 }
1089
1090 static void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1091 {
1092          struct r8192_priv *priv = ieee80211_priv(dev);
1093          struct ieee80211_network *net;
1094          u8 i=0, basic_rate = 0;
1095          net = & priv->ieee80211->current_network;
1096
1097          for (i=0; i<net->rates_len; i++)
1098          {
1099                  basic_rate = net->rates[i]&0x7f;
1100                  switch(basic_rate)
1101                  {
1102                          case MGN_1M:   *rate_config |= RRSR_1M;        break;
1103                          case MGN_2M:   *rate_config |= RRSR_2M;        break;
1104                          case MGN_5_5M: *rate_config |= RRSR_5_5M;      break;
1105                          case MGN_11M:  *rate_config |= RRSR_11M;       break;
1106                          case MGN_6M:   *rate_config |= RRSR_6M;        break;
1107                          case MGN_9M:   *rate_config |= RRSR_9M;        break;
1108                          case MGN_12M:  *rate_config |= RRSR_12M;       break;
1109                          case MGN_18M:  *rate_config |= RRSR_18M;       break;
1110                          case MGN_24M:  *rate_config |= RRSR_24M;       break;
1111                          case MGN_36M:  *rate_config |= RRSR_36M;       break;
1112                          case MGN_48M:  *rate_config |= RRSR_48M;       break;
1113                          case MGN_54M:  *rate_config |= RRSR_54M;       break;
1114                  }
1115          }
1116          for (i=0; i<net->rates_ex_len; i++)
1117          {
1118                  basic_rate = net->rates_ex[i]&0x7f;
1119                  switch(basic_rate)
1120                  {
1121                          case MGN_1M:   *rate_config |= RRSR_1M;        break;
1122                          case MGN_2M:   *rate_config |= RRSR_2M;        break;
1123                          case MGN_5_5M: *rate_config |= RRSR_5_5M;      break;
1124                          case MGN_11M:  *rate_config |= RRSR_11M;       break;
1125                          case MGN_6M:   *rate_config |= RRSR_6M;        break;
1126                          case MGN_9M:   *rate_config |= RRSR_9M;        break;
1127                          case MGN_12M:  *rate_config |= RRSR_12M;       break;
1128                          case MGN_18M:  *rate_config |= RRSR_18M;       break;
1129                          case MGN_24M:  *rate_config |= RRSR_24M;       break;
1130                          case MGN_36M:  *rate_config |= RRSR_36M;       break;
1131                          case MGN_48M:  *rate_config |= RRSR_48M;       break;
1132                          case MGN_54M:  *rate_config |= RRSR_54M;       break;
1133                  }
1134          }
1135 }
1136
1137
1138 #define SHORT_SLOT_TIME 9
1139 #define NON_SHORT_SLOT_TIME 20
1140
1141 static void rtl8192_update_cap(struct net_device* dev, u16 cap)
1142 {
1143         u32 tmp = 0;
1144         struct r8192_priv *priv = ieee80211_priv(dev);
1145         struct ieee80211_network *net = &priv->ieee80211->current_network;
1146         priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1147         tmp = priv->basic_rate;
1148         if (priv->short_preamble)
1149                 tmp |= BRSR_AckShortPmb;
1150         write_nic_dword(dev, RRSR, tmp);
1151
1152         if (net->mode & (IEEE_G|IEEE_N_24G))
1153         {
1154                 u8 slot_time = 0;
1155                 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1156                 {//short slot time
1157                         slot_time = SHORT_SLOT_TIME;
1158                 }
1159                 else //long slot time
1160                         slot_time = NON_SHORT_SLOT_TIME;
1161                 priv->slot_time = slot_time;
1162                 write_nic_byte(dev, SLOT_TIME, slot_time);
1163         }
1164
1165 }
1166
1167 static void rtl8192_net_update(struct net_device *dev)
1168 {
1169         struct r8192_priv *priv = ieee80211_priv(dev);
1170         struct ieee80211_network *net;
1171         u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1172         u16 rate_config = 0;
1173         net = &priv->ieee80211->current_network;
1174
1175         /* update Basic rate: RR, BRSR */
1176         rtl8192_config_rate(dev, &rate_config);
1177
1178         /*
1179          * Select RRSR (in Legacy-OFDM and CCK)
1180          * For 8190, we select only 24M, 12M, 6M, 11M, 5.5M,
1181          * 2M, and 1M from the Basic rate.
1182          * We do not use other rates.
1183          */
1184         priv->basic_rate = rate_config &= 0x15f;
1185
1186         /* BSSID */
1187         write_nic_dword(dev, BSSIDR, ((u32 *)net->bssid)[0]);
1188         write_nic_word(dev, BSSIDR+4, ((u16 *)net->bssid)[2]);
1189
1190         if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1191         {
1192                 write_nic_word(dev, ATIMWND, 2);
1193                 write_nic_word(dev, BCN_DMATIME, 256);
1194                 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1195                 /*
1196                  * BIT15 of BCN_DRV_EARLY_INT will indicate
1197                  * whether software beacon or hw beacon is applied.
1198                  */
1199                 write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
1200                 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1201
1202                 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1203                 /* TODO: BcnIFS may required to be changed on ASIC */
1204                 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1205                 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1206         }
1207 }
1208
1209 void rtl819xE_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1210 {
1211     struct r8192_priv *priv = ieee80211_priv(dev);
1212     struct rtl8192_tx_ring *ring;
1213     tx_desc_819x_pci *entry;
1214     unsigned int idx;
1215     dma_addr_t mapping;
1216     cb_desc *tcb_desc;
1217     unsigned long flags;
1218
1219     ring = &priv->tx_ring[TXCMD_QUEUE];
1220     mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1221
1222     spin_lock_irqsave(&priv->irq_th_lock,flags);
1223     idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1224     entry = &ring->desc[idx];
1225
1226     tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1227     memset(entry,0,12);
1228     entry->LINIP = tcb_desc->bLastIniPkt;
1229     entry->FirstSeg = 1;//first segment
1230     entry->LastSeg = 1; //last segment
1231     if(tcb_desc->bCmdOrInit == DESC_PACKET_TYPE_INIT) {
1232         entry->CmdInit = DESC_PACKET_TYPE_INIT;
1233     } else {
1234         entry->CmdInit = DESC_PACKET_TYPE_NORMAL;
1235         entry->Offset = sizeof(TX_FWINFO_8190PCI) + 8;
1236         entry->PktSize = (u16)(tcb_desc->pkt_size + entry->Offset);
1237         entry->QueueSelect = QSLT_CMD;
1238         entry->TxFWInfoSize = 0x08;
1239         entry->RATid = (u8)DESC_PACKET_TYPE_INIT;
1240     }
1241     entry->TxBufferSize = skb->len;
1242     entry->TxBuffAddr = cpu_to_le32(mapping);
1243     entry->OWN = 1;
1244
1245 #ifdef JOHN_DUMP_TXDESC
1246     {       int i;
1247         tx_desc_819x_pci *entry1 =  &ring->desc[0];
1248         unsigned int *ptr= (unsigned int *)entry1;
1249         printk("<Tx descriptor>:\n");
1250         for (i = 0; i < 8; i++)
1251             printk("%8x ", ptr[i]);
1252         printk("\n");
1253     }
1254 #endif
1255     __skb_queue_tail(&ring->queue, skb);
1256     spin_unlock_irqrestore(&priv->irq_th_lock,flags);
1257
1258     write_nic_byte(dev, TPPoll, TPPoll_CQ);
1259
1260     return;
1261 }
1262
1263 /*
1264  * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1265  * in TxFwInfo data structure
1266  */
1267 static u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1268 {
1269         u8 QueueSelect = 0;
1270
1271         switch (QueueID) {
1272         case BE_QUEUE:
1273                 QueueSelect = QSLT_BE;
1274                 break;
1275
1276         case BK_QUEUE:
1277                 QueueSelect = QSLT_BK;
1278                 break;
1279
1280         case VO_QUEUE:
1281                 QueueSelect = QSLT_VO;
1282                 break;
1283
1284         case VI_QUEUE:
1285                 QueueSelect = QSLT_VI;
1286                 break;
1287
1288         case MGNT_QUEUE:
1289                 QueueSelect = QSLT_MGNT;
1290                 break;
1291
1292         case BEACON_QUEUE:
1293                 QueueSelect = QSLT_BEACON;
1294                 break;
1295
1296         case TXCMD_QUEUE:
1297                 QueueSelect = QSLT_CMD;
1298                 break;
1299
1300         case HIGH_QUEUE:
1301         default:
1302                 RT_TRACE(COMP_ERR, "Impossible Queue Selection: %d\n", QueueID);
1303                 break;
1304         }
1305         return QueueSelect;
1306 }
1307
1308 static u8 MRateToHwRate8190Pci(u8 rate)
1309 {
1310         u8  ret = DESC90_RATE1M;
1311
1312         switch(rate) {
1313                 case MGN_1M:    ret = DESC90_RATE1M;            break;
1314                 case MGN_2M:    ret = DESC90_RATE2M;            break;
1315                 case MGN_5_5M:  ret = DESC90_RATE5_5M;  break;
1316                 case MGN_11M:   ret = DESC90_RATE11M;   break;
1317                 case MGN_6M:    ret = DESC90_RATE6M;            break;
1318                 case MGN_9M:    ret = DESC90_RATE9M;            break;
1319                 case MGN_12M:   ret = DESC90_RATE12M;   break;
1320                 case MGN_18M:   ret = DESC90_RATE18M;   break;
1321                 case MGN_24M:   ret = DESC90_RATE24M;   break;
1322                 case MGN_36M:   ret = DESC90_RATE36M;   break;
1323                 case MGN_48M:   ret = DESC90_RATE48M;   break;
1324                 case MGN_54M:   ret = DESC90_RATE54M;   break;
1325
1326                 // HT rate since here
1327                 case MGN_MCS0:  ret = DESC90_RATEMCS0;  break;
1328                 case MGN_MCS1:  ret = DESC90_RATEMCS1;  break;
1329                 case MGN_MCS2:  ret = DESC90_RATEMCS2;  break;
1330                 case MGN_MCS3:  ret = DESC90_RATEMCS3;  break;
1331                 case MGN_MCS4:  ret = DESC90_RATEMCS4;  break;
1332                 case MGN_MCS5:  ret = DESC90_RATEMCS5;  break;
1333                 case MGN_MCS6:  ret = DESC90_RATEMCS6;  break;
1334                 case MGN_MCS7:  ret = DESC90_RATEMCS7;  break;
1335                 case MGN_MCS8:  ret = DESC90_RATEMCS8;  break;
1336                 case MGN_MCS9:  ret = DESC90_RATEMCS9;  break;
1337                 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1338                 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1339                 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1340                 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1341                 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1342                 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1343                 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1344
1345                 default:       break;
1346         }
1347         return ret;
1348 }
1349
1350
1351 static u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1352 {
1353         u8   tmp_Short;
1354
1355         tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1356
1357         if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1358                 tmp_Short = 0;
1359
1360         return tmp_Short;
1361 }
1362
1363 /*
1364  * The tx procedure is just as following,
1365  * skb->cb will contain all the following information,
1366  * priority, morefrag, rate, &dev.
1367  */
1368 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1369 {
1370         struct r8192_priv *priv = ieee80211_priv(dev);
1371         struct rtl8192_tx_ring *ring;
1372         unsigned long flags;
1373         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1374         tx_desc_819x_pci *pdesc = NULL;
1375         TX_FWINFO_8190PCI *pTxFwInfo = NULL;
1376         dma_addr_t mapping;
1377         bool multi_addr = false, broad_addr = false, uni_addr = false;
1378         u8 *pda_addr = NULL;
1379         int idx;
1380
1381         if (priv->bdisable_nic) {
1382                 RT_TRACE(COMP_ERR, "Nic is disabled! Can't tx packet len=%d qidx=%d!!!\n",
1383                          skb->len, tcb_desc->queue_index);
1384                 return skb->len;
1385         }
1386
1387 #ifdef ENABLE_LPS
1388         priv->ieee80211->bAwakePktSent = true;
1389 #endif
1390
1391         mapping = pci_map_single(priv->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
1392
1393         /* collect the tx packets statitcs */
1394         pda_addr = ((u8 *)skb->data) + sizeof(TX_FWINFO_8190PCI);
1395         if (is_multicast_ether_addr(pda_addr))
1396                 multi_addr = true;
1397         else if (is_broadcast_ether_addr(pda_addr))
1398                 broad_addr = true;
1399         else
1400                 uni_addr = true;
1401
1402         if (uni_addr)
1403                 priv->stats.txbytesunicast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1404         else if (multi_addr)
1405                 priv->stats.txbytesmulticast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1406         else
1407                 priv->stats.txbytesbroadcast += (u8)(skb->len) - sizeof(TX_FWINFO_8190PCI);
1408
1409         /* fill tx firmware */
1410         pTxFwInfo = (PTX_FWINFO_8190PCI)skb->data;
1411         memset(pTxFwInfo, 0, sizeof(TX_FWINFO_8190PCI));
1412         pTxFwInfo->TxHT = (tcb_desc->data_rate&0x80) ? 1 : 0;
1413         pTxFwInfo->TxRate = MRateToHwRate8190Pci((u8)tcb_desc->data_rate);
1414         pTxFwInfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1415         pTxFwInfo->Short = QueryIsShort(pTxFwInfo->TxHT, pTxFwInfo->TxRate, tcb_desc);
1416
1417         /* Aggregation related */
1418         if (tcb_desc->bAMPDUEnable) {
1419                 pTxFwInfo->AllowAggregation = 1;
1420                 pTxFwInfo->RxMF = tcb_desc->ampdu_factor;
1421                 pTxFwInfo->RxAMD = tcb_desc->ampdu_density;
1422         } else {
1423                 pTxFwInfo->AllowAggregation = 0;
1424                 pTxFwInfo->RxMF = 0;
1425                 pTxFwInfo->RxAMD = 0;
1426         }
1427
1428         /* Protection mode related */
1429         pTxFwInfo->RtsEnable = (tcb_desc->bRTSEnable) ? 1 : 0;
1430         pTxFwInfo->CtsEnable = (tcb_desc->bCTSEnable) ? 1 : 0;
1431         pTxFwInfo->RtsSTBC = (tcb_desc->bRTSSTBC) ? 1 : 0;
1432         pTxFwInfo->RtsHT = (tcb_desc->rts_rate&0x80) ? 1 : 0;
1433         pTxFwInfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1434         pTxFwInfo->RtsBandwidth = 0;
1435         pTxFwInfo->RtsSubcarrier = tcb_desc->RTSSC;
1436         pTxFwInfo->RtsShort = (pTxFwInfo->RtsHT == 0) ? (tcb_desc->bRTSUseShortPreamble ? 1 : 0) : (tcb_desc->bRTSUseShortGI? 1 : 0);
1437
1438         /* Set Bandwidth and sub-channel settings. */
1439         if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40) {
1440                 if (tcb_desc->bPacketBW) {
1441                         pTxFwInfo->TxBandwidth = 1;
1442 #ifdef RTL8190P
1443                         pTxFwInfo->TxSubCarrier = 3;
1444 #else
1445                         /* use duplicated mode */
1446                         pTxFwInfo->TxSubCarrier = 0;
1447 #endif
1448                 } else {
1449                         pTxFwInfo->TxBandwidth = 0;
1450                         pTxFwInfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1451                 }
1452         } else {
1453                 pTxFwInfo->TxBandwidth = 0;
1454                 pTxFwInfo->TxSubCarrier = 0;
1455         }
1456
1457         spin_lock_irqsave(&priv->irq_th_lock, flags);
1458         ring = &priv->tx_ring[tcb_desc->queue_index];
1459         if (tcb_desc->queue_index != BEACON_QUEUE)
1460                 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1461         else
1462                 idx = 0;
1463
1464         pdesc = &ring->desc[idx];
1465         if ((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
1466                 RT_TRACE(COMP_ERR, "No more TX desc@%d, ring->idx = %d,idx = %d,%x",
1467                          tcb_desc->queue_index, ring->idx, idx, skb->len);
1468                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1469                 return skb->len;
1470         }
1471
1472         /* fill tx descriptor */
1473         memset(pdesc, 0, 12);
1474
1475         /*DWORD 0*/
1476         pdesc->LINIP = 0;
1477         pdesc->CmdInit = 1;
1478         pdesc->Offset = sizeof(TX_FWINFO_8190PCI) + 8; /* We must add 8!! */
1479         pdesc->PktSize = (u16)skb->len-sizeof(TX_FWINFO_8190PCI);
1480
1481         /*DWORD 1*/
1482         pdesc->SecCAMID = 0;
1483         pdesc->RATid = tcb_desc->RATRIndex;
1484
1485         pdesc->NoEnc = 1;
1486         pdesc->SecType = 0x0;
1487         if (tcb_desc->bHwSec) {
1488                 switch (priv->ieee80211->pairwise_key_type) {
1489                 case KEY_TYPE_WEP40:
1490                 case KEY_TYPE_WEP104:
1491                         pdesc->SecType = 0x1;
1492                         pdesc->NoEnc = 0;
1493                         break;
1494                 case KEY_TYPE_TKIP:
1495                         pdesc->SecType = 0x2;
1496                         pdesc->NoEnc = 0;
1497                         break;
1498                 case KEY_TYPE_CCMP:
1499                         pdesc->SecType = 0x3;
1500                         pdesc->NoEnc = 0;
1501                         break;
1502                 case KEY_TYPE_NA:
1503                         pdesc->SecType = 0x0;
1504                         pdesc->NoEnc = 1;
1505                         break;
1506                 }
1507         }
1508
1509         /* Set Packet ID */
1510         pdesc->PktId = 0x0;
1511
1512         pdesc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1513         pdesc->TxFWInfoSize = sizeof(TX_FWINFO_8190PCI);
1514
1515         pdesc->DISFB = tcb_desc->bTxDisableRateFallBack;
1516         pdesc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1517
1518         pdesc->FirstSeg = 1;
1519         pdesc->LastSeg = 1;
1520         pdesc->TxBufferSize = skb->len;
1521
1522         pdesc->TxBuffAddr = cpu_to_le32(mapping);
1523         __skb_queue_tail(&ring->queue, skb);
1524         pdesc->OWN = 1;
1525         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1526         dev->trans_start = jiffies;
1527         write_nic_word(dev, TPPoll, 0x01<<tcb_desc->queue_index);
1528         return 0;
1529 }
1530
1531 static short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
1532 {
1533     struct r8192_priv *priv = ieee80211_priv(dev);
1534     rx_desc_819x_pci *entry = NULL;
1535     int i;
1536
1537     priv->rx_ring = pci_alloc_consistent(priv->pdev,
1538             sizeof(*priv->rx_ring) * priv->rxringcount, &priv->rx_ring_dma);
1539
1540     if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
1541         RT_TRACE(COMP_ERR,"Cannot allocate RX ring\n");
1542         return -ENOMEM;
1543     }
1544
1545     memset(priv->rx_ring, 0, sizeof(*priv->rx_ring) * priv->rxringcount);
1546     priv->rx_idx = 0;
1547
1548     for (i = 0; i < priv->rxringcount; i++) {
1549         struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
1550         dma_addr_t *mapping;
1551         entry = &priv->rx_ring[i];
1552         if (!skb)
1553             return 0;
1554         priv->rx_buf[i] = skb;
1555         mapping = (dma_addr_t *)skb->cb;
1556         *mapping = pci_map_single(priv->pdev, skb_tail_pointer(skb),
1557                 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1558
1559         entry->BufferAddress = cpu_to_le32(*mapping);
1560
1561         entry->Length = priv->rxbuffersize;
1562         entry->OWN = 1;
1563     }
1564
1565     entry->EOR = 1;
1566     return 0;
1567 }
1568
1569 static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
1570         unsigned int prio, unsigned int entries)
1571 {
1572     struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1573     tx_desc_819x_pci *ring;
1574     dma_addr_t dma;
1575     int i;
1576
1577     ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
1578     if (!ring || (unsigned long)ring & 0xFF) {
1579         RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n", prio);
1580         return -ENOMEM;
1581     }
1582
1583     memset(ring, 0, sizeof(*ring)*entries);
1584     priv->tx_ring[prio].desc = ring;
1585     priv->tx_ring[prio].dma = dma;
1586     priv->tx_ring[prio].idx = 0;
1587     priv->tx_ring[prio].entries = entries;
1588     skb_queue_head_init(&priv->tx_ring[prio].queue);
1589
1590     for (i = 0; i < entries; i++)
1591         ring[i].NextDescAddress =
1592             cpu_to_le32((u32)dma + ((i + 1) % entries) * sizeof(*ring));
1593
1594     return 0;
1595 }
1596
1597 static short rtl8192_pci_initdescring(struct net_device *dev)
1598 {
1599         u32 ret;
1600         int i;
1601         struct r8192_priv *priv = ieee80211_priv(dev);
1602
1603         ret = rtl8192_alloc_rx_desc_ring(dev);
1604         if (ret)
1605                 return ret;
1606
1607         /* general process for other queue */
1608         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1609                 ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount);
1610                 if (ret)
1611                         goto err_free_rings;
1612         }
1613
1614         return 0;
1615
1616 err_free_rings:
1617         rtl8192_free_rx_ring(dev);
1618         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1619                 if (priv->tx_ring[i].desc)
1620                         rtl8192_free_tx_ring(dev, i);
1621         return 1;
1622 }
1623
1624 static void rtl8192_pci_resetdescring(struct net_device *dev)
1625 {
1626     struct r8192_priv *priv = ieee80211_priv(dev);
1627     int i;
1628
1629     /* force the rx_idx to the first one */
1630     if(priv->rx_ring) {
1631         rx_desc_819x_pci *entry = NULL;
1632         for (i = 0; i < priv->rxringcount; i++) {
1633             entry = &priv->rx_ring[i];
1634             entry->OWN = 1;
1635         }
1636         priv->rx_idx = 0;
1637     }
1638
1639     /* after reset, release previous pending packet, and force the
1640      * tx idx to the first one */
1641     for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1642         if (priv->tx_ring[i].desc) {
1643             struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
1644
1645             while (skb_queue_len(&ring->queue)) {
1646                 tx_desc_819x_pci *entry = &ring->desc[ring->idx];
1647                 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1648
1649                 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1650                         skb->len, PCI_DMA_TODEVICE);
1651                 kfree_skb(skb);
1652                 ring->idx = (ring->idx + 1) % ring->entries;
1653             }
1654             ring->idx = 0;
1655         }
1656     }
1657 }
1658
1659 static void rtl8192_link_change(struct net_device *dev)
1660 {
1661         struct r8192_priv *priv = ieee80211_priv(dev);
1662         struct ieee80211_device* ieee = priv->ieee80211;
1663         //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
1664         if (ieee->state == IEEE80211_LINKED)
1665         {
1666                 rtl8192_net_update(dev);
1667                 rtl8192_update_ratr_table(dev);
1668 #if 1
1669                 //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
1670                 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
1671                 EnableHWSecurityConfig8192(dev);
1672 #endif
1673         }
1674         else
1675         {
1676                 write_nic_byte(dev, 0x173, 0);
1677         }
1678         /*update timing params*/
1679         //rtl8192_set_chan(dev, priv->chan);
1680         //MSR
1681         rtl8192_update_msr(dev);
1682
1683         // 2007/10/16 MH MAC Will update TSF according to all received beacon, so we have
1684         //      // To set CBSSID bit when link with any AP or STA.
1685         if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
1686         {
1687                 u32 reg = 0;
1688                 reg = read_nic_dword(dev, RCR);
1689                 if (priv->ieee80211->state == IEEE80211_LINKED)
1690                         priv->ReceiveConfig = reg |= RCR_CBSSID;
1691                 else
1692                         priv->ReceiveConfig = reg &= ~RCR_CBSSID;
1693                 write_nic_dword(dev, RCR, reg);
1694         }
1695 }
1696
1697
1698 static const struct ieee80211_qos_parameters def_qos_parameters = {
1699         {3,3,3,3},/* cw_min */
1700         {7,7,7,7},/* cw_max */
1701         {2,2,2,2},/* aifs */
1702         {0,0,0,0},/* flags */
1703         {0,0,0,0} /* tx_op_limit */
1704 };
1705
1706 static void rtl8192_update_beacon(struct work_struct * work)
1707 {
1708         struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
1709         struct net_device *dev = priv->ieee80211->dev;
1710         struct ieee80211_device* ieee = priv->ieee80211;
1711         struct ieee80211_network* net = &ieee->current_network;
1712
1713         if (ieee->pHTInfo->bCurrentHTSupport)
1714                 HTUpdateSelfAndPeerSetting(ieee, net);
1715         ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
1716         rtl8192_update_cap(dev, net->capability);
1717 }
1718
1719 /*
1720 * background support to run QoS activate functionality
1721 */
1722 static const int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
1723 static void rtl8192_qos_activate(struct work_struct * work)
1724 {
1725         struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
1726         struct net_device *dev = priv->ieee80211->dev;
1727         struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
1728         u8 mode = priv->ieee80211->current_network.mode;
1729         u8  u1bAIFS;
1730         u32 u4bAcParam;
1731         int i;
1732
1733         mutex_lock(&priv->mutex);
1734         if(priv->ieee80211->state != IEEE80211_LINKED)
1735                 goto success;
1736         RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
1737         /* It better set slot time at first */
1738         /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1739         /* update the ac parameter to related registers */
1740         for(i = 0; i <  QOS_QUEUE_NUM; i++) {
1741                 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1742                 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
1743                 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
1744                                 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
1745                                 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
1746                                 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
1747                 //printk("===>u4bAcParam:%x, ", u4bAcParam);
1748                 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
1749                 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
1750         }
1751
1752 success:
1753         mutex_unlock(&priv->mutex);
1754 }
1755
1756 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
1757                 int active_network,
1758                 struct ieee80211_network *network)
1759 {
1760         int ret = 0;
1761         u32 size = sizeof(struct ieee80211_qos_parameters);
1762
1763         if(priv->ieee80211->state !=IEEE80211_LINKED)
1764                 return ret;
1765
1766         if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1767                 return ret;
1768
1769         if (network->flags & NETWORK_HAS_QOS_MASK) {
1770                 if (active_network &&
1771                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
1772                         network->qos_data.active = network->qos_data.supported;
1773
1774                 if ((network->qos_data.active == 1) && (active_network == 1) &&
1775                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
1776                                 (network->qos_data.old_param_count !=
1777                                  network->qos_data.param_count)) {
1778                         network->qos_data.old_param_count =
1779                                 network->qos_data.param_count;
1780                         queue_work(priv->priv_wq, &priv->qos_activate);
1781                         RT_TRACE (COMP_QOS, "QoS parameters change call "
1782                                         "qos_activate\n");
1783                 }
1784         } else {
1785                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1786                        &def_qos_parameters, size);
1787
1788                 if ((network->qos_data.active == 1) && (active_network == 1)) {
1789                         queue_work(priv->priv_wq, &priv->qos_activate);
1790                         RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
1791                 }
1792                 network->qos_data.active = 0;
1793                 network->qos_data.supported = 0;
1794         }
1795
1796         return 0;
1797 }
1798
1799 /* handle manage frame frame beacon and probe response */
1800 static int rtl8192_handle_beacon(struct net_device * dev,
1801                               struct ieee80211_beacon * beacon,
1802                               struct ieee80211_network * network)
1803 {
1804         struct r8192_priv *priv = ieee80211_priv(dev);
1805
1806         rtl8192_qos_handle_probe_response(priv,1,network);
1807
1808         queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
1809         return 0;
1810
1811 }
1812
1813 /*
1814  * handling the beaconing responses. if we get different QoS setting
1815  * off the network from the associated setting, adjust the QoS setting
1816  */
1817 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
1818                                     struct ieee80211_network *network)
1819 {
1820         int ret = 0;
1821         unsigned long flags;
1822         u32 size = sizeof(struct ieee80211_qos_parameters);
1823         int set_qos_param = 0;
1824
1825         if ((priv == NULL) || (network == NULL))
1826                 return ret;
1827
1828         if (priv->ieee80211->state != IEEE80211_LINKED)
1829                 return ret;
1830
1831         if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1832                 return ret;
1833
1834         spin_lock_irqsave(&priv->ieee80211->lock, flags);
1835         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1836                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1837                          &network->qos_data.parameters,
1838                         sizeof(struct ieee80211_qos_parameters));
1839                 priv->ieee80211->current_network.qos_data.active = 1;
1840                 set_qos_param = 1;
1841                 /* update qos parameter for current network */
1842                 priv->ieee80211->current_network.qos_data.old_param_count =
1843                         priv->ieee80211->current_network.qos_data.param_count;
1844                 priv->ieee80211->current_network.qos_data.param_count =
1845                         network->qos_data.param_count;
1846
1847         } else {
1848                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1849                        &def_qos_parameters, size);
1850                 priv->ieee80211->current_network.qos_data.active = 0;
1851                 priv->ieee80211->current_network.qos_data.supported = 0;
1852                 set_qos_param = 1;
1853         }
1854
1855         spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
1856
1857         RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __FUNCTION__,
1858                 network->flags, priv->ieee80211->current_network.qos_data.active);
1859         if (set_qos_param == 1)
1860                 queue_work(priv->priv_wq, &priv->qos_activate);
1861
1862         return ret;
1863 }
1864
1865
1866 static int rtl8192_handle_assoc_response(struct net_device *dev,
1867                                      struct ieee80211_assoc_response_frame *resp,
1868                                      struct ieee80211_network *network)
1869 {
1870         struct r8192_priv *priv = ieee80211_priv(dev);
1871         rtl8192_qos_association_resp(priv, network);
1872         return 0;
1873 }
1874
1875
1876 /* updateRATRTabel for MCS only. Basic rate is not implemented. */
1877 static void rtl8192_update_ratr_table(struct net_device* dev)
1878 {
1879         struct r8192_priv* priv = ieee80211_priv(dev);
1880         struct ieee80211_device* ieee = priv->ieee80211;
1881         u8* pMcsRate = ieee->dot11HTOperationalRateSet;
1882         u32 ratr_value = 0;
1883         u8 rate_index = 0;
1884
1885         rtl8192_config_rate(dev, (u16*)(&ratr_value));
1886         ratr_value |= (*(u16*)(pMcsRate)) << 12;
1887
1888         switch (ieee->mode)
1889         {
1890                 case IEEE_A:
1891                         ratr_value &= 0x00000FF0;
1892                         break;
1893                 case IEEE_B:
1894                         ratr_value &= 0x0000000F;
1895                         break;
1896                 case IEEE_G:
1897                         ratr_value &= 0x00000FF7;
1898                         break;
1899                 case IEEE_N_24G:
1900                 case IEEE_N_5G:
1901                         if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
1902                                 ratr_value &= 0x0007F007;
1903                         else{
1904                                 if (priv->rf_type == RF_1T2R)
1905                                         ratr_value &= 0x000FF007;
1906                                 else
1907                                         ratr_value &= 0x0F81F007;
1908                         }
1909                         break;
1910                 default:
1911                         break;
1912         }
1913         ratr_value &= 0x0FFFFFFF;
1914         if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
1915                 ratr_value |= 0x80000000;
1916         }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
1917                 ratr_value |= 0x80000000;
1918         }
1919         write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
1920         write_nic_byte(dev, UFWP, 1);
1921 }
1922
1923 static bool GetNmodeSupportBySecCfg8190Pci(struct net_device*dev)
1924 {
1925         struct r8192_priv *priv = ieee80211_priv(dev);
1926         struct ieee80211_device *ieee = priv->ieee80211;
1927
1928         return !(ieee->rtllib_ap_sec_type &&
1929                  (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP)));
1930 }
1931
1932 static void rtl8192_refresh_supportrate(struct r8192_priv* priv)
1933 {
1934         struct ieee80211_device* ieee = priv->ieee80211;
1935         //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
1936         if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
1937         {
1938                 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
1939                 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
1940                 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
1941         }
1942         else
1943                 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
1944 }
1945
1946 static u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
1947 {
1948         struct r8192_priv *priv = ieee80211_priv(dev);
1949         u8 ret = 0;
1950         switch(priv->rf_chip)
1951         {
1952                 case RF_8225:
1953                 case RF_8256:
1954                 case RF_PSEUDO_11N:
1955                         ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
1956                         break;
1957                 case RF_8258:
1958                         ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
1959                         break;
1960                 default:
1961                         ret = WIRELESS_MODE_B;
1962                         break;
1963         }
1964         return ret;
1965 }
1966
1967 static void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
1968 {
1969         struct r8192_priv *priv = ieee80211_priv(dev);
1970         u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
1971
1972 #if 1
1973         if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
1974         {
1975                 if(bSupportMode & WIRELESS_MODE_N_24G)
1976                 {
1977                         wireless_mode = WIRELESS_MODE_N_24G;
1978                 }
1979                 else if(bSupportMode & WIRELESS_MODE_N_5G)
1980                 {
1981                         wireless_mode = WIRELESS_MODE_N_5G;
1982                 }
1983                 else if((bSupportMode & WIRELESS_MODE_A))
1984                 {
1985                         wireless_mode = WIRELESS_MODE_A;
1986                 }
1987                 else if((bSupportMode & WIRELESS_MODE_G))
1988                 {
1989                         wireless_mode = WIRELESS_MODE_G;
1990                 }
1991                 else if((bSupportMode & WIRELESS_MODE_B))
1992                 {
1993                         wireless_mode = WIRELESS_MODE_B;
1994                 }
1995                 else{
1996                         RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
1997                         wireless_mode = WIRELESS_MODE_B;
1998                 }
1999         }
2000 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2001         ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2002 #endif
2003         priv->ieee80211->mode = wireless_mode;
2004
2005         if ((wireless_mode == WIRELESS_MODE_N_24G) ||  (wireless_mode == WIRELESS_MODE_N_5G))
2006                 priv->ieee80211->pHTInfo->bEnableHT = 1;
2007         else
2008                 priv->ieee80211->pHTInfo->bEnableHT = 0;
2009         RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2010         rtl8192_refresh_supportrate(priv);
2011 #endif
2012
2013 }
2014
2015 static bool GetHalfNmodeSupportByAPs819xPci(struct net_device* dev)
2016 {
2017         struct r8192_priv* priv = ieee80211_priv(dev);
2018         struct ieee80211_device* ieee = priv->ieee80211;
2019
2020         return ieee->bHalfWirelessN24GMode;
2021 }
2022
2023 short rtl8192_is_tx_queue_empty(struct net_device *dev)
2024 {
2025         int i=0;
2026         struct r8192_priv *priv = ieee80211_priv(dev);
2027         for (i=0; i<=MGNT_QUEUE; i++)
2028         {
2029                 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
2030                         continue;
2031                 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0){
2032                         printk("===>tx queue is not empty:%d, %d\n", i, skb_queue_len(&(&priv->tx_ring[i])->queue));
2033                         return 0;
2034                 }
2035         }
2036         return 1;
2037 }
2038
2039 static void rtl8192_hw_sleep_down(struct net_device *dev)
2040 {
2041         struct r8192_priv *priv = ieee80211_priv(dev);
2042         unsigned long flags = 0;
2043
2044         spin_lock_irqsave(&priv->rf_ps_lock,flags);
2045         if (priv->RFChangeInProgress) {
2046                 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2047                 RT_TRACE(COMP_RF, "rtl8192_hw_sleep_down(): RF Change in progress! \n");
2048                 printk("rtl8192_hw_sleep_down(): RF Change in progress!\n");
2049                 return;
2050         }
2051         spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2052
2053         MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
2054 }
2055
2056 static void rtl8192_hw_sleep_wq (struct work_struct *work)
2057 {
2058         struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2059         struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
2060         struct net_device *dev = ieee->dev;
2061
2062         rtl8192_hw_sleep_down(dev);
2063 }
2064
2065 static void rtl8192_hw_wakeup(struct net_device* dev)
2066 {
2067         struct r8192_priv *priv = ieee80211_priv(dev);
2068         unsigned long flags = 0;
2069
2070         spin_lock_irqsave(&priv->rf_ps_lock,flags);
2071         if (priv->RFChangeInProgress) {
2072                 spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2073                 RT_TRACE(COMP_RF, "rtl8192_hw_wakeup(): RF Change in progress! \n");
2074                 printk("rtl8192_hw_wakeup(): RF Change in progress! schedule wake up task again\n");
2075                 queue_delayed_work(priv->ieee80211->wq,&priv->ieee80211->hw_wakeup_wq,MSECS(10));//PowerSave is not supported if kernel version is below 2.6.20
2076                 return;
2077         }
2078         spin_unlock_irqrestore(&priv->rf_ps_lock,flags);
2079
2080         MgntActSet_RF_State(dev, eRfOn, RF_CHANGE_BY_PS);
2081 }
2082
2083 void rtl8192_hw_wakeup_wq (struct work_struct *work)
2084 {
2085         struct delayed_work *dwork = container_of(work,struct delayed_work,work);
2086         struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
2087         struct net_device *dev = ieee->dev;
2088         rtl8192_hw_wakeup(dev);
2089
2090 }
2091
2092 #define MIN_SLEEP_TIME 50
2093 #define MAX_SLEEP_TIME 10000
2094 static void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
2095 {
2096         struct r8192_priv *priv = ieee80211_priv(dev);
2097
2098         u32 rb = jiffies;
2099         unsigned long flags;
2100
2101         spin_lock_irqsave(&priv->ps_lock,flags);
2102
2103         // Writing HW register with 0 equals to disable
2104         // the timer, that is not really what we want
2105         //
2106         tl -= MSECS(8+16+7);
2107
2108         // If the interval in witch we are requested to sleep is too
2109         // short then give up and remain awake
2110         // when we sleep after send null frame, the timer will be too short to sleep.
2111         //
2112         if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
2113                         ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
2114                 spin_unlock_irqrestore(&priv->ps_lock,flags);
2115                 printk("too short to sleep::%x, %x, %lx\n",tl, rb,  MSECS(MIN_SLEEP_TIME));
2116                 return;
2117         }
2118
2119         if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
2120                         ((tl < rb) && (tl>MSECS(69)) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))||
2121                         ((tl<rb)&&(tl<MSECS(69))&&((tl+0xffffffff-rb)>MSECS(MAX_SLEEP_TIME)))) {
2122                 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb,  MSECS(MAX_SLEEP_TIME));
2123                 spin_unlock_irqrestore(&priv->ps_lock,flags);
2124                 return;
2125         }
2126         {
2127                 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
2128                 queue_delayed_work(priv->ieee80211->wq,
2129                                 &priv->ieee80211->hw_wakeup_wq,tmp);
2130                 //PowerSave not supported when kernel version less 2.6.20
2131         }
2132         queue_delayed_work(priv->ieee80211->wq,
2133                         (void *)&priv->ieee80211->hw_sleep_wq,0);
2134         spin_unlock_irqrestore(&priv->ps_lock,flags);
2135
2136 }
2137
2138 static void rtl8192_init_priv_variable(struct net_device* dev)
2139 {
2140         struct r8192_priv *priv = ieee80211_priv(dev);
2141         u8 i;
2142         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
2143
2144         // Default Halt the NIC if RF is OFF.
2145         pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_HALT_NIC;
2146         pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_CLK_REQ;
2147         pPSC->RegRfPsLevel |= RT_RF_OFF_LEVL_ASPM;
2148         pPSC->RegRfPsLevel |= RT_RF_LPS_LEVEL_ASPM;
2149         pPSC->bLeisurePs = true;
2150         pPSC->RegMaxLPSAwakeIntvl = 5;
2151         priv->bHwRadioOff = false;
2152
2153         priv->being_init_adapter = false;
2154         priv->txbuffsize = 1600;//1024;
2155         priv->txfwbuffersize = 4096;
2156         priv->txringcount = 64;//32;
2157         //priv->txbeaconcount = priv->txringcount;
2158         priv->txbeaconcount = 2;
2159         priv->rxbuffersize = 9100;//2048;//1024;
2160         priv->rxringcount = MAX_RX_COUNT;//64;
2161         priv->irq_enabled=0;
2162         priv->card_8192 = NIC_8192E;
2163         priv->rx_skb_complete = 1;
2164         priv->chan = 1; //set to channel 1
2165         priv->RegWirelessMode = WIRELESS_MODE_AUTO;
2166         priv->RegChannelPlan = 0xf;
2167         priv->nrxAMPDU_size = 0;
2168         priv->nrxAMPDU_aggr_num = 0;
2169         priv->last_rxdesc_tsf_high = 0;
2170         priv->last_rxdesc_tsf_low = 0;
2171         priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2172         priv->ieee80211->iw_mode = IW_MODE_INFRA;
2173         priv->ieee80211->ieee_up=0;
2174         priv->retry_rts = DEFAULT_RETRY_RTS;
2175         priv->retry_data = DEFAULT_RETRY_DATA;
2176         priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2177         priv->ieee80211->rate = 110; //11 mbps
2178         priv->ieee80211->short_slot = 1;
2179         priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2180         priv->bcck_in_ch14 = false;
2181         priv->bfsync_processing  = false;
2182         priv->CCKPresentAttentuation = 0;
2183         priv->rfa_txpowertrackingindex = 0;
2184         priv->rfc_txpowertrackingindex = 0;
2185         priv->CckPwEnl = 6;
2186         priv->ScanDelay = 50;//for Scan TODO
2187         //added by amy for silent reset
2188         priv->ResetProgress = RESET_TYPE_NORESET;
2189         priv->bForcedSilentReset = 0;
2190         priv->bDisableNormalResetCheck = false;
2191         priv->force_reset = false;
2192         //added by amy for power save
2193         priv->RegRfOff = 0;
2194         priv->ieee80211->RfOffReason = 0;
2195         priv->RFChangeInProgress = false;
2196         priv->bHwRfOffAction = 0;
2197         priv->SetRFPowerStateInProgress = false;
2198         priv->ieee80211->PowerSaveControl.bInactivePs = true;
2199         priv->ieee80211->PowerSaveControl.bIPSModeBackup = false;
2200         //just for debug
2201         priv->txpower_checkcnt = 0;
2202         priv->thermal_readback_index =0;
2203         priv->txpower_tracking_callback_cnt = 0;
2204         priv->ccktxpower_adjustcnt_ch14 = 0;
2205         priv->ccktxpower_adjustcnt_not_ch14 = 0;
2206
2207         priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2208         priv->ieee80211->iw_mode = IW_MODE_INFRA;
2209         priv->ieee80211->softmac_features  = IEEE_SOFTMAC_SCAN |
2210                 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2211                 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE;/* |
2212                 IEEE_SOFTMAC_BEACONS;*///added by amy 080604 //|  //IEEE_SOFTMAC_SINGLE_QUEUE;
2213
2214         priv->ieee80211->active_scan = 1;
2215         priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2216         priv->ieee80211->host_encrypt = 1;
2217         priv->ieee80211->host_decrypt = 1;
2218         //priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2219         //priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2220         priv->ieee80211->start_send_beacons = rtl8192_start_beacon;//+by david 081107
2221         priv->ieee80211->stop_send_beacons = rtl8192_stop_beacon;//+by david 081107
2222         priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2223         priv->ieee80211->set_chan = rtl8192_set_chan;
2224         priv->ieee80211->link_change = rtl8192_link_change;
2225         priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2226         priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2227         priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2228         priv->ieee80211->init_wmmparam_flag = 0;
2229         priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2230         priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2231         priv->ieee80211->tx_headroom = sizeof(TX_FWINFO_8190PCI);
2232         priv->ieee80211->qos_support = 1;
2233         priv->ieee80211->dot11PowerSaveMode = 0;
2234         //added by WB
2235 //      priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2236         priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2237         priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2238         priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2239
2240         priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
2241 //      priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
2242         priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
2243         priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
2244         //added by david
2245         priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8190Pci;
2246         priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2247         priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xPci;
2248
2249         //added by amy
2250         priv->ieee80211->InitialGainHandler = InitialGain819xPci;
2251
2252 #ifdef ENABLE_IPS
2253         priv->ieee80211->ieee80211_ips_leave_wq = ieee80211_ips_leave_wq;
2254         priv->ieee80211->ieee80211_ips_leave = ieee80211_ips_leave;
2255 #endif
2256 #ifdef ENABLE_LPS
2257         priv->ieee80211->LeisurePSLeave            = LeisurePSLeave;
2258 #endif
2259
2260         priv->ieee80211->SetHwRegHandler = rtl8192e_SetHwReg;
2261         priv->ieee80211->rtllib_ap_sec_type = rtl8192e_ap_sec_type;
2262
2263         priv->card_type = USB;
2264         {
2265                 priv->ShortRetryLimit = 0x30;
2266                 priv->LongRetryLimit = 0x30;
2267         }
2268         priv->EarlyRxThreshold = 7;
2269         priv->enable_gpio0 = 0;
2270
2271         priv->TransmitConfig = 0;
2272
2273         priv->ReceiveConfig = RCR_ADD3  |
2274                 RCR_AMF | RCR_ADF |             //accept management/data
2275                 RCR_AICV |                      //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2276                 RCR_AB | RCR_AM | RCR_APM |     //accept BC/MC/UC
2277                 RCR_AAP | ((u32)7<<RCR_MXDMA_OFFSET) |
2278                 ((u32)7 << RCR_FIFO_OFFSET) | RCR_ONLYERLPKT;
2279
2280         priv->irq_mask =        (u32)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK |
2281                                 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK |
2282                                 IMR_BDOK | IMR_RXCMDOK | IMR_TIMEOUT0 | IMR_RDU | IMR_RXFOVW |
2283                                 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2284
2285         priv->AcmControl = 0;
2286         priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
2287         if (priv->pFirmware)
2288         memset(priv->pFirmware, 0, sizeof(rt_firmware));
2289
2290         /* rx related queue */
2291         skb_queue_head_init(&priv->rx_queue);
2292         skb_queue_head_init(&priv->skb_queue);
2293
2294         /* Tx related queue */
2295         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2296                 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2297         }
2298         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2299                 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2300         }
2301         priv->rf_set_chan = rtl8192_phy_SwChnl;
2302 }
2303
2304 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2305 {
2306         spin_lock_init(&priv->tx_lock);
2307         spin_lock_init(&priv->irq_lock);//added by thomas
2308         spin_lock_init(&priv->irq_th_lock);
2309         spin_lock_init(&priv->rf_ps_lock);
2310         spin_lock_init(&priv->ps_lock);
2311         //spin_lock_init(&priv->rf_lock);
2312         sema_init(&priv->wx_sem,1);
2313         sema_init(&priv->rf_sem,1);
2314         mutex_init(&priv->mutex);
2315 }
2316
2317 /* init tasklet and wait_queue here */
2318 #define DRV_NAME "wlan0"
2319 static void rtl8192_init_priv_task(struct net_device* dev)
2320 {
2321         struct r8192_priv *priv = ieee80211_priv(dev);
2322
2323 #ifdef PF_SYNCTHREAD
2324         priv->priv_wq = create_workqueue(DRV_NAME,0);
2325 #else
2326         priv->priv_wq = create_workqueue(DRV_NAME);
2327 #endif
2328
2329 #ifdef ENABLE_IPS
2330         INIT_WORK(&priv->ieee80211->ips_leave_wq, (void*)IPSLeave_wq);
2331 #endif
2332
2333 //      INIT_WORK(&priv->reset_wq, (void(*)(void*)) rtl8192_restart);
2334         INIT_WORK(&priv->reset_wq,  rtl8192_restart);
2335 //      INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2336         INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2337         INIT_DELAYED_WORK(&priv->txpower_tracking_wq,  dm_txpower_trackingcallback);
2338         INIT_DELAYED_WORK(&priv->rfpath_check_wq,  dm_rf_pathcheck_workitemcallback);
2339         INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2340         //INIT_WORK(&priv->SwChnlWorkItem,  rtl8192_SwChnl_WorkItem);
2341         //INIT_WORK(&priv->SetBWModeWorkItem,  rtl8192_SetBWModeWorkItem);
2342         INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2343         INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
2344         INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
2345
2346         tasklet_init(&priv->irq_rx_tasklet,
2347              (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2348              (unsigned long)priv);
2349         tasklet_init(&priv->irq_tx_tasklet,
2350              (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
2351              (unsigned long)priv);
2352         tasklet_init(&priv->irq_prepare_beacon_tasklet,
2353                 (void(*)(unsigned long))rtl8192_prepare_beacon,
2354                 (unsigned long)priv);
2355 }
2356
2357 static void rtl8192_get_eeprom_size(struct net_device* dev)
2358 {
2359         u16 curCR = 0;
2360         struct r8192_priv *priv = ieee80211_priv(dev);
2361         RT_TRACE(COMP_INIT, "===========>%s()\n", __FUNCTION__);
2362         curCR = read_nic_dword(dev, EPROM_CMD);
2363         RT_TRACE(COMP_INIT, "read from Reg Cmd9346CR(%x):%x\n", EPROM_CMD, curCR);
2364         //whether need I consider BIT5?
2365         priv->epromtype = (curCR & EPROM_CMD_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2366         RT_TRACE(COMP_INIT, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2367 }
2368
2369 /*
2370  * used to swap endian. as ntohl & htonl are not
2371  * neccessary to swap endian, so use this instead.
2372  */
2373 static inline u16 endian_swap(u16* data)
2374 {
2375         u16 tmp = *data;
2376         *data = (tmp >> 8) | (tmp << 8);
2377         return *data;
2378 }
2379
2380 /*
2381  * Adapter->EEPROMAddressSize should be set before this function call.
2382  *  EEPROM address size can be got through GetEEPROMSize8185()
2383  */
2384 static void rtl8192_read_eeprom_info(struct net_device* dev)
2385 {
2386         struct r8192_priv *priv = ieee80211_priv(dev);
2387
2388         u8                      tempval;
2389 #ifdef RTL8192E
2390         u8                      ICVer8192, ICVer8256;
2391 #endif
2392         u16                     i,usValue, IC_Version;
2393         u16                     EEPROMId;
2394 #ifdef RTL8190P
2395         u8                      offset;
2396         u8                      EepromTxPower[100];
2397 #endif
2398         u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x01};
2399         RT_TRACE(COMP_INIT, "====> rtl8192_read_eeprom_info\n");
2400
2401
2402         // TODO: I don't know if we need to apply EF function to EEPROM read function
2403
2404         //2 Read EEPROM ID to make sure autoload is success
2405         EEPROMId = eprom_read(dev, 0);
2406         if( EEPROMId != RTL8190_EEPROM_ID )
2407         {
2408                 RT_TRACE(COMP_ERR, "EEPROM ID is invalid:%x, %x\n", EEPROMId, RTL8190_EEPROM_ID);
2409                 priv->AutoloadFailFlag=true;
2410         }
2411         else
2412         {
2413                 priv->AutoloadFailFlag=false;
2414         }
2415
2416         //
2417         // Assign Chip Version ID
2418         //
2419         // Read IC Version && Channel Plan
2420         if(!priv->AutoloadFailFlag)
2421         {
2422                 // VID, PID
2423                 priv->eeprom_vid = eprom_read(dev, (EEPROM_VID >> 1));
2424                 priv->eeprom_did = eprom_read(dev, (EEPROM_DID >> 1));
2425
2426                 usValue = eprom_read(dev, (u16)(EEPROM_Customer_ID>>1)) >> 8 ;
2427                 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
2428                 usValue = eprom_read(dev, (EEPROM_ICVersion_ChannelPlan>>1));
2429                 priv->eeprom_ChannelPlan = usValue&0xff;
2430                 IC_Version = ((usValue&0xff00)>>8);
2431
2432 #ifdef RTL8190P
2433                 priv->card_8192_version = (VERSION_8190)(IC_Version);
2434 #else
2435         #ifdef RTL8192E
2436                 ICVer8192 = (IC_Version&0xf);           //bit0~3; 1:A cut, 2:B cut, 3:C cut...
2437                 ICVer8256 = ((IC_Version&0xf0)>>4);//bit4~6, bit7 reserved for other RF chip; 1:A cut, 2:B cut, 3:C cut...
2438                 RT_TRACE(COMP_INIT, "\nICVer8192 = 0x%x\n", ICVer8192);
2439                 RT_TRACE(COMP_INIT, "\nICVer8256 = 0x%x\n", ICVer8256);
2440                 if(ICVer8192 == 0x2)    //B-cut
2441                 {
2442                         if(ICVer8256 == 0x5) //E-cut
2443                                 priv->card_8192_version= VERSION_8190_BE;
2444                 }
2445         #endif
2446 #endif
2447                 switch(priv->card_8192_version)
2448                 {
2449                         case VERSION_8190_BD:
2450                         case VERSION_8190_BE:
2451                                 break;
2452                         default:
2453                                 priv->card_8192_version = VERSION_8190_BD;
2454                                 break;
2455                 }
2456                 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", priv->card_8192_version);
2457         }
2458         else
2459         {
2460                 priv->card_8192_version = VERSION_8190_BD;
2461                 priv->eeprom_vid = 0;
2462                 priv->eeprom_did = 0;
2463                 priv->eeprom_CustomerID = 0;
2464                 priv->eeprom_ChannelPlan = 0;
2465                 RT_TRACE(COMP_INIT, "\nIC Version = 0x%x\n", 0xff);
2466         }
2467
2468         RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
2469         RT_TRACE(COMP_INIT, "EEPROM DID = 0x%4x\n", priv->eeprom_did);
2470         RT_TRACE(COMP_INIT,"EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
2471
2472         //2 Read Permanent MAC address
2473         if(!priv->AutoloadFailFlag)
2474         {
2475                 for(i = 0; i < 6; i += 2)
2476                 {
2477                         usValue = eprom_read(dev, (u16) ((EEPROM_NODE_ADDRESS_BYTE_0+i)>>1));
2478                         *(u16*)(&dev->dev_addr[i]) = usValue;
2479                 }
2480         } else {
2481                 // when auto load failed,  the last address byte set to be a random one.
2482                 // added by david woo.2007/11/7
2483                 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2484         }
2485
2486         RT_TRACE(COMP_INIT, "Permanent Address = %pM\n", dev->dev_addr);
2487
2488                 //2 TX Power Check EEPROM Fail or not
2489         if(priv->card_8192_version > VERSION_8190_BD) {
2490                 priv->bTXPowerDataReadFromEEPORM = true;
2491         } else {
2492                 priv->bTXPowerDataReadFromEEPORM = false;
2493         }
2494
2495         // 2007/11/15 MH 8190PCI Default=2T4R, 8192PCIE default=1T2R
2496         priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
2497
2498         if(priv->card_8192_version > VERSION_8190_BD)
2499         {
2500                 // Read RF-indication and Tx Power gain index diff of legacy to HT OFDM rate.
2501                 if(!priv->AutoloadFailFlag)
2502                 {
2503                         tempval = (eprom_read(dev, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
2504                         priv->EEPROMLegacyHTTxPowerDiff = tempval & 0xf;        // bit[3:0]
2505
2506                         if (tempval&0x80)       //RF-indication, bit[7]
2507                                 priv->rf_type = RF_1T2R;
2508                         else
2509                                 priv->rf_type = RF_2T4R;
2510                 }
2511                 else
2512                 {
2513                         priv->EEPROMLegacyHTTxPowerDiff = EEPROM_Default_LegacyHTTxPowerDiff;
2514                 }
2515                 RT_TRACE(COMP_INIT, "EEPROMLegacyHTTxPowerDiff = %d\n",
2516                         priv->EEPROMLegacyHTTxPowerDiff);
2517
2518                 // Read ThermalMeter from EEPROM
2519                 if(!priv->AutoloadFailFlag)
2520                 {
2521                         priv->EEPROMThermalMeter = (u8)(((eprom_read(dev, (EEPROM_ThermalMeter>>1))) & 0xff00)>>8);
2522                 }
2523                 else
2524                 {
2525                         priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2526                 }
2527                 RT_TRACE(COMP_INIT, "ThermalMeter = %d\n", priv->EEPROMThermalMeter);
2528                 //vivi, for tx power track
2529                 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2530
2531                 if(priv->epromtype == EPROM_93c46)
2532                 {
2533                 // Read antenna tx power offset of B/C/D to A and CrystalCap from EEPROM
2534                 if(!priv->AutoloadFailFlag)
2535                 {
2536                                 usValue = eprom_read(dev, (EEPROM_TxPwDiff_CrystalCap>>1));
2537                                 priv->EEPROMAntPwDiff = (usValue&0x0fff);
2538                                 priv->EEPROMCrystalCap = (u8)((usValue&0xf000)>>12);
2539                 }
2540                 else
2541                 {
2542                                 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2543                                 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2544                 }
2545                         RT_TRACE(COMP_INIT, "EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2546                         RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2547
2548                 //
2549                 // Get per-channel Tx Power Level
2550                 //
2551                 for(i=0; i<14; i+=2)
2552                 {
2553                         if(!priv->AutoloadFailFlag)
2554                         {
2555                                 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_CCK+i)>>1) );
2556                         }
2557                         else
2558                         {
2559                                 usValue = EEPROM_Default_TxPower;
2560                         }
2561                         *((u16*)(&priv->EEPROMTxPowerLevelCCK[i])) = usValue;
2562                         RT_TRACE(COMP_INIT,"CCK Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK[i]);
2563                         RT_TRACE(COMP_INIT, "CCK Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelCCK[i+1]);
2564                 }
2565                 for(i=0; i<14; i+=2)
2566                 {
2567                         if(!priv->AutoloadFailFlag)
2568                         {
2569                                 usValue = eprom_read(dev, (u16) ((EEPROM_TxPwIndex_OFDM_24G+i)>>1) );
2570                         }
2571                         else
2572                         {
2573                                 usValue = EEPROM_Default_TxPower;
2574                         }
2575                         *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[i])) = usValue;
2576                         RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
2577                         RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i+1, priv->EEPROMTxPowerLevelOFDM24G[i+1]);
2578                 }
2579                 }
2580                 else if(priv->epromtype== EPROM_93c56)
2581                 {
2582                 #ifdef RTL8190P
2583                         // Read CrystalCap from EEPROM
2584                         if(!priv->AutoloadFailFlag)
2585                         {
2586                                 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2587                                 priv->EEPROMCrystalCap = (u8)(((eprom_read(dev, (EEPROM_C56_CrystalCap>>1))) & 0xf000)>>12);
2588                         }
2589                         else
2590                         {
2591                                 priv->EEPROMAntPwDiff = EEPROM_Default_AntTxPowerDiff;
2592                                 priv->EEPROMCrystalCap = EEPROM_Default_TxPwDiff_CrystalCap;
2593                         }
2594                         RT_TRACE(COMP_INIT,"EEPROMAntPwDiff = %d\n", priv->EEPROMAntPwDiff);
2595                         RT_TRACE(COMP_INIT, "EEPROMCrystalCap = %d\n", priv->EEPROMCrystalCap);
2596
2597                         // Get Tx Power Level by Channel
2598                         if(!priv->AutoloadFailFlag)
2599                         {
2600                                     // Read Tx power of Channel 1 ~ 14 from EEPROM.
2601                                for(i = 0; i < 12; i+=2)
2602                                 {
2603                                         if (i <6)
2604                                                 offset = EEPROM_C56_RfA_CCK_Chnl1_TxPwIndex + i;
2605                                         else
2606                                                 offset = EEPROM_C56_RfC_CCK_Chnl1_TxPwIndex + i - 6;
2607                                         usValue = eprom_read(dev, (offset>>1));
2608                                        *((u16*)(&EepromTxPower[i])) = usValue;
2609                                 }
2610
2611                                for(i = 0; i < 12; i++)
2612                                 {
2613                                         if (i <= 2)
2614                                                 priv->EEPROMRfACCKChnl1TxPwLevel[i] = EepromTxPower[i];
2615                                         else if ((i >=3 )&&(i <= 5))
2616                                                 priv->EEPROMRfAOfdmChnlTxPwLevel[i-3] = EepromTxPower[i];
2617                                         else if ((i >=6 )&&(i <= 8))
2618                                                 priv->EEPROMRfCCCKChnl1TxPwLevel[i-6] = EepromTxPower[i];
2619                                         else
2620                                                 priv->EEPROMRfCOfdmChnlTxPwLevel[i-9] = EepromTxPower[i];
2621                                 }
2622                         }
2623                         else
2624                         {
2625                                 priv->EEPROMRfACCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2626                                 priv->EEPROMRfACCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2627                                 priv->EEPROMRfACCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2628
2629                                 priv->EEPROMRfAOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2630                                 priv->EEPROMRfAOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2631                                 priv->EEPROMRfAOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2632
2633                                 priv->EEPROMRfCCCKChnl1TxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2634                                 priv->EEPROMRfCCCKChnl1TxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2635                                 priv->EEPROMRfCCCKChnl1TxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2636
2637                                 priv->EEPROMRfCOfdmChnlTxPwLevel[0] = EEPROM_Default_TxPowerLevel;
2638                                 priv->EEPROMRfCOfdmChnlTxPwLevel[1] = EEPROM_Default_TxPowerLevel;
2639                                 priv->EEPROMRfCOfdmChnlTxPwLevel[2] = EEPROM_Default_TxPowerLevel;
2640                         }
2641                         RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[0]);
2642                         RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[1]);
2643                         RT_TRACE(COMP_INIT, "priv->EEPROMRfACCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfACCKChnl1TxPwLevel[2]);
2644                         RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[0]);
2645                         RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[1]);
2646                         RT_TRACE(COMP_INIT, "priv->EEPROMRfAOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfAOfdmChnlTxPwLevel[2]);
2647                         RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[0] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[0]);
2648                         RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[1] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[1]);
2649                         RT_TRACE(COMP_INIT, "priv->EEPROMRfCCCKChnl1TxPwLevel[2] = 0x%x\n", priv->EEPROMRfCCCKChnl1TxPwLevel[2]);
2650                         RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[0] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[0]);
2651                         RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[1] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[1]);
2652                         RT_TRACE(COMP_INIT, "priv->EEPROMRfCOfdmChnlTxPwLevel[2] = 0x%x\n", priv->EEPROMRfCOfdmChnlTxPwLevel[2]);
2653 #endif
2654
2655                 }
2656                 //
2657                 // Update HAL variables.
2658                 //
2659                 if(priv->epromtype == EPROM_93c46)
2660                 {
2661                         for(i=0; i<14; i++)
2662                         {
2663                                 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK[i];
2664                                 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
2665                         }
2666                         priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2667                 // Antenna B gain offset to antenna A, bit0~3
2668                         priv->AntennaTxPwDiff[0] = (priv->EEPROMAntPwDiff & 0xf);
2669                 // Antenna C gain offset to antenna A, bit4~7
2670                         priv->AntennaTxPwDiff[1] = ((priv->EEPROMAntPwDiff & 0xf0)>>4);
2671                 // Antenna D gain offset to antenna A, bit8~11
2672                         priv->AntennaTxPwDiff[2] = ((priv->EEPROMAntPwDiff & 0xf00)>>8);
2673                 // CrystalCap, bit12~15
2674                         priv->CrystalCap = priv->EEPROMCrystalCap;
2675                 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2676                         priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2677                         priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2678                 }
2679                 else if(priv->epromtype == EPROM_93c56)
2680                 {
2681                         //char  cck_pwr_diff_a=0, cck_pwr_diff_c=0;
2682
2683                         //cck_pwr_diff_a = pHalData->EEPROMRfACCKChnl7TxPwLevel - pHalData->EEPROMRfAOfdmChnlTxPwLevel[1];
2684                         //cck_pwr_diff_c = pHalData->EEPROMRfCCCKChnl7TxPwLevel - pHalData->EEPROMRfCOfdmChnlTxPwLevel[1];
2685                         for(i=0; i<3; i++)      // channel 1~3 use the same Tx Power Level.
2686                         {
2687                                 priv->TxPowerLevelCCK_A[i]  = priv->EEPROMRfACCKChnl1TxPwLevel[0];
2688                                 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[0];
2689                                 priv->TxPowerLevelCCK_C[i] =  priv->EEPROMRfCCCKChnl1TxPwLevel[0];
2690                                 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[0];
2691                         }
2692                         for(i=3; i<9; i++)      // channel 4~9 use the same Tx Power Level
2693                         {
2694                                 priv->TxPowerLevelCCK_A[i]  = priv->EEPROMRfACCKChnl1TxPwLevel[1];
2695                                 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[1];
2696                                 priv->TxPowerLevelCCK_C[i] =  priv->EEPROMRfCCCKChnl1TxPwLevel[1];
2697                                 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[1];
2698                         }
2699                         for(i=9; i<14; i++)     // channel 10~14 use the same Tx Power Level
2700                         {
2701                                 priv->TxPowerLevelCCK_A[i]  = priv->EEPROMRfACCKChnl1TxPwLevel[2];
2702                                 priv->TxPowerLevelOFDM24G_A[i] = priv->EEPROMRfAOfdmChnlTxPwLevel[2];
2703                                 priv->TxPowerLevelCCK_C[i] =  priv->EEPROMRfCCCKChnl1TxPwLevel[2];
2704                                 priv->TxPowerLevelOFDM24G_C[i] = priv->EEPROMRfCOfdmChnlTxPwLevel[2];
2705                         }
2706                         for(i=0; i<14; i++)
2707                                 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_A[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_A[i]);
2708                         for(i=0; i<14; i++)
2709                                 RT_TRACE(COMP_INIT,"priv->TxPowerLevelOFDM24G_A[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_A[i]);
2710                         for(i=0; i<14; i++)
2711                                 RT_TRACE(COMP_INIT, "priv->TxPowerLevelCCK_C[%d] = 0x%x\n", i, priv->TxPowerLevelCCK_C[i]);
2712                         for(i=0; i<14; i++)
2713                                 RT_TRACE(COMP_INIT, "priv->TxPowerLevelOFDM24G_C[%d] = 0x%x\n", i, priv->TxPowerLevelOFDM24G_C[i]);
2714                         priv->LegacyHTTxPowerDiff = priv->EEPROMLegacyHTTxPowerDiff;
2715                         priv->AntennaTxPwDiff[0] = 0;
2716                         priv->AntennaTxPwDiff[1] = 0;
2717                         priv->AntennaTxPwDiff[2] = 0;
2718                         priv->CrystalCap = priv->EEPROMCrystalCap;
2719                         // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2720                         priv->ThermalMeter[0] = (priv->EEPROMThermalMeter & 0xf);
2721                         priv->ThermalMeter[1] = ((priv->EEPROMThermalMeter & 0xf0)>>4);
2722                 }
2723         }
2724
2725         if(priv->rf_type == RF_1T2R)
2726         {
2727                 RT_TRACE(COMP_INIT, "\n1T2R config\n");
2728         }
2729         else if (priv->rf_type == RF_2T4R)
2730         {
2731                 RT_TRACE(COMP_INIT, "\n2T4R config\n");
2732         }
2733
2734         // 2008/01/16 MH We can only know RF type in the function. So we have to init
2735         // DIG RATR table again.
2736         init_rate_adaptive(dev);
2737
2738         //1 Make a copy for following variables and we can change them if we want
2739
2740         priv->rf_chip= RF_8256;
2741
2742         if(priv->RegChannelPlan == 0xf)
2743         {
2744                 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2745         }
2746         else
2747         {
2748                 priv->ChannelPlan = priv->RegChannelPlan;
2749         }
2750
2751         //
2752         //  Used PID and DID to Set CustomerID
2753         //
2754         if( priv->eeprom_vid == 0x1186 &&  priv->eeprom_did == 0x3304 )
2755         {
2756                 priv->CustomerID =  RT_CID_DLINK;
2757         }
2758
2759         switch(priv->eeprom_CustomerID)
2760         {
2761                 case EEPROM_CID_DEFAULT:
2762                         priv->CustomerID = RT_CID_DEFAULT;
2763                         break;
2764                 case EEPROM_CID_CAMEO:
2765                         priv->CustomerID = RT_CID_819x_CAMEO;
2766                         break;
2767                 case  EEPROM_CID_RUNTOP:
2768                         priv->CustomerID = RT_CID_819x_RUNTOP;
2769                         break;
2770                 case EEPROM_CID_NetCore:
2771                         priv->CustomerID = RT_CID_819x_Netcore;
2772                         break;
2773                 case EEPROM_CID_TOSHIBA:        // Merge by Jacken, 2008/01/31
2774                         priv->CustomerID = RT_CID_TOSHIBA;
2775                         if(priv->eeprom_ChannelPlan&0x80)
2776                                 priv->ChannelPlan = priv->eeprom_ChannelPlan&0x7f;
2777                         else
2778                                 priv->ChannelPlan = 0x0;
2779                         RT_TRACE(COMP_INIT, "Toshiba ChannelPlan = 0x%x\n",
2780                                 priv->ChannelPlan);
2781                         break;
2782                 case EEPROM_CID_Nettronix:
2783                         priv->ScanDelay = 100;  //cosa add for scan
2784                         priv->CustomerID = RT_CID_Nettronix;
2785                         break;
2786                 case EEPROM_CID_Pronet:
2787                         priv->CustomerID = RT_CID_PRONET;
2788                         break;
2789                 case EEPROM_CID_DLINK:
2790                         priv->CustomerID = RT_CID_DLINK;
2791                         break;
2792
2793                 case EEPROM_CID_WHQL:
2794                         //Adapter->bInHctTest = TRUE;//do not supported
2795
2796                         //priv->bSupportTurboMode = FALSE;
2797                         //priv->bAutoTurboBy8186 = FALSE;
2798
2799                         //pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
2800                         //pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
2801                         //pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
2802
2803                         break;
2804                 default:
2805                         // value from RegCustomerID
2806                         break;
2807         }
2808
2809         //Avoid the channel plan array overflow, by Bruce, 2007-08-27.
2810         if(priv->ChannelPlan > CHANNEL_PLAN_LEN - 1)
2811                 priv->ChannelPlan = 0; //FCC
2812
2813         switch(priv->CustomerID)
2814         {
2815                 case RT_CID_DEFAULT:
2816                 #ifdef RTL8190P
2817                         priv->LedStrategy = HW_LED;
2818                 #else
2819                         #ifdef RTL8192E
2820                         priv->LedStrategy = SW_LED_MODE1;
2821                         #endif
2822                 #endif
2823                         break;
2824
2825                 case RT_CID_819x_CAMEO:
2826                         priv->LedStrategy = SW_LED_MODE2;
2827                         break;
2828
2829                 case RT_CID_819x_RUNTOP:
2830                         priv->LedStrategy = SW_LED_MODE3;
2831                         break;
2832
2833                 case RT_CID_819x_Netcore:
2834                         priv->LedStrategy = SW_LED_MODE4;
2835                         break;
2836
2837                 case RT_CID_Nettronix:
2838                         priv->LedStrategy = SW_LED_MODE5;
2839                         break;
2840
2841                 case RT_CID_PRONET:
2842                         priv->LedStrategy = SW_LED_MODE6;
2843                         break;
2844
2845                 case RT_CID_TOSHIBA:   //Modify by Jacken 2008/01/31
2846                         // Do nothing.
2847                         //break;
2848
2849                 default:
2850                 #ifdef RTL8190P
2851                         priv->LedStrategy = HW_LED;
2852                 #else
2853                         #ifdef RTL8192E
2854                         priv->LedStrategy = SW_LED_MODE1;
2855                         #endif
2856                 #endif
2857                         break;
2858         }
2859
2860
2861         if( priv->eeprom_vid == 0x1186 &&  priv->eeprom_did == 0x3304)
2862                 priv->ieee80211->bSupportRemoteWakeUp = true;
2863         else
2864                 priv->ieee80211->bSupportRemoteWakeUp = false;
2865
2866
2867         RT_TRACE(COMP_INIT, "RegChannelPlan(%d)\n", priv->RegChannelPlan);
2868         RT_TRACE(COMP_INIT, "ChannelPlan = %d \n", priv->ChannelPlan);
2869         RT_TRACE(COMP_INIT, "LedStrategy = %d \n", priv->LedStrategy);
2870         RT_TRACE(COMP_TRACE, "<==== ReadAdapterInfo\n");
2871
2872         return ;
2873 }
2874
2875
2876 static short rtl8192_get_channel_map(struct net_device * dev)
2877 {
2878         struct r8192_priv *priv = ieee80211_priv(dev);
2879 #ifdef ENABLE_DOT11D
2880         if(priv->ChannelPlan> COUNTRY_CODE_GLOBAL_DOMAIN){
2881                 printk("rtl8180_init:Error channel plan! Set to default.\n");
2882                 priv->ChannelPlan= 0;
2883         }
2884         RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
2885
2886         rtl819x_set_channel_map(priv->ChannelPlan, priv);
2887 #else
2888         int ch,i;
2889         //Set Default Channel Plan
2890         if(!channels){
2891                 DMESG("No channels, aborting");
2892                 return -1;
2893         }
2894         ch=channels;
2895         priv->ChannelPlan= 0;//hikaru
2896          // set channels 1..14 allowed in given locale
2897         for (i=1; i<=14; i++) {
2898                 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
2899                 ch >>= 1;
2900         }
2901 #endif
2902         return 0;
2903 }
2904
2905 static short rtl8192_init(struct net_device *dev)
2906 {
2907         struct r8192_priv *priv = ieee80211_priv(dev);
2908         memset(&(priv->stats),0,sizeof(struct Stats));
2909         rtl8192_init_priv_variable(dev);
2910         rtl8192_init_priv_lock(priv);
2911         rtl8192_init_priv_task(dev);
2912         rtl8192_get_eeprom_size(dev);
2913         rtl8192_read_eeprom_info(dev);
2914         rtl8192_get_channel_map(dev);
2915         init_hal_dm(dev);
2916         init_timer(&priv->watch_dog_timer);
2917         priv->watch_dog_timer.data = (unsigned long)dev;
2918         priv->watch_dog_timer.function = watch_dog_timer_callback;
2919 #if defined(IRQF_SHARED)
2920         if(request_irq(dev->irq, (void*)rtl8192_interrupt, IRQF_SHARED, dev->name, dev)){
2921 #else
2922         if(request_irq(dev->irq, (void *)rtl8192_interrupt, SA_SHIRQ, dev->name, dev)){
2923 #endif
2924                 printk("Error allocating IRQ %d",dev->irq);
2925                 return -1;
2926         }else{
2927                 priv->irq=dev->irq;
2928                 printk("IRQ %d",dev->irq);
2929         }
2930         if(rtl8192_pci_initdescring(dev)!=0){
2931                 printk("Endopoints initialization failed");
2932                 return -1;
2933         }
2934
2935         //rtl8192_rx_enable(dev);
2936         //rtl8192_adapter_start(dev);
2937         return 0;
2938 }
2939
2940 /*
2941  * Actually only set RRSR, RATR and BW_OPMODE registers
2942  *  not to do all the hw config as its name says
2943  * This part need to modified according to the rate set we filtered
2944  */
2945 static void rtl8192_hwconfig(struct net_device* dev)
2946 {
2947         u32 regRATR = 0, regRRSR = 0;
2948         u8 regBwOpMode = 0, regTmp = 0;
2949         struct r8192_priv *priv = ieee80211_priv(dev);
2950
2951 // Set RRSR, RATR, and BW_OPMODE registers
2952         //
2953         switch(priv->ieee80211->mode)
2954         {
2955         case WIRELESS_MODE_B:
2956                 regBwOpMode = BW_OPMODE_20MHZ;
2957                 regRATR = RATE_ALL_CCK;
2958                 regRRSR = RATE_ALL_CCK;
2959                 break;
2960         case WIRELESS_MODE_A:
2961                 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
2962                 regRATR = RATE_ALL_OFDM_AG;
2963                 regRRSR = RATE_ALL_OFDM_AG;
2964                 break;
2965         case WIRELESS_MODE_G:
2966                 regBwOpMode = BW_OPMODE_20MHZ;
2967                 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2968                 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2969                 break;
2970         case WIRELESS_MODE_AUTO:
2971         case WIRELESS_MODE_N_24G:
2972                 // It support CCK rate by default.
2973                 // CCK rate will be filtered out only when associated AP does not support it.
2974                 regBwOpMode = BW_OPMODE_20MHZ;
2975                         regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2976                         regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2977                 break;
2978         case WIRELESS_MODE_N_5G:
2979                 regBwOpMode = BW_OPMODE_5G;
2980                 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2981                 regRRSR = RATE_ALL_OFDM_AG;
2982                 break;
2983         }
2984
2985         write_nic_byte(dev, BW_OPMODE, regBwOpMode);
2986         {
2987                 u32 ratr_value = 0;
2988                 ratr_value = regRATR;
2989                 if (priv->rf_type == RF_1T2R)
2990                 {
2991                         ratr_value &= ~(RATE_ALL_OFDM_2SS);
2992                 }
2993                 write_nic_dword(dev, RATR0, ratr_value);
2994                 write_nic_byte(dev, UFWP, 1);
2995         }
2996         regTmp = read_nic_byte(dev, 0x313);
2997         regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2998         write_nic_dword(dev, RRSR, regRRSR);
2999
3000         //
3001         // Set Retry Limit here
3002         //
3003         write_nic_word(dev, RETRY_LIMIT,
3004                         priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
3005                         priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3006         // Set Contention Window here
3007
3008         // Set Tx AGC
3009
3010         // Set Tx Antenna including Feedback control
3011
3012         // Set Auto Rate fallback control
3013
3014
3015 }
3016
3017
3018 static RT_STATUS rtl8192_adapter_start(struct net_device *dev)
3019 {
3020         struct r8192_priv *priv = ieee80211_priv(dev);
3021 //      struct ieee80211_device *ieee = priv->ieee80211;
3022         u32 ulRegRead;
3023         RT_STATUS rtStatus = RT_STATUS_SUCCESS;
3024         //u8 eRFPath;
3025         u8 tmpvalue;
3026 #ifdef RTL8192E
3027         u8 ICVersion,SwitchingRegulatorOutput;
3028 #endif
3029         bool bfirmwareok = true;
3030 #ifdef RTL8190P
3031         u8 ucRegRead;
3032 #endif
3033         u32     tmpRegA, tmpRegC, TempCCk;
3034         int     i =0;
3035
3036         RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3037         priv->being_init_adapter = true;
3038         rtl8192_pci_resetdescring(dev);
3039         // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
3040         priv->Rf_Mode = RF_OP_By_SW_3wire;
3041 #ifdef RTL8192E
3042         //dPLL on
3043         if(priv->ResetProgress == RESET_TYPE_NORESET)
3044         {
3045             write_nic_byte(dev, ANAPAR, 0x37);
3046             // Accordign to designer's explain, LBUS active will never > 10ms. We delay 10ms
3047             // Joseph increae the time to prevent firmware download fail
3048             mdelay(500);
3049         }
3050 #endif
3051         //PlatformSleepUs(10000);
3052         // For any kind of InitializeAdapter process, we shall use system now!!
3053         priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3054
3055         // Set to eRfoff in order not to count receive count.
3056         if(priv->RegRfOff == TRUE)
3057                 priv->ieee80211->eRFPowerState = eRfOff;
3058
3059         //
3060         //3 //Config CPUReset Register
3061         //3//
3062         //3 Firmware Reset Or Not
3063         ulRegRead = read_nic_dword(dev, CPU_GEN);
3064         if(priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3065         {       //called from MPInitialized. do nothing
3066                 ulRegRead |= CPU_GEN_SYSTEM_RESET;
3067         }else if(priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3068                 ulRegRead |= CPU_GEN_FIRMWARE_RESET;    // Called from MPReset
3069         else
3070                 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__,   priv->pFirmware->firmware_status);
3071
3072 #ifdef RTL8190P
3073         //2008.06.03, for WOL 90 hw bug
3074         ulRegRead &= (~(CPU_GEN_GPIO_UART));
3075 #endif
3076
3077         write_nic_dword(dev, CPU_GEN, ulRegRead);
3078         //mdelay(100);
3079
3080 #ifdef RTL8192E
3081
3082         //3//
3083         //3 //Fix the issue of E-cut high temperature issue
3084         //3//
3085         // TODO: E cut only
3086         ICVersion = read_nic_byte(dev, IC_VERRSION);
3087         if(ICVersion >= 0x4) //E-cut only
3088         {
3089                 // HW SD suggest that we should not wirte this register too often, so driver
3090                 // should readback this register. This register will be modified only when
3091                 // power on reset
3092                 SwitchingRegulatorOutput = read_nic_byte(dev, SWREGULATOR);
3093                 if(SwitchingRegulatorOutput  != 0xb8)
3094                 {
3095                         write_nic_byte(dev, SWREGULATOR, 0xa8);
3096                         mdelay(1);
3097                         write_nic_byte(dev, SWREGULATOR, 0xb8);
3098                 }
3099         }
3100 #endif
3101
3102
3103         //3//
3104         //3// Initialize BB before MAC
3105         //3//
3106         RT_TRACE(COMP_INIT, "BB Config Start!\n");
3107         rtStatus = rtl8192_BBConfig(dev);
3108         if(rtStatus != RT_STATUS_SUCCESS)
3109         {
3110                 RT_TRACE(COMP_ERR, "BB Config failed\n");
3111                 return rtStatus;
3112         }
3113         RT_TRACE(COMP_INIT,"BB Config Finished!\n");
3114
3115         //3//Set Loopback mode or Normal mode
3116         //3//
3117         //2006.12.13 by emily. Note!We should not merge these two CPU_GEN register writings
3118         //      because setting of System_Reset bit reset MAC to default transmission mode.
3119                 //Loopback mode or not
3120         priv->LoopbackMode = RTL819X_NO_LOOPBACK;
3121         //priv->LoopbackMode = RTL819X_MAC_LOOPBACK;
3122         if(priv->ResetProgress == RESET_TYPE_NORESET)
3123         {
3124         ulRegRead = read_nic_dword(dev, CPU_GEN);
3125         if(priv->LoopbackMode == RTL819X_NO_LOOPBACK)
3126         {
3127                 ulRegRead = ((ulRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3128         }
3129         else if (priv->LoopbackMode == RTL819X_MAC_LOOPBACK )
3130         {
3131                 ulRegRead |= CPU_CCK_LOOPBACK;
3132         }
3133         else
3134         {
3135                 RT_TRACE(COMP_ERR,"Serious error: wrong loopback mode setting\n");
3136         }
3137
3138         //2008.06.03, for WOL
3139         //ulRegRead &= (~(CPU_GEN_GPIO_UART));
3140         write_nic_dword(dev, CPU_GEN, ulRegRead);
3141
3142         // 2006.11.29. After reset cpu, we sholud wait for a second, otherwise, it may fail to write registers. Emily
3143         udelay(500);
3144         }
3145         //3Set Hardware(Do nothing now)
3146         rtl8192_hwconfig(dev);
3147         //2=======================================================
3148         // Common Setting for all of the FPGA platform. (part 1)
3149         //2=======================================================
3150         // If there is changes, please make sure it applies to all of the FPGA version
3151         //3 Turn on Tx/Rx
3152         write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3153
3154         //2Set Tx dma burst
3155 #ifdef RTL8190P
3156         write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3157                         (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) |
3158                         (1<<MULRW_SHIFT)));
3159 #else
3160         #ifdef RTL8192E
3161         write_nic_byte(dev, PCIF, ((MXDMA2_NoLimit<<MXDMA2_RX_SHIFT) |
3162                                    (MXDMA2_NoLimit<<MXDMA2_TX_SHIFT) ));
3163         #endif
3164 #endif
3165         //set IDR0 here
3166         write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3167         write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3168         //set RCR
3169         write_nic_dword(dev, RCR, priv->ReceiveConfig);
3170
3171         //3 Initialize Number of Reserved Pages in Firmware Queue
3172         #ifdef TO_DO_LIST
3173         if(priv->bInHctTest)
3174         {
3175                 PlatformEFIOWrite4Byte(Adapter, RQPN1,  NUM_OF_PAGE_IN_FW_QUEUE_BK_DTM << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3176                                         NUM_OF_PAGE_IN_FW_QUEUE_BE_DTM << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3177                                         NUM_OF_PAGE_IN_FW_QUEUE_VI_DTM << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3178                                         NUM_OF_PAGE_IN_FW_QUEUE_VO_DTM <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3179                 PlatformEFIOWrite4Byte(Adapter, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3180                 PlatformEFIOWrite4Byte(Adapter, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3181                                         NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3182                                         NUM_OF_PAGE_IN_FW_QUEUE_PUB_DTM<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3183         }
3184         else
3185         #endif
3186         {
3187                 write_nic_dword(dev, RQPN1,  NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
3188                                         NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
3189                                         NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
3190                                         NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3191                 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT);
3192                 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
3193                                         NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT|
3194                                         NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT);
3195         }
3196
3197         rtl8192_tx_enable(dev);
3198         rtl8192_rx_enable(dev);
3199         //3Set Response Rate Setting Register
3200         // CCK rate is supported by default.
3201         // CCK rate will be filtered out only when associated AP does not support it.
3202         ulRegRead = (0xFFF00000 & read_nic_dword(dev, RRSR))  | RATE_ALL_OFDM_AG | RATE_ALL_CCK;
3203         write_nic_dword(dev, RRSR, ulRegRead);
3204         write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3205
3206         //2Set AckTimeout
3207         // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3208         write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3209
3210         //rtl8192_actset_wirelessmode(dev,priv->RegWirelessMode);
3211         if(priv->ResetProgress == RESET_TYPE_NORESET)
3212         rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3213         //-----------------------------------------------------------------------------
3214         // Set up security related. 070106, by rcnjko:
3215         // 1. Clear all H/W keys.
3216         // 2. Enable H/W encryption/decryption.
3217         //-----------------------------------------------------------------------------
3218         CamResetAllEntry(dev);
3219         {
3220                 u8 SECR_value = 0x0;
3221                 SECR_value |= SCR_TxEncEnable;
3222                 SECR_value |= SCR_RxDecEnable;
3223                 SECR_value |= SCR_NoSKMC;
3224                 write_nic_byte(dev, SECR, SECR_value);
3225         }
3226         //3Beacon related
3227         write_nic_word(dev, ATIMWND, 2);
3228         write_nic_word(dev, BCN_INTERVAL, 100);
3229         for (i=0; i<QOS_QUEUE_NUM; i++)
3230                 write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
3231         //
3232         // Switching regulator controller: This is set temporarily.
3233         // It's not sure if this can be removed in the future.
3234         // PJ advised to leave it by default.
3235         //
3236         write_nic_byte(dev, 0xbe, 0xc0);
3237
3238         //2=======================================================
3239         // Set PHY related configuration defined in MAC register bank
3240         //2=======================================================
3241         rtl8192_phy_configmac(dev);
3242
3243         if (priv->card_8192_version > (u8) VERSION_8190_BD) {
3244                 rtl8192_phy_getTxPower(dev);
3245                 rtl8192_phy_setTxPower(dev, priv->chan);
3246         }
3247
3248         //if D or C cut
3249                 tmpvalue = read_nic_byte(dev, IC_VERRSION);
3250                 priv->IC_Cut = tmpvalue;
3251                 RT_TRACE(COMP_INIT, "priv->IC_Cut = 0x%x\n", priv->IC_Cut);
3252                 if(priv->IC_Cut >= IC_VersionCut_D)
3253                 {
3254                         //pHalData->bDcut = TRUE;
3255                         if(priv->IC_Cut == IC_VersionCut_D)
3256                                 RT_TRACE(COMP_INIT, "D-cut\n");
3257                         if(priv->IC_Cut == IC_VersionCut_E)
3258                         {
3259                                 RT_TRACE(COMP_INIT, "E-cut\n");
3260                                 // HW SD suggest that we should not wirte this register too often, so driver
3261                                 // should readback this register. This register will be modified only when
3262                                 // power on reset
3263                         }
3264                 }
3265                 else
3266                 {
3267                         //pHalData->bDcut = FALSE;
3268                         RT_TRACE(COMP_INIT, "Before C-cut\n");
3269                 }
3270
3271 #if 1
3272         //Firmware download
3273         RT_TRACE(COMP_INIT, "Load Firmware!\n");
3274         bfirmwareok = init_firmware(dev);
3275         if(bfirmwareok != true) {
3276                 rtStatus = RT_STATUS_FAILURE;
3277                 return rtStatus;
3278         }
3279         RT_TRACE(COMP_INIT, "Load Firmware finished!\n");
3280 #endif
3281         //RF config
3282         if(priv->ResetProgress == RESET_TYPE_NORESET)
3283         {
3284         RT_TRACE(COMP_INIT, "RF Config Started!\n");
3285         rtStatus = rtl8192_phy_RFConfig(dev);
3286         if(rtStatus != RT_STATUS_SUCCESS)
3287         {
3288                 RT_TRACE(COMP_ERR, "RF Config failed\n");
3289                         return rtStatus;
3290         }
3291         RT_TRACE(COMP_INIT, "RF Config Finished!\n");
3292         }
3293         rtl8192_phy_updateInitGain(dev);
3294
3295         /*---- Set CCK and OFDM Block "ON"----*/
3296         rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3297         rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3298
3299 #ifdef RTL8192E
3300         //Enable Led
3301         write_nic_byte(dev, 0x87, 0x0);
3302 #endif
3303 #ifdef RTL8190P
3304         //2008.06.03, for WOL
3305         ucRegRead = read_nic_byte(dev, GPE);
3306         ucRegRead |= BIT0;
3307         write_nic_byte(dev, GPE, ucRegRead);
3308
3309         ucRegRead = read_nic_byte(dev, GPO);
3310         ucRegRead &= ~BIT0;
3311         write_nic_byte(dev, GPO, ucRegRead);
3312 #endif
3313
3314         //2=======================================================
3315         // RF Power Save
3316         //2=======================================================
3317 #ifdef ENABLE_IPS
3318
3319 {
3320         if(priv->RegRfOff == TRUE)
3321         { // User disable RF via registry.
3322                 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RegRfOff ----------\n",__FUNCTION__);
3323                 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
3324 #if 0//cosa, ask SD3 willis and he doesn't know what is this for
3325                 // Those action will be discard in MgntActSet_RF_State because off the same state
3326         for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3327                 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3328 #endif
3329         }
3330         else if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_PS)
3331         { // H/W or S/W RF OFF before sleep.
3332                 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3333                 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3334         }
3335         else if(priv->ieee80211->RfOffReason >= RF_CHANGE_BY_IPS)
3336         { // H/W or S/W RF OFF before sleep.
3337                 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): Turn off RF for RfOffReason(%d) ----------\n", __FUNCTION__,priv->ieee80211->RfOffReason);
3338                 MgntActSet_RF_State(dev, eRfOff, priv->ieee80211->RfOffReason);
3339         }
3340         else
3341         {
3342                 RT_TRACE((COMP_INIT|COMP_RF|COMP_POWER), "%s(): RF-ON \n",__FUNCTION__);
3343                 priv->ieee80211->eRFPowerState = eRfOn;
3344                 priv->ieee80211->RfOffReason = 0;
3345                 //DrvIFIndicateCurrentPhyStatus(Adapter);
3346         // LED control
3347         //Adapter->HalFunc.LedControlHandler(Adapter, LED_CTL_POWER_ON);
3348
3349         //
3350         // If inactive power mode is enabled, disable rf while in disconnected state.
3351         // But we should still tell upper layer we are in rf on state.
3352         // 2007.07.16, by shien chang.
3353         //
3354                 //if(!Adapter->bInHctTest)
3355         //IPSEnter(Adapter);
3356
3357         }
3358 }
3359 #endif
3360         if(1){
3361 #ifdef RTL8192E
3362                         // We can force firmware to do RF-R/W
3363                         if(priv->ieee80211->FwRWRF)
3364                                 priv->Rf_Mode = RF_OP_By_FW;
3365                         else
3366                                 priv->Rf_Mode = RF_OP_By_SW_3wire;
3367 #else
3368                         priv->Rf_Mode = RF_OP_By_SW_3wire;
3369 #endif
3370         }
3371 #ifdef RTL8190P
3372         if(priv->ResetProgress == RESET_TYPE_NORESET)
3373         {
3374                 dm_initialize_txpower_tracking(dev);
3375
3376                 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3377                 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3378
3379                 if(priv->rf_type == RF_2T4R){
3380                 for(i = 0; i<TxBBGainTableLength; i++)
3381                 {
3382                         if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3383                         {
3384                                 priv->rfa_txpowertrackingindex= (u8)i;
3385                                 priv->rfa_txpowertrackingindex_real= (u8)i;
3386                                 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3387                                 break;
3388                         }
3389                 }
3390                 }
3391                 for(i = 0; i<TxBBGainTableLength; i++)
3392                 {
3393                         if(tmpRegC == priv->txbbgain_table[i].txbbgain_value)
3394                         {
3395                                 priv->rfc_txpowertrackingindex= (u8)i;
3396                                 priv->rfc_txpowertrackingindex_real= (u8)i;
3397                                 priv->rfc_txpowertracking_default = priv->rfc_txpowertrackingindex;
3398                                 break;
3399                         }
3400                 }
3401                 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3402
3403                 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3404                 {
3405                         if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3406                         {
3407                                 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3408                                 break;
3409                         }
3410                 }
3411                 priv->CCKPresentAttentuation_40Mdefault = 0;
3412                 priv->CCKPresentAttentuation_difference = 0;
3413                 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3414                 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3415                 RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3416                 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_initial = %d\n", priv->rfc_txpowertrackingindex);
3417                 RT_TRACE(COMP_POWER_TRACKING, "priv->rfc_txpowertrackingindex_real_initial = %d\n", priv->rfc_txpowertrackingindex_real);
3418                 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3419                 RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3420         }
3421 #else
3422         #ifdef RTL8192E
3423         if(priv->ResetProgress == RESET_TYPE_NORESET)
3424         {
3425                 dm_initialize_txpower_tracking(dev);
3426
3427                 if(priv->IC_Cut >= IC_VersionCut_D)
3428                 {
3429                         tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3430                         tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3431                         for(i = 0; i<TxBBGainTableLength; i++)
3432                         {
3433                                 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3434                                 {
3435                                         priv->rfa_txpowertrackingindex= (u8)i;
3436                                         priv->rfa_txpowertrackingindex_real= (u8)i;
3437                                         priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
3438                                         break;
3439                                 }
3440                         }
3441
3442                 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3443
3444                 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3445                 {
3446                         if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3447                         {
3448                                 priv->CCKPresentAttentuation_20Mdefault =(u8) i;
3449                                 break;
3450                         }
3451                 }
3452                 priv->CCKPresentAttentuation_40Mdefault = 0;
3453                 priv->CCKPresentAttentuation_difference = 0;
3454                 priv->CCKPresentAttentuation = priv->CCKPresentAttentuation_20Mdefault;
3455                         RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_initial = %d\n", priv->rfa_txpowertrackingindex);
3456                         RT_TRACE(COMP_POWER_TRACKING, "priv->rfa_txpowertrackingindex_real__initial = %d\n", priv->rfa_txpowertrackingindex_real);
3457                         RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_difference_initial = %d\n", priv->CCKPresentAttentuation_difference);
3458                         RT_TRACE(COMP_POWER_TRACKING, "priv->CCKPresentAttentuation_initial = %d\n", priv->CCKPresentAttentuation);
3459                         priv->btxpower_tracking = FALSE;//TEMPLY DISABLE
3460                 }
3461         }
3462         #endif
3463 #endif
3464         rtl8192_irq_enable(dev);
3465         priv->being_init_adapter = false;
3466         return rtStatus;
3467
3468 }
3469
3470 static void rtl8192_prepare_beacon(struct r8192_priv *priv)
3471 {
3472         struct sk_buff *skb;
3473         //unsigned long flags;
3474         cb_desc *tcb_desc;
3475
3476         skb = ieee80211_get_beacon(priv->ieee80211);
3477         tcb_desc = (cb_desc *)(skb->cb + 8);
3478         //spin_lock_irqsave(&priv->tx_lock,flags);
3479         /* prepare misc info for the beacon xmit */
3480         tcb_desc->queue_index = BEACON_QUEUE;
3481         /* IBSS does not support HT yet, use 1M defaultly */
3482         tcb_desc->data_rate = 2;
3483         tcb_desc->RATRIndex = 7;
3484         tcb_desc->bTxDisableRateFallBack = 1;
3485         tcb_desc->bTxUseDriverAssingedRate = 1;
3486
3487         skb_push(skb, priv->ieee80211->tx_headroom);
3488         if(skb){
3489                 rtl8192_tx(priv->ieee80211->dev,skb);
3490         }
3491         //spin_unlock_irqrestore (&priv->tx_lock, flags);
3492 }
3493
3494
3495 /*
3496  * configure registers for beacon tx and enables it via
3497  * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3498  * be used to stop beacon transmission
3499  */
3500 static void rtl8192_start_beacon(struct net_device *dev)
3501 {
3502         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3503         struct ieee80211_network *net = &priv->ieee80211->current_network;
3504         u16 BcnTimeCfg = 0;
3505         u16 BcnCW = 6;
3506         u16 BcnIFS = 0xf;
3507
3508         DMESG("Enabling beacon TX");
3509         //rtl8192_prepare_beacon(dev);
3510         rtl8192_irq_disable(dev);
3511         //rtl8192_beacon_tx_enable(dev);
3512
3513         /* ATIM window */
3514         write_nic_word(dev, ATIMWND, 2);
3515
3516         /* Beacon interval (in unit of TU) */
3517         write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
3518
3519         /*
3520          * DrvErlyInt (in unit of TU).
3521          * (Time to send interrupt to notify driver to c
3522          * hange beacon content)
3523          * */
3524         write_nic_word(dev, BCN_DRV_EARLY_INT, 10);
3525
3526         /*
3527          * BcnDMATIM(in unit of us).
3528          * Indicates the time before TBTT to perform beacon queue DMA
3529          * */
3530         write_nic_word(dev, BCN_DMATIME, 256);
3531
3532         /*
3533          * Force beacon frame transmission even after receiving
3534          * beacon frame from other ad hoc STA
3535          * */
3536         write_nic_byte(dev, BCN_ERR_THRESH, 100);
3537
3538         /* Set CW and IFS */
3539         BcnTimeCfg |= BcnCW<<BCN_TCFG_CW_SHIFT;
3540         BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
3541         write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
3542
3543
3544         /* enable the interrupt for ad-hoc process */
3545         rtl8192_irq_enable(dev);
3546 }
3547
3548 static bool HalTxCheckStuck8190Pci(struct net_device *dev)
3549 {
3550         u16                             RegTxCounter = read_nic_word(dev, 0x128);
3551         struct r8192_priv *priv = ieee80211_priv(dev);
3552         bool                            bStuck = FALSE;
3553         RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3554         if(priv->TxCounter==RegTxCounter)
3555                 bStuck = TRUE;
3556
3557         priv->TxCounter = RegTxCounter;
3558
3559         return bStuck;
3560 }
3561
3562 /*
3563  * Assumption: RT_TX_SPINLOCK is acquired.
3564  */
3565 static RESET_TYPE
3566 TxCheckStuck(struct net_device *dev)
3567 {
3568         struct r8192_priv *priv = ieee80211_priv(dev);
3569         u8                      QueueID;
3570         ptx_ring                head=NULL,tail=NULL,txring = NULL;
3571         u8                      ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3572         bool                    bCheckFwTxCnt = false;
3573
3574         //
3575         // Decide Stuch threshold according to current power save mode
3576         //
3577         switch (priv->ieee80211->dot11PowerSaveMode)
3578         {
3579                 // The threshold value  may required to be adjusted .
3580                 case eActive:           // Active/Continuous access.
3581                         ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
3582                         break;
3583                 case eMaxPs:            // Max power save mode.
3584                         ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3585                         break;
3586                 case eFastPs:   // Fast power save mode.
3587                         ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
3588                         break;
3589         }
3590
3591         //
3592         // Check whether specific tcb has been queued for a specific time
3593         //
3594         for(QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++)
3595         {
3596
3597
3598                 if(QueueID == TXCMD_QUEUE)
3599                         continue;
3600
3601                 switch(QueueID) {
3602                 case MGNT_QUEUE:
3603                         tail=priv->txmapringtail;
3604                         head=priv->txmapringhead;
3605                         break;
3606
3607                 case BK_QUEUE:
3608                         tail=priv->txbkpringtail;
3609                         head=priv->txbkpringhead;
3610                         break;
3611
3612                 case BE_QUEUE:
3613                         tail=priv->txbepringtail;
3614                         head=priv->txbepringhead;
3615                         break;
3616
3617                 case VI_QUEUE:
3618                         tail=priv->txvipringtail;
3619                         head=priv->txvipringhead;
3620                         break;
3621
3622                 case VO_QUEUE:
3623                         tail=priv->txvopringtail;
3624                         head=priv->txvopringhead;
3625                         break;
3626
3627                 default:
3628                         tail=head=NULL;
3629                         break;
3630                 }
3631
3632                 if(tail == head)
3633                         continue;
3634                 else
3635                 {
3636                         txring = head;
3637                         if(txring == NULL)
3638                         {
3639                                 RT_TRACE(COMP_ERR,"%s():txring is NULL , BUG!\n",__FUNCTION__);
3640                                 continue;
3641                         }
3642                         txring->nStuckCount++;
3643                         bCheckFwTxCnt = TRUE;
3644                 }
3645         }
3646 #if 1
3647         if(bCheckFwTxCnt)
3648         {
3649                 if(HalTxCheckStuck8190Pci(dev))
3650                 {
3651                         RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3652                         return RESET_TYPE_SILENT;
3653                 }
3654         }
3655 #endif
3656         return RESET_TYPE_NORESET;
3657 }
3658
3659
3660 static bool HalRxCheckStuck8190Pci(struct net_device *dev)
3661 {
3662         struct r8192_priv *priv = ieee80211_priv(dev);
3663         u16                             RegRxCounter = read_nic_word(dev, 0x130);
3664         bool                            bStuck = FALSE;
3665         static u8                       rx_chk_cnt = 0;
3666         RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3667         // If rssi is small, we should check rx for long time because of bad rx.
3668         // or maybe it will continuous silent reset every 2 seconds.
3669         rx_chk_cnt++;
3670         if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3671         {
3672                 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3673         }
3674         else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3675                 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3676                 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3677
3678         {
3679                 if(rx_chk_cnt < 2)
3680                 {
3681                         return bStuck;
3682                 }
3683                 else
3684                 {
3685                         rx_chk_cnt = 0;
3686                 }
3687         }
3688         else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3689                 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3690                 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3691         {
3692                 if(rx_chk_cnt < 4)
3693                 {
3694                         //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3695                         return bStuck;
3696                 }
3697                 else
3698                 {
3699                         rx_chk_cnt = 0;
3700                         //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3701                 }
3702         }
3703         else
3704         {
3705                 if(rx_chk_cnt < 8)
3706                 {
3707                         //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3708                         return bStuck;
3709                 }
3710                 else
3711                 {
3712                         rx_chk_cnt = 0;
3713                         //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3714                 }
3715         }
3716         if(priv->RxCounter==RegRxCounter)
3717                 bStuck = TRUE;
3718
3719         priv->RxCounter = RegRxCounter;
3720
3721         return bStuck;
3722 }
3723
3724 static RESET_TYPE RxCheckStuck(struct net_device *dev)
3725 {
3726
3727         if(HalRxCheckStuck8190Pci(dev))
3728         {
3729                 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3730                 return RESET_TYPE_SILENT;
3731         }
3732
3733         return RESET_TYPE_NORESET;
3734 }
3735
3736 static RESET_TYPE
3737 rtl819x_ifcheck_resetornot(struct net_device *dev)
3738 {
3739         struct r8192_priv *priv = ieee80211_priv(dev);
3740         RESET_TYPE      TxResetType = RESET_TYPE_NORESET;
3741         RESET_TYPE      RxResetType = RESET_TYPE_NORESET;
3742         RT_RF_POWER_STATE       rfState;
3743
3744         rfState = priv->ieee80211->eRFPowerState;
3745
3746         TxResetType = TxCheckStuck(dev);
3747 #if 1
3748         if( rfState != eRfOff &&
3749                 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3750                 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3751         {
3752                 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3753                 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3754                 // if driver is in firmware download failure status, driver should initialize RF in the following
3755                 // silent reset procedure Emily, 2008.01.21
3756
3757                 // Driver should not check RX stuck in IBSS mode because it is required to
3758                 // set Check BSSID in order to send beacon, however, if check BSSID is
3759                 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3760                 RxResetType = RxCheckStuck(dev);
3761         }
3762 #endif
3763
3764         RT_TRACE(COMP_RESET,"%s(): TxResetType is %d, RxResetType is %d\n",__FUNCTION__,TxResetType,RxResetType);
3765         if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3766                 return RESET_TYPE_NORMAL;
3767         else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT)
3768                 return RESET_TYPE_SILENT;
3769         else
3770                 return RESET_TYPE_NORESET;
3771
3772 }
3773
3774
3775 static void CamRestoreAllEntry(struct net_device *dev)
3776 {
3777         u8 EntryId = 0;
3778         struct r8192_priv *priv = ieee80211_priv(dev);
3779         const u8*       MacAddr = priv->ieee80211->current_network.bssid;
3780
3781         static const u8 CAM_CONST_ADDR[4][6] = {
3782                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3783                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3784                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3785                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3786         static const u8 CAM_CONST_BROAD[] =
3787                 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3788
3789         RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3790
3791
3792         if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3793             (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3794         {
3795
3796                 for(EntryId=0; EntryId<4; EntryId++)
3797                 {
3798                         {
3799                                 MacAddr = CAM_CONST_ADDR[EntryId];
3800                                 setKey(dev,
3801                                                 EntryId ,
3802                                                 EntryId,
3803                                                 priv->ieee80211->pairwise_key_type,
3804                                                 MacAddr,
3805                                                 0,
3806                                                 NULL);
3807                         }
3808                 }
3809
3810         }
3811         else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3812         {
3813
3814                 {
3815                         if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3816                                 setKey(dev,
3817                                                 4,
3818                                                 0,
3819                                                 priv->ieee80211->pairwise_key_type,
3820                                                 (u8*)dev->dev_addr,
3821                                                 0,
3822                                                 NULL);
3823                         else
3824                                 setKey(dev,
3825                                                 4,
3826                                                 0,
3827                                                 priv->ieee80211->pairwise_key_type,
3828                                                 MacAddr,
3829                                                 0,
3830                                                 NULL);
3831                 }
3832         }
3833         else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3834         {
3835
3836                 {
3837                         if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3838                                 setKey(dev,
3839                                                 4,
3840                                                 0,
3841                                                 priv->ieee80211->pairwise_key_type,
3842                                                 (u8*)dev->dev_addr,
3843                                                 0,
3844                                                 NULL);
3845                         else
3846                                 setKey(dev,
3847                                                 4,
3848                                                 0,
3849                                                 priv->ieee80211->pairwise_key_type,
3850                                                 MacAddr,
3851                                                 0,
3852                                                 NULL);
3853                 }
3854         }
3855
3856
3857
3858         if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3859         {
3860                 MacAddr = CAM_CONST_BROAD;
3861                 for(EntryId=1 ; EntryId<4 ; EntryId++)
3862                 {
3863                         {
3864                                 setKey(dev,
3865                                                 EntryId,
3866                                                 EntryId,
3867                                                 priv->ieee80211->group_key_type,
3868                                                 MacAddr,
3869                                                 0,
3870                                                 NULL);
3871                         }
3872                 }
3873                 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3874                                 setKey(dev,
3875                                                 0,
3876                                                 0,
3877                                                 priv->ieee80211->group_key_type,
3878                                                 CAM_CONST_ADDR[0],
3879                                                 0,
3880                                                 NULL);
3881         }
3882         else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3883         {
3884                 MacAddr = CAM_CONST_BROAD;
3885                 for(EntryId=1; EntryId<4 ; EntryId++)
3886                 {
3887                         {
3888                                 setKey(dev,
3889                                                 EntryId ,
3890                                                 EntryId,
3891                                                 priv->ieee80211->group_key_type,
3892                                                 MacAddr,
3893                                                 0,
3894                                                 NULL);
3895                         }
3896                 }
3897
3898                 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3899                                 setKey(dev,
3900                                                 0 ,
3901                                                 0,
3902                                                 priv->ieee80211->group_key_type,
3903                                                 CAM_CONST_ADDR[0],
3904                                                 0,
3905                                                 NULL);
3906         }
3907 }
3908
3909 /*
3910  * This function is used to fix Tx/Rx stop bug temporarily.
3911  * This function will do "system reset" to NIC when Tx or Rx is stuck.
3912  * The method checking Tx/Rx stuck of this function is supported by FW,
3913  * which reports Tx and Rx counter to register 0x128 and 0x130.
3914  */
3915 static void rtl819x_ifsilentreset(struct net_device *dev)
3916 {
3917         struct r8192_priv *priv = ieee80211_priv(dev);
3918         u8      reset_times = 0;
3919         int reset_status = 0;
3920         struct ieee80211_device *ieee = priv->ieee80211;
3921
3922
3923         return;
3924
3925         // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3926         //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3927
3928         if(priv->ResetProgress==RESET_TYPE_NORESET)
3929         {
3930 RESET_START:
3931 #ifdef ENABLE_LPS
3932                 //LZM for PS-Poll AID issue. 090429
3933                 if(priv->ieee80211->state == IEEE80211_LINKED)
3934                     LeisurePSLeave(dev);
3935 #endif
3936
3937                 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3938
3939                 // Set the variable for reset.
3940                 priv->ResetProgress = RESET_TYPE_SILENT;
3941 //              rtl8192_close(dev);
3942 #if 1
3943                 down(&priv->wx_sem);
3944                 if(priv->up == 0)
3945                 {
3946                         RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3947                         up(&priv->wx_sem);
3948                         return ;
3949                 }
3950                 priv->up = 0;
3951                 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3952                 if(!netif_queue_stopped(dev))
3953                         netif_stop_queue(dev);
3954
3955                 dm_backup_dynamic_mechanism_state(dev);
3956
3957                 rtl8192_irq_disable(dev);
3958                 rtl8192_cancel_deferred_work(priv);
3959                 deinit_hal_dm(dev);
3960                 del_timer_sync(&priv->watch_dog_timer);
3961                 ieee->sync_scan_hurryup = 1;
3962                 if(ieee->state == IEEE80211_LINKED)
3963                 {
3964                         down(&ieee->wx_sem);
3965                         printk("ieee->state is IEEE80211_LINKED\n");
3966                         ieee80211_stop_send_beacons(priv->ieee80211);
3967                         del_timer_sync(&ieee->associate_timer);
3968                         cancel_delayed_work(&ieee->associate_retry_wq);
3969                         ieee80211_stop_scan(ieee);
3970                         up(&ieee->wx_sem);
3971                 }
3972                 else{
3973                         printk("ieee->state is NOT LINKED\n");
3974                         ieee80211_softmac_stop_protocol(priv->ieee80211,true);
3975                 }
3976                 rtl8192_halt_adapter(dev, true);
3977                 up(&priv->wx_sem);
3978                 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3979                 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
3980                 reset_status = _rtl8192_up(dev);
3981
3982                 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3983                 if(reset_status == -1)
3984                 {
3985                         if(reset_times < 3)
3986                         {
3987                                 reset_times++;
3988                                 goto RESET_START;
3989                         }
3990                         else
3991                         {
3992                                 RT_TRACE(COMP_ERR," ERR!!! %s():  Reset Failed!!\n",__FUNCTION__);
3993                         }
3994                 }
3995 #endif
3996                 ieee->is_silent_reset = 1;
3997 #if 1
3998                 EnableHWSecurityConfig8192(dev);
3999 #if 1
4000                 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4001                 {
4002                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
4003
4004 #if 1
4005                         queue_work(ieee->wq, &ieee->associate_complete_wq);
4006 #endif
4007
4008                 }
4009                 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4010                 {
4011                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
4012                         ieee->link_change(ieee->dev);
4013
4014                 //      notify_wx_assoc_event(ieee);
4015
4016                         ieee80211_start_send_beacons(ieee);
4017
4018                         if (ieee->data_hard_resume)
4019                                 ieee->data_hard_resume(ieee->dev);
4020                         netif_carrier_on(ieee->dev);
4021                 }
4022 #endif
4023
4024                 CamRestoreAllEntry(dev);
4025
4026                 // Restore the previous setting for all dynamic mechanism
4027                 dm_restore_dynamic_mechanism_state(dev);
4028
4029                 priv->ResetProgress = RESET_TYPE_NORESET;
4030                 priv->reset_count++;
4031
4032                 priv->bForcedSilentReset =false;
4033                 priv->bResetInProgress = false;
4034
4035                 // For test --> force write UFWP.
4036                 write_nic_byte(dev, UFWP, 1);
4037                 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4038 #endif
4039         }
4040 }
4041
4042 #ifdef ENABLE_IPS
4043 void InactivePsWorkItemCallback(struct net_device *dev)
4044 {
4045         struct r8192_priv *priv = ieee80211_priv(dev);
4046         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4047
4048         RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() ---------> \n");
4049         //
4050         // This flag "bSwRfProcessing", indicates the status of IPS procedure, should be set if the IPS workitem
4051         // is really scheduled.
4052         // The old code, sets this flag before scheduling the IPS workitem and however, at the same time the
4053         // previous IPS workitem did not end yet, fails to schedule the current workitem. Thus, bSwRfProcessing
4054         // blocks the IPS procedure of switching RF.
4055         // By Bruce, 2007-12-25.
4056         //
4057         pPSC->bSwRfProcessing = TRUE;
4058
4059         RT_TRACE(COMP_RF, "InactivePsWorkItemCallback(): Set RF to %s.\n",
4060                         pPSC->eInactivePowerState == eRfOff?"OFF":"ON");
4061
4062
4063         MgntActSet_RF_State(dev, pPSC->eInactivePowerState, RF_CHANGE_BY_IPS);
4064
4065         //
4066         // To solve CAM values miss in RF OFF, rewrite CAM values after RF ON. By Bruce, 2007-09-20.
4067         //
4068         pPSC->bSwRfProcessing = FALSE;
4069         RT_TRACE(COMP_POWER, "InactivePsWorkItemCallback() <--------- \n");
4070 }
4071
4072 #ifdef ENABLE_LPS
4073 /* Change current and default preamble mode. */
4074 bool MgntActSet_802_11_PowerSaveMode(struct net_device *dev,    u8 rtPsMode)
4075 {
4076         struct r8192_priv *priv = ieee80211_priv(dev);
4077
4078         // Currently, we do not change power save mode on IBSS mode.
4079         if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
4080         {
4081                 return false;
4082         }
4083
4084         //
4085         // <RJ_NOTE> If we make HW to fill up the PwrMgt bit for us,
4086         // some AP will not response to our mgnt frames with PwrMgt bit set,
4087         // e.g. cannot associate the AP.
4088         // So I commented out it. 2005.02.16, by rcnjko.
4089         //
4090 //      // Change device's power save mode.
4091 //      Adapter->HalFunc.SetPSModeHandler( Adapter, rtPsMode );
4092
4093         // Update power save mode configured.
4094         //RT_TRACE(COMP_LPS,"%s(): set ieee->ps = %x\n",__FUNCTION__,rtPsMode);
4095         if(!priv->ps_force) {
4096                 priv->ieee80211->ps = rtPsMode;
4097         }
4098
4099         // Awake immediately
4100         if(priv->ieee80211->sta_sleep != 0 && rtPsMode == IEEE80211_PS_DISABLED)
4101         {
4102                 unsigned long flags;
4103
4104                 //PlatformSetTimer(Adapter, &(pMgntInfo->AwakeTimer), 0);
4105                 // Notify the AP we awke.
4106                 rtl8192_hw_wakeup(dev);
4107                 priv->ieee80211->sta_sleep = 0;
4108
4109                 spin_lock_irqsave(&(priv->ieee80211->mgmt_tx_lock), flags);
4110                 printk("LPS leave: notify AP we are awaked ++++++++++ SendNullFunctionData\n");
4111                 ieee80211_sta_ps_send_null_frame(priv->ieee80211, 0);
4112                 spin_unlock_irqrestore(&(priv->ieee80211->mgmt_tx_lock), flags);
4113         }
4114
4115         return true;
4116 }
4117
4118 /* Enter the leisure power save mode. */
4119 void LeisurePSEnter(struct net_device *dev)
4120 {
4121         struct r8192_priv *priv = ieee80211_priv(dev);
4122         PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4123
4124         //RT_TRACE(COMP_PS, "LeisurePSEnter()...\n");
4125         //RT_TRACE(COMP_PS, "pPSC->bLeisurePs = %d, ieee->ps = %d,pPSC->LpsIdleCount is %d,RT_CHECK_FOR_HANG_PERIOD is %d\n",
4126         //      pPSC->bLeisurePs, priv->ieee80211->ps,pPSC->LpsIdleCount,RT_CHECK_FOR_HANG_PERIOD);
4127
4128         if(!((priv->ieee80211->iw_mode == IW_MODE_INFRA) &&
4129                 (priv->ieee80211->state == IEEE80211_LINKED)) ||
4130                 (priv->ieee80211->iw_mode == IW_MODE_ADHOC) ||
4131                 (priv->ieee80211->iw_mode == IW_MODE_MASTER))
4132                 return;
4133
4134         if (pPSC->bLeisurePs)
4135         {
4136                 // Idle for a while if we connect to AP a while ago.
4137                 if(pPSC->LpsIdleCount >= RT_CHECK_FOR_HANG_PERIOD) //  4 Sec
4138                 {
4139
4140                         if(priv->ieee80211->ps == IEEE80211_PS_DISABLED)
4141                         {
4142
4143                                 //RT_TRACE(COMP_LPS, "LeisurePSEnter(): Enter 802.11 power save mode...\n");
4144                                 MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST);
4145
4146                         }
4147                 }
4148                 else
4149                         pPSC->LpsIdleCount++;
4150         }
4151 }
4152
4153
4154 /* Leave leisure power save mode. */
4155 void LeisurePSLeave(struct net_device *dev)
4156 {
4157         struct r8192_priv *priv = ieee80211_priv(dev);
4158         PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4159
4160         if (pPSC->bLeisurePs)
4161         {
4162                 if(priv->ieee80211->ps != IEEE80211_PS_DISABLED)
4163                 {
4164                         // move to lps_wakecomplete()
4165                         //RT_TRACE(COMP_LPS, "LeisurePSLeave(): Busy Traffic , Leave 802.11 power save..\n");
4166                         MgntActSet_802_11_PowerSaveMode(dev, IEEE80211_PS_DISABLED);
4167
4168                 }
4169         }
4170 }
4171 #endif
4172
4173
4174 /* Enter the inactive power save mode. RF will be off */
4175 void
4176 IPSEnter(struct net_device *dev)
4177 {
4178         struct r8192_priv *priv = ieee80211_priv(dev);
4179         PRT_POWER_SAVE_CONTROL          pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4180         RT_RF_POWER_STATE                       rtState;
4181
4182         if (pPSC->bInactivePs)
4183         {
4184                 rtState = priv->ieee80211->eRFPowerState;
4185                 //
4186                 // Added by Bruce, 2007-12-25.
4187                 // Do not enter IPS in the following conditions:
4188                 // (1) RF is already OFF or Sleep
4189                 // (2) bSwRfProcessing (indicates the IPS is still under going)
4190                 // (3) Connectted (only disconnected can trigger IPS)
4191                 // (4) IBSS (send Beacon)
4192                 // (5) AP mode (send Beacon)
4193                 //
4194                 if (rtState == eRfOn && !pPSC->bSwRfProcessing
4195                         && (priv->ieee80211->state != IEEE80211_LINKED) )
4196                 {
4197                         RT_TRACE(COMP_RF,"IPSEnter(): Turn off RF.\n");
4198                         //printk("IPSEnter(): Turn off RF.\n");
4199                         pPSC->eInactivePowerState = eRfOff;
4200 //                      queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4201                         InactivePsWorkItemCallback(dev);
4202                 }
4203         }
4204 }
4205
4206 //
4207 //      Description:
4208 //              Leave the inactive power save mode, RF will be on.
4209 //      2007.08.17, by shien chang.
4210 //
4211 void
4212 IPSLeave(struct net_device *dev)
4213 {
4214         struct r8192_priv *priv = ieee80211_priv(dev);
4215         PRT_POWER_SAVE_CONTROL  pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
4216         RT_RF_POWER_STATE       rtState;
4217
4218         if (pPSC->bInactivePs)
4219         {
4220                 rtState = priv->ieee80211->eRFPowerState;
4221                 if (rtState != eRfOn  && !pPSC->bSwRfProcessing && priv->ieee80211->RfOffReason <= RF_CHANGE_BY_IPS)
4222                 {
4223                         RT_TRACE(COMP_POWER, "IPSLeave(): Turn on RF.\n");
4224                         //printk("IPSLeave(): Turn on RF.\n");
4225                         pPSC->eInactivePowerState = eRfOn;
4226 //                      queue_work(priv->priv_wq,&(pPSC->InactivePsWorkItem));
4227                         InactivePsWorkItemCallback(dev);
4228                 }
4229         }
4230 }
4231
4232 void IPSLeave_wq(void *data)
4233 {
4234         struct ieee80211_device *ieee = container_of(data,struct ieee80211_device,ips_leave_wq);
4235         struct net_device *dev = ieee->dev;
4236
4237         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4238         down(&priv->ieee80211->ips_sem);
4239         IPSLeave(dev);
4240         up(&priv->ieee80211->ips_sem);
4241 }
4242
4243 void ieee80211_ips_leave_wq(struct net_device *dev)
4244 {
4245         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4246         RT_RF_POWER_STATE       rtState;
4247         rtState = priv->ieee80211->eRFPowerState;
4248
4249         if(priv->ieee80211->PowerSaveControl.bInactivePs){
4250                 if(rtState == eRfOff){
4251                         if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
4252                         {
4253                                 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
4254                                 return;
4255                         }
4256                         else{
4257                                 printk("=========>%s(): IPSLeave\n",__FUNCTION__);
4258                                 queue_work(priv->ieee80211->wq,&priv->ieee80211->ips_leave_wq);
4259                         }
4260                 }
4261         }
4262 }
4263 //added by amy 090331 end
4264 void ieee80211_ips_leave(struct net_device *dev)
4265 {
4266         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4267         down(&priv->ieee80211->ips_sem);
4268         IPSLeave(dev);
4269         up(&priv->ieee80211->ips_sem);
4270 }
4271 #endif
4272
4273 static void rtl819x_update_rxcounts(
4274         struct r8192_priv *priv,
4275         u32* TotalRxBcnNum,
4276         u32* TotalRxDataNum
4277 )
4278 {
4279         u16                     SlotIndex;
4280         u8                      i;
4281
4282         *TotalRxBcnNum = 0;
4283         *TotalRxDataNum = 0;
4284
4285         SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4286         priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4287         priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4288         for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4289                 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4290                 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4291         }
4292 }
4293
4294
4295 static void rtl819x_watchdog_wqcallback(struct work_struct *work)
4296 {
4297         struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4298        struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4299        struct net_device *dev = priv->ieee80211->dev;
4300         struct ieee80211_device* ieee = priv->ieee80211;
4301         RESET_TYPE      ResetType = RESET_TYPE_NORESET;
4302         static u8       check_reset_cnt=0;
4303         unsigned long flags;
4304         bool bBusyTraffic = false;
4305         static u8 last_time = 0;
4306         bool bEnterPS = false;
4307
4308         if ((!priv->up) || priv->bHwRadioOff)
4309                 return;
4310
4311         if(!priv->up)
4312                 return;
4313         hal_dm_watchdog(dev);
4314 #ifdef ENABLE_IPS
4315 //      printk("watch_dog ENABLE_IPS\n");
4316         if(ieee->actscanning == false){
4317                 //printk("%d,%d,%d,%d\n", ieee->eRFPowerState, ieee->is_set_key, ieee->proto_stoppping, ieee->wx_set_enc);
4318                 if((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state == IEEE80211_NOLINK) &&
4319                     (ieee->eRFPowerState == eRfOn)&&!ieee->is_set_key &&
4320                     (!ieee->proto_stoppping) && !ieee->wx_set_enc){
4321                         if(ieee->PowerSaveControl.ReturnPoint == IPS_CALLBACK_NONE){
4322                                 //printk("====================>haha:IPSEnter()\n");
4323                                 IPSEnter(dev);
4324                                 //ieee80211_stop_scan(priv->ieee80211);
4325                         }
4326                 }
4327         }
4328 #endif
4329         {//to get busy traffic condition
4330                 if(ieee->state == IEEE80211_LINKED)
4331                 {
4332                         if(     ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
4333                                 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
4334                                 bBusyTraffic = true;
4335                         }
4336
4337 #ifdef ENABLE_LPS
4338                         //added by amy for Leisure PS
4339                         if(     ((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod + ieee->LinkDetectInfo.NumTxOkInPeriod) > 8 ) ||
4340                                 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2) )
4341                         {
4342                                 //printk("ieee->LinkDetectInfo.NumRxUnicastOkInPeriod is %d,ieee->LinkDetectInfo.NumTxOkInPeriod is %d\n",
4343                                 //      ieee->LinkDetectInfo.NumRxUnicastOkInPeriod,ieee->LinkDetectInfo.NumTxOkInPeriod);
4344                                 bEnterPS= false;
4345                         }
4346                         else
4347                         {
4348                                 bEnterPS= true;
4349                         }
4350
4351                         //printk("***bEnterPS = %d\n", bEnterPS);
4352                         // LeisurePS only work in infra mode.
4353                         if(bEnterPS)
4354                         {
4355                                 LeisurePSEnter(dev);
4356                         }
4357                         else
4358                         {
4359                                 LeisurePSLeave(dev);
4360                         }
4361 #endif
4362
4363                 }
4364                 else
4365                 {
4366 #ifdef ENABLE_LPS
4367                         //RT_TRACE(COMP_LPS,"====>no link LPS leave\n");
4368                         LeisurePSLeave(dev);
4369 #endif
4370                 }
4371
4372                 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4373                 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4374                 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
4375                 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4376         }
4377
4378
4379         //added by amy for AP roaming
4380         if (1)
4381         {
4382                 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4383                 {
4384                         u32     TotalRxBcnNum = 0;
4385                         u32     TotalRxDataNum = 0;
4386
4387                         rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4388                         if((TotalRxBcnNum+TotalRxDataNum) == 0)
4389                         {
4390                                 if( ieee->eRFPowerState == eRfOff)
4391                                         RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4392                                 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4393                                 //              Dot11d_Reset(dev);
4394                                 ieee->state = IEEE80211_ASSOCIATING;
4395                                 notify_wx_assoc_event(priv->ieee80211);
4396                                 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4397                                 ieee->is_roaming = true;
4398                                 ieee->is_set_key = false;
4399                                 ieee->link_change(dev);
4400                                 queue_work(ieee->wq, &ieee->associate_procedure_wq);
4401                         }
4402                 }
4403               ieee->LinkDetectInfo.NumRecvBcnInPeriod=0;
4404               ieee->LinkDetectInfo.NumRecvDataInPeriod=0;
4405
4406         }
4407         //check if reset the driver
4408         spin_lock_irqsave(&priv->tx_lock,flags);
4409         if(check_reset_cnt++ >= 3 && !ieee->is_roaming && (last_time != 1))
4410         {
4411                 ResetType = rtl819x_ifcheck_resetornot(dev);
4412                 check_reset_cnt = 3;
4413                 //DbgPrint("Start to check silent reset\n");
4414         }
4415         spin_unlock_irqrestore(&priv->tx_lock,flags);
4416         if(!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL)
4417         {
4418                 priv->ResetProgress = RESET_TYPE_NORMAL;
4419                 RT_TRACE(COMP_RESET,"%s(): NOMAL RESET\n",__FUNCTION__);
4420                 return;
4421         }
4422         /* disable silent reset temply 2008.9.11*/
4423 #if 1
4424         if( ((priv->force_reset) || (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT))) // This is control by OID set in Pomelo
4425         {
4426                 last_time = 1;
4427                 rtl819x_ifsilentreset(dev);
4428         }
4429         else
4430                 last_time = 0;
4431 #endif
4432         priv->force_reset = false;
4433         priv->bForcedSilentReset = false;
4434         priv->bResetInProgress = false;
4435         RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4436
4437 }
4438
4439 void watch_dog_timer_callback(unsigned long data)
4440 {
4441         struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4442         queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq,0);
4443         mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4444
4445 }
4446
4447 static int _rtl8192_up(struct net_device *dev)
4448 {
4449         struct r8192_priv *priv = ieee80211_priv(dev);
4450         //int i;
4451         RT_STATUS init_status = RT_STATUS_SUCCESS;
4452         priv->up=1;
4453         priv->ieee80211->ieee_up=1;
4454         priv->bdisable_nic = false;  //YJ,add,091111
4455         RT_TRACE(COMP_INIT, "Bringing up iface");
4456
4457         init_status = rtl8192_adapter_start(dev);
4458         if(init_status != RT_STATUS_SUCCESS)
4459         {
4460                 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
4461                 return -1;
4462         }
4463         RT_TRACE(COMP_INIT, "start adapter finished\n");
4464 #ifdef RTL8192E
4465         if(priv->ieee80211->eRFPowerState!=eRfOn)
4466                 MgntActSet_RF_State(dev, eRfOn, priv->ieee80211->RfOffReason);
4467 #endif
4468         if(priv->ieee80211->state != IEEE80211_LINKED)
4469         ieee80211_softmac_start_protocol(priv->ieee80211);
4470         ieee80211_reset_queue(priv->ieee80211);
4471         watch_dog_timer_callback((unsigned long) dev);
4472         if(!netif_queue_stopped(dev))
4473                 netif_start_queue(dev);
4474         else
4475                 netif_wake_queue(dev);
4476
4477         return 0;
4478 }
4479
4480
4481 static int rtl8192_open(struct net_device *dev)
4482 {
4483         struct r8192_priv *priv = ieee80211_priv(dev);
4484         int ret;
4485
4486         down(&priv->wx_sem);
4487         ret = rtl8192_up(dev);
4488         up(&priv->wx_sem);
4489         return ret;
4490
4491 }
4492
4493
4494 int rtl8192_up(struct net_device *dev)
4495 {
4496         struct r8192_priv *priv = ieee80211_priv(dev);
4497
4498         if (priv->up == 1) return -1;
4499
4500         return _rtl8192_up(dev);
4501 }
4502
4503
4504 static int rtl8192_close(struct net_device *dev)
4505 {
4506         struct r8192_priv *priv = ieee80211_priv(dev);
4507         int ret;
4508
4509         down(&priv->wx_sem);
4510
4511         ret = rtl8192_down(dev);
4512
4513         up(&priv->wx_sem);
4514
4515         return ret;
4516
4517 }
4518
4519 int rtl8192_down(struct net_device *dev)
4520 {
4521         struct r8192_priv *priv = ieee80211_priv(dev);
4522
4523         if (priv->up == 0) return -1;
4524
4525 #ifdef ENABLE_LPS
4526         //LZM for PS-Poll AID issue. 090429
4527         if(priv->ieee80211->state == IEEE80211_LINKED)
4528                 LeisurePSLeave(dev);
4529 #endif
4530
4531         priv->up=0;
4532         priv->ieee80211->ieee_up = 0;
4533         RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4534 /* FIXME */
4535         if (!netif_queue_stopped(dev))
4536                 netif_stop_queue(dev);
4537
4538         rtl8192_irq_disable(dev);
4539         rtl8192_cancel_deferred_work(priv);
4540         deinit_hal_dm(dev);
4541         del_timer_sync(&priv->watch_dog_timer);
4542
4543         ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4544
4545         rtl8192_halt_adapter(dev,false);
4546         memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4547
4548         RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4549
4550         return 0;
4551 }
4552
4553
4554 void rtl8192_commit(struct net_device *dev)
4555 {
4556         struct r8192_priv *priv = ieee80211_priv(dev);
4557
4558         if (priv->up == 0) return ;
4559
4560
4561         ieee80211_softmac_stop_protocol(priv->ieee80211,true);
4562
4563         rtl8192_irq_disable(dev);
4564         rtl8192_halt_adapter(dev,true);
4565         _rtl8192_up(dev);
4566 }
4567
4568 static void rtl8192_restart(struct work_struct *work)
4569 {
4570         struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4571         struct net_device *dev = priv->ieee80211->dev;
4572
4573         down(&priv->wx_sem);
4574
4575         rtl8192_commit(dev);
4576
4577         up(&priv->wx_sem);
4578 }
4579
4580 static void r8192_set_multicast(struct net_device *dev)
4581 {
4582         struct r8192_priv *priv = ieee80211_priv(dev);
4583         short promisc;
4584
4585         //down(&priv->wx_sem);
4586
4587         /* FIXME FIXME */
4588
4589         promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4590
4591         if (promisc != priv->promisc) {
4592                 ;
4593         //      rtl8192_commit(dev);
4594         }
4595
4596         priv->promisc = promisc;
4597
4598         //schedule_work(&priv->reset_wq);
4599         //up(&priv->wx_sem);
4600 }
4601
4602
4603 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
4604 {
4605         struct r8192_priv *priv = ieee80211_priv(dev);
4606         struct sockaddr *addr = mac;
4607
4608         down(&priv->wx_sem);
4609
4610         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4611
4612         schedule_work(&priv->reset_wq);
4613         up(&priv->wx_sem);
4614
4615         return 0;
4616 }
4617
4618 /* based on ipw2200 driver */
4619 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4620 {
4621         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4622         struct iwreq *wrq = (struct iwreq *)rq;
4623         int ret=-1;
4624         struct ieee80211_device *ieee = priv->ieee80211;
4625         u32 key[4];
4626         u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4627         struct iw_point *p = &wrq->u.data;
4628         struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4629
4630         down(&priv->wx_sem);
4631
4632
4633      if (p->length < sizeof(struct ieee_param) || !p->pointer){
4634              ret = -EINVAL;
4635              goto out;
4636      }
4637
4638      ipw = kmalloc(p->length, GFP_KERNEL);
4639      if (ipw == NULL){
4640              ret = -ENOMEM;
4641              goto out;
4642      }
4643      if (copy_from_user(ipw, p->pointer, p->length)) {
4644             kfree(ipw);
4645             ret = -EFAULT;
4646             goto out;
4647      }
4648
4649         switch (cmd) {
4650             case RTL_IOCTL_WPA_SUPPLICANT:
4651                 //parse here for HW security
4652                         if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4653                         {
4654                                 if (ipw->u.crypt.set_tx)
4655                                 {
4656                                         if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4657                                                 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4658                                         else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4659                                                 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4660                                         else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4661                                         {
4662                                                 if (ipw->u.crypt.key_len == 13)
4663                                                         ieee->pairwise_key_type = KEY_TYPE_WEP104;
4664                                                 else if (ipw->u.crypt.key_len == 5)
4665                                                         ieee->pairwise_key_type = KEY_TYPE_WEP40;
4666                                         }
4667                                         else
4668                                                 ieee->pairwise_key_type = KEY_TYPE_NA;
4669
4670                                         if (ieee->pairwise_key_type)
4671                                         {
4672                                                 memcpy((u8*)key, ipw->u.crypt.key, 16);
4673                                                 EnableHWSecurityConfig8192(dev);
4674                                         //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!
4675                                         //added by WB.
4676                                                 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4677                                                 if (ieee->auth_mode != 2)  //LEAP WEP will never set this.
4678                                                 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4679                                         }
4680                                         if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) && ieee->pHTInfo->bCurrentHTSupport){
4681                                                         write_nic_byte(dev, 0x173, 1); //fix aes bug
4682                                                 }
4683
4684                                 }
4685                                 else //if (ipw->u.crypt.idx) //group key use idx > 0
4686                                 {
4687                                         memcpy((u8*)key, ipw->u.crypt.key, 16);
4688                                         if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4689                                                 ieee->group_key_type= KEY_TYPE_CCMP;
4690                                         else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4691                                                 ieee->group_key_type = KEY_TYPE_TKIP;
4692                                         else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4693                                         {
4694                                                 if (ipw->u.crypt.key_len == 13)
4695                                                         ieee->group_key_type = KEY_TYPE_WEP104;
4696                                                 else if (ipw->u.crypt.key_len == 5)
4697                                                         ieee->group_key_type = KEY_TYPE_WEP40;
4698                                         }
4699                                         else
4700                                                 ieee->group_key_type = KEY_TYPE_NA;
4701
4702                                         if (ieee->group_key_type)
4703                                         {
4704                                                         setKey( dev,
4705                                                                 ipw->u.crypt.idx,
4706                                                                 ipw->u.crypt.idx,               //KeyIndex
4707                                                                 ieee->group_key_type,   //KeyType
4708                                                                 broadcast_addr, //MacAddr
4709                                                                 0,              //DefaultKey
4710                                                                 key);           //KeyContent
4711                                         }
4712                                 }
4713                         }
4714 #ifdef JOHN_DEBUG
4715                 //john's test 0711
4716         {
4717                 int i;
4718                 printk("@@ wrq->u pointer = ");
4719                 for(i=0;i<wrq->u.data.length;i++){
4720                         if(i%10==0) printk("\n");
4721                         printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4722                 }
4723                 printk("\n");
4724         }
4725 #endif /*JOHN_DEBUG*/
4726                 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4727                 break;
4728
4729             default:
4730                 ret = -EOPNOTSUPP;
4731                 break;
4732         }
4733
4734         kfree(ipw);
4735 out:
4736         up(&priv->wx_sem);
4737
4738         return ret;
4739 }
4740
4741 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
4742 {
4743         u8  ret_rate = 0x02;
4744
4745         if(!bIsHT) {
4746                 switch(rate) {
4747                         case DESC90_RATE1M:   ret_rate = MGN_1M;         break;
4748                         case DESC90_RATE2M:   ret_rate = MGN_2M;         break;
4749                         case DESC90_RATE5_5M: ret_rate = MGN_5_5M;       break;
4750                         case DESC90_RATE11M:  ret_rate = MGN_11M;        break;
4751                         case DESC90_RATE6M:   ret_rate = MGN_6M;         break;
4752                         case DESC90_RATE9M:   ret_rate = MGN_9M;         break;
4753                         case DESC90_RATE12M:  ret_rate = MGN_12M;        break;
4754                         case DESC90_RATE18M:  ret_rate = MGN_18M;        break;
4755                         case DESC90_RATE24M:  ret_rate = MGN_24M;        break;
4756                         case DESC90_RATE36M:  ret_rate = MGN_36M;        break;
4757                         case DESC90_RATE48M:  ret_rate = MGN_48M;        break;
4758                         case DESC90_RATE54M:  ret_rate = MGN_54M;        break;
4759
4760                         default:
4761                                               RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4762                                               break;
4763                 }
4764
4765         } else {
4766                 switch(rate) {
4767                         case DESC90_RATEMCS0:   ret_rate = MGN_MCS0;    break;
4768                         case DESC90_RATEMCS1:   ret_rate = MGN_MCS1;    break;
4769                         case DESC90_RATEMCS2:   ret_rate = MGN_MCS2;    break;
4770                         case DESC90_RATEMCS3:   ret_rate = MGN_MCS3;    break;
4771                         case DESC90_RATEMCS4:   ret_rate = MGN_MCS4;    break;
4772                         case DESC90_RATEMCS5:   ret_rate = MGN_MCS5;    break;
4773                         case DESC90_RATEMCS6:   ret_rate = MGN_MCS6;    break;
4774                         case DESC90_RATEMCS7:   ret_rate = MGN_MCS7;    break;
4775                         case DESC90_RATEMCS8:   ret_rate = MGN_MCS8;    break;
4776                         case DESC90_RATEMCS9:   ret_rate = MGN_MCS9;    break;
4777                         case DESC90_RATEMCS10:  ret_rate = MGN_MCS10;   break;
4778                         case DESC90_RATEMCS11:  ret_rate = MGN_MCS11;   break;
4779                         case DESC90_RATEMCS12:  ret_rate = MGN_MCS12;   break;
4780                         case DESC90_RATEMCS13:  ret_rate = MGN_MCS13;   break;
4781                         case DESC90_RATEMCS14:  ret_rate = MGN_MCS14;   break;
4782                         case DESC90_RATEMCS15:  ret_rate = MGN_MCS15;   break;
4783                         case DESC90_RATEMCS32:  ret_rate = (0x80|0x20); break;
4784
4785                         default:
4786                                                 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4787                                                 break;
4788                 }
4789         }
4790
4791         return ret_rate;
4792 }
4793
4794 /* Record the TSF time stamp when receiving a packet */
4795 static void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4796 {
4797         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4798
4799         if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4800                 stats->mac_time[0] = priv->LastRxDescTSFLow;
4801                 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4802         } else {
4803                 priv->LastRxDescTSFLow = stats->mac_time[0];
4804                 priv->LastRxDescTSFHigh = stats->mac_time[1];
4805         }
4806 }
4807
4808 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
4809 {
4810         long    signal_power; // in dBm.
4811
4812         // Translate to dBm (x=0.5y-95).
4813         signal_power = (long)((signal_strength_index + 1) >> 1);
4814         signal_power -= 95;
4815
4816         return signal_power;
4817 }
4818
4819 /*
4820  * Update Rx signal related information in the packet reeived
4821  * to RxStats. User application can query RxStats to realize
4822  * current Rx signal status.
4823  *
4824  * In normal operation, user only care about the information of the BSS
4825  * and we shall invoke this function if the packet received is from the BSS.
4826  */
4827 static void
4828 rtl819x_update_rxsignalstatistics8190pci(
4829         struct r8192_priv * priv,
4830         struct ieee80211_rx_stats * pprevious_stats
4831         )
4832 {
4833         int weighting = 0;
4834
4835         //2 <ToDo> Update Rx Statistics (such as signal strength and signal quality).
4836
4837         // Initila state
4838         if(priv->stats.recv_signal_power == 0)
4839                 priv->stats.recv_signal_power = pprevious_stats->RecvSignalPower;
4840
4841         // To avoid the past result restricting the statistics sensitivity, weight the current power (5/6) to speed up the
4842         // reaction of smoothed Signal Power.
4843         if(pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
4844                 weighting = 5;
4845         else if(pprevious_stats->RecvSignalPower < priv->stats.recv_signal_power)
4846                 weighting = (-5);
4847         //
4848         // We need more correct power of received packets and the  "SignalStrength" of RxStats have been beautified or translated,
4849         // so we record the correct power in Dbm here. By Bruce, 2008-03-07.
4850         //
4851         priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 + pprevious_stats->RecvSignalPower + weighting) / 6;
4852 }
4853
4854 static void
4855 rtl8190_process_cck_rxpathsel(
4856         struct r8192_priv * priv,
4857         struct ieee80211_rx_stats * pprevious_stats
4858         )
4859 {
4860 #ifdef RTL8190P //Only 90P 2T4R need to check
4861         char                            last_cck_adc_pwdb[4]={0,0,0,0};
4862         u8                              i;
4863 //cosa add for Rx path selection
4864                 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable)
4865                 {
4866                         if(pprevious_stats->bIsCCK &&
4867                                 (pprevious_stats->bPacketToSelf ||pprevious_stats->bPacketBeacon))
4868                         {
4869                                 /* record the cck adc_pwdb to the sliding window. */
4870                                 if(priv->stats.cck_adc_pwdb.TotalNum++ >= PHY_RSSI_SLID_WIN_MAX)
4871                                 {
4872                                         priv->stats.cck_adc_pwdb.TotalNum = PHY_RSSI_SLID_WIN_MAX;
4873                                         for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4874                                         {
4875                                                 last_cck_adc_pwdb[i] = priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index];
4876                                                 priv->stats.cck_adc_pwdb.TotalVal[i] -= last_cck_adc_pwdb[i];
4877                                         }
4878                                 }
4879                                 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4880                                 {
4881                                         priv->stats.cck_adc_pwdb.TotalVal[i] += pprevious_stats->cck_adc_pwdb[i];
4882                                         priv->stats.cck_adc_pwdb.elements[i][priv->stats.cck_adc_pwdb.index] = pprevious_stats->cck_adc_pwdb[i];
4883                                 }
4884                                 priv->stats.cck_adc_pwdb.index++;
4885                                 if(priv->stats.cck_adc_pwdb.index >= PHY_RSSI_SLID_WIN_MAX)
4886                                         priv->stats.cck_adc_pwdb.index = 0;
4887
4888                                 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4889                                 {
4890                                         DM_RxPathSelTable.cck_pwdb_sta[i] = priv->stats.cck_adc_pwdb.TotalVal[i]/priv->stats.cck_adc_pwdb.TotalNum;
4891                                 }
4892
4893                                 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
4894                                 {
4895                                         if(pprevious_stats->cck_adc_pwdb[i]  > (char)priv->undecorated_smoothed_cck_adc_pwdb[i])
4896                                         {
4897                                                 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4898                                                         ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4899                                                         (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4900                                                 priv->undecorated_smoothed_cck_adc_pwdb[i] = priv->undecorated_smoothed_cck_adc_pwdb[i] + 1;
4901                                         }
4902                                         else
4903                                         {
4904                                                 priv->undecorated_smoothed_cck_adc_pwdb[i] =
4905                                                         ( (priv->undecorated_smoothed_cck_adc_pwdb[i]*(Rx_Smooth_Factor-1)) +
4906                                                         (pprevious_stats->cck_adc_pwdb[i])) /(Rx_Smooth_Factor);
4907                                         }
4908                                 }
4909                         }
4910                 }
4911 #endif
4912 }
4913
4914
4915 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4916         be a local static. Otherwise, it may increase when we return from S3/S4. The
4917         value will be kept in memory or disk. We must delcare the value in adapter
4918         and it will be reinitialized when return from S3/S4. */
4919 static void rtl8192_process_phyinfo(struct r8192_priv * priv, u8* buffer,struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4920 {
4921         bool bcheck = false;
4922         u8      rfpath;
4923         u32 nspatial_stream, tmp_val;
4924         //u8    i;
4925         static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4926         static u32 slide_evm_index=0, slide_evm_statistics=0;
4927         static u32 last_rssi=0, last_evm=0;
4928         //cosa add for rx path selection
4929 //      static long slide_cck_adc_pwdb_index=0, slide_cck_adc_pwdb_statistics=0;
4930 //      static char last_cck_adc_pwdb[4]={0,0,0,0};
4931         //cosa add for beacon rssi smoothing
4932         static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4933         static u32 last_beacon_adc_pwdb=0;
4934
4935         struct ieee80211_hdr_3addr *hdr;
4936         u16 sc ;
4937         unsigned int frag,seq;
4938         hdr = (struct ieee80211_hdr_3addr *)buffer;
4939         sc = le16_to_cpu(hdr->seq_ctl);
4940         frag = WLAN_GET_SEQ_FRAG(sc);
4941         seq = WLAN_GET_SEQ_SEQ(sc);
4942         //cosa add 04292008 to record the sequence number
4943         pcurrent_stats->Seq_Num = seq;
4944         //
4945         // Check whether we should take the previous packet into accounting
4946         //
4947         if(!pprevious_stats->bIsAMPDU)
4948         {
4949                 // if previous packet is not aggregated packet
4950                 bcheck = true;
4951         }else
4952         {
4953 //remve for that we don't use AMPDU to calculate PWDB,because the reported PWDB of some AP is fault.
4954 #if 0
4955                 // if previous packet is aggregated packet, and current packet
4956                 //      (1) is not AMPDU
4957                 //      (2) is the first packet of one AMPDU
4958                 // that means the previous packet is the last one aggregated packet
4959                 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
4960                         bcheck = true;
4961 #endif
4962         }
4963
4964         if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4965         {
4966                 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4967                 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4968                 priv->stats.slide_rssi_total -= last_rssi;
4969         }
4970         priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4971
4972         priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4973         if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4974                 slide_rssi_index = 0;
4975
4976         // <1> Showed on UI for user, in dbm
4977         tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4978         priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4979         pcurrent_stats->rssi = priv->stats.signal_strength;
4980         //
4981         // If the previous packet does not match the criteria, neglect it
4982         //
4983         if(!pprevious_stats->bPacketMatchBSSID)
4984         {
4985                 if(!pprevious_stats->bToSelfBA)
4986                         return;
4987         }
4988
4989         if(!bcheck)
4990                 return;
4991
4992         rtl8190_process_cck_rxpathsel(priv,pprevious_stats);
4993
4994         //
4995         // Check RSSI
4996         //
4997         priv->stats.num_process_phyinfo++;
4998 #if 0
4999         /* record the general signal strength to the sliding window. */
5000         if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
5001         {
5002                 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
5003                 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
5004                 priv->stats.slide_rssi_total -= last_rssi;
5005         }
5006         priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
5007
5008         priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
5009         if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
5010                 slide_rssi_index = 0;
5011
5012         // <1> Showed on UI for user, in dbm
5013         tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
5014         priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
5015
5016 #endif
5017         // <2> Showed on UI for engineering
5018         // hardware does not provide rssi information for each rf path in CCK
5019         if(!pprevious_stats->bIsCCK && pprevious_stats->bPacketToSelf)
5020         {
5021                 for (rfpath = RF90_PATH_A; rfpath < RF90_PATH_C; rfpath++)
5022                 {
5023                         if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
5024                                 continue;
5025                         RT_TRACE(COMP_DBG,"Jacken -> pPreviousstats->RxMIMOSignalStrength[rfpath]  = %d \n" ,pprevious_stats->RxMIMOSignalStrength[rfpath] );
5026                         //Fixed by Jacken 2008-03-20
5027                         if(priv->stats.rx_rssi_percentage[rfpath] == 0)
5028                         {
5029                                 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
5030                                 //DbgPrint("MIMO RSSI initialize \n");
5031                         }
5032                         if(pprevious_stats->RxMIMOSignalStrength[rfpath]  > priv->stats.rx_rssi_percentage[rfpath])
5033                         {
5034                                 priv->stats.rx_rssi_percentage[rfpath] =
5035                                         ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5036                                         (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5037                                 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath]  + 1;
5038                         }
5039                         else
5040                         {
5041                                 priv->stats.rx_rssi_percentage[rfpath] =
5042                                         ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
5043                                         (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
5044                         }
5045                         RT_TRACE(COMP_DBG,"Jacken -> priv->RxStats.RxRSSIPercentage[rfPath]  = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
5046                 }
5047         }
5048
5049
5050         //
5051         // Check PWDB.
5052         //
5053         //cosa add for beacon rssi smoothing by average.
5054         if(pprevious_stats->bPacketBeacon)
5055         {
5056                 /* record the beacon pwdb to the sliding window. */
5057                 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5058                 {
5059                         slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
5060                         last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
5061                         priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
5062                         //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
5063                         //      slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
5064                 }
5065                 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
5066                 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
5067                 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
5068                 slide_beacon_adc_pwdb_index++;
5069                 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
5070                         slide_beacon_adc_pwdb_index = 0;
5071                 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
5072                 if(pprevious_stats->RxPWDBAll >= 3)
5073                         pprevious_stats->RxPWDBAll -= 3;
5074         }
5075
5076         RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
5077                                 pprevious_stats->bIsCCK? "CCK": "OFDM",
5078                                 pprevious_stats->RxPWDBAll);
5079
5080         if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5081         {
5082                 if(priv->undecorated_smoothed_pwdb < 0) // initialize
5083                 {
5084                         priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
5085                         //DbgPrint("First pwdb initialize \n");
5086                 }
5087 #if 1
5088                 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
5089                 {
5090                         priv->undecorated_smoothed_pwdb =
5091                                         ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5092                                         (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5093                         priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
5094                 }
5095                 else
5096                 {
5097                         priv->undecorated_smoothed_pwdb =
5098                                         ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
5099                                         (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
5100                 }
5101 #else
5102                 //Fixed by Jacken 2008-03-20
5103                 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
5104                 {
5105                         pHalData->UndecoratedSmoothedPWDB =
5106                                         ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5107                         pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
5108                 }
5109                 else
5110                 {
5111                         pHalData->UndecoratedSmoothedPWDB =
5112                                         ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
5113                 }
5114 #endif
5115                 rtl819x_update_rxsignalstatistics8190pci(priv,pprevious_stats);
5116         }
5117
5118         //
5119         // Check EVM
5120         //
5121         /* record the general EVM to the sliding window. */
5122         if(pprevious_stats->SignalQuality == 0)
5123         {
5124         }
5125         else
5126         {
5127                 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
5128                         if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
5129                                 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
5130                                 last_evm = priv->stats.slide_evm[slide_evm_index];
5131                                 priv->stats.slide_evm_total -= last_evm;
5132                         }
5133
5134                         priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
5135
5136                         priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
5137                         if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
5138                                 slide_evm_index = 0;
5139
5140                         // <1> Showed on UI for user, in percentage.
5141                         tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
5142                         priv->stats.signal_quality = tmp_val;
5143                         //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
5144                         priv->stats.last_signal_strength_inpercent = tmp_val;
5145                 }
5146
5147                 // <2> Showed on UI for engineering
5148                 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
5149                 {
5150                         for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
5151                         {
5152                                 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
5153                                 {
5154                                         if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
5155                                         {
5156                                                 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
5157                                         }
5158                                         priv->stats.rx_evm_percentage[nspatial_stream] =
5159                                                 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
5160                                                 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
5161                                 }
5162                         }
5163                 }
5164         }
5165
5166 }
5167
5168 static u8 rtl819x_query_rxpwrpercentage(
5169         char            antpower
5170         )
5171 {
5172         if ((antpower <= -100) || (antpower >= 20))
5173         {
5174                 return  0;
5175         }
5176         else if (antpower >= 0)
5177         {
5178                 return  100;
5179         }
5180         else
5181         {
5182                 return  (100+antpower);
5183         }
5184
5185 }
5186
5187 static u8
5188 rtl819x_evm_dbtopercentage(
5189         char value
5190         )
5191 {
5192         char ret_val;
5193
5194         ret_val = value;
5195
5196         if(ret_val >= 0)
5197                 ret_val = 0;
5198         if(ret_val <= -33)
5199                 ret_val = -33;
5200         ret_val = 0 - ret_val;
5201         ret_val*=3;
5202         if(ret_val == 99)
5203                 ret_val = 100;
5204         return ret_val;
5205 }
5206
5207 /* We want good-looking for signal strength/quality */
5208 static long rtl819x_signal_scale_mapping(long currsig)
5209 {
5210         long retsig;
5211
5212         // Step 1. Scale mapping.
5213         if(currsig >= 61 && currsig <= 100)
5214         {
5215                 retsig = 90 + ((currsig - 60) / 4);
5216         }
5217         else if(currsig >= 41 && currsig <= 60)
5218         {
5219                 retsig = 78 + ((currsig - 40) / 2);
5220         }
5221         else if(currsig >= 31 && currsig <= 40)
5222         {
5223                 retsig = 66 + (currsig - 30);
5224         }
5225         else if(currsig >= 21 && currsig <= 30)
5226         {
5227                 retsig = 54 + (currsig - 20);
5228         }
5229         else if(currsig >= 5 && currsig <= 20)
5230         {
5231                 retsig = 42 + (((currsig - 5) * 2) / 3);
5232         }
5233         else if(currsig == 4)
5234         {
5235                 retsig = 36;
5236         }
5237         else if(currsig == 3)
5238         {
5239                 retsig = 27;
5240         }
5241         else if(currsig == 2)
5242         {
5243                 retsig = 18;
5244         }
5245         else if(currsig == 1)
5246         {
5247                 retsig = 9;
5248         }
5249         else
5250         {
5251                 retsig = currsig;
5252         }
5253
5254         return retsig;
5255 }
5256
5257 static void rtl8192_query_rxphystatus(
5258         struct r8192_priv * priv,
5259         struct ieee80211_rx_stats * pstats,
5260         prx_desc_819x_pci  pdesc,
5261         prx_fwinfo_819x_pci   pdrvinfo,
5262         struct ieee80211_rx_stats * precord_stats,
5263         bool bpacket_match_bssid,
5264         bool bpacket_toself,
5265         bool bPacketBeacon,
5266         bool bToSelfBA
5267         )
5268 {
5269         //PRT_RFD_STATUS                pRtRfdStatus = &(pRfd->Status);
5270         phy_sts_ofdm_819xpci_t* pofdm_buf;
5271         phy_sts_cck_819xpci_t   *       pcck_buf;
5272         phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
5273         u8                              *prxpkt;
5274         u8                              i,max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
5275         char                            rx_pwr[4], rx_pwr_all=0;
5276         //long                          rx_avg_pwr = 0;
5277         char                            rx_snrX, rx_evmX;
5278         u8                              evm, pwdb_all;
5279         u32                     RSSI, total_rssi=0;//, total_evm=0;
5280 //      long                            signal_strength_index = 0;
5281         u8                              is_cck_rate=0;
5282         u8                              rf_rx_num = 0;
5283
5284         /* 2007/07/04 MH For OFDM RSSI. For high power or not. */
5285         static  u8              check_reg824 = 0;
5286         static  u32             reg824_bit9 = 0;
5287
5288         priv->stats.numqry_phystatus++;
5289
5290         is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
5291
5292         // Record it for next packet processing
5293         memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
5294         pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
5295         pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
5296         pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
5297         pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
5298         pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
5299         /*2007.08.30 requested by SD3 Jerry */
5300         if(check_reg824 == 0)
5301         {
5302                 reg824_bit9 = rtl8192_QueryBBReg(priv->ieee80211->dev, rFPGA0_XA_HSSIParameter2, 0x200);
5303                 check_reg824 = 1;
5304         }
5305
5306
5307         prxpkt = (u8*)pdrvinfo;
5308
5309         /* Move pointer to the 16th bytes. Phy status start address. */
5310         prxpkt += sizeof(rx_fwinfo_819x_pci);
5311
5312         /* Initial the cck and ofdm buffer pointer */
5313         pcck_buf = (phy_sts_cck_819xpci_t *)prxpkt;
5314         pofdm_buf = (phy_sts_ofdm_819xpci_t *)prxpkt;
5315
5316         pstats->RxMIMOSignalQuality[0] = -1;
5317         pstats->RxMIMOSignalQuality[1] = -1;
5318         precord_stats->RxMIMOSignalQuality[0] = -1;
5319         precord_stats->RxMIMOSignalQuality[1] = -1;
5320
5321         if(is_cck_rate)
5322         {
5323                 //
5324                 // (1)Hardware does not provide RSSI for CCK
5325                 //
5326
5327                 //
5328                 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5329                 //
5330                 u8 report;//, cck_agc_rpt;
5331 #ifdef RTL8190P
5332                 u8 tmp_pwdb;
5333                 char cck_adc_pwdb[4];
5334 #endif
5335                 priv->stats.numqry_phystatusCCK++;
5336
5337 #ifdef RTL8190P //Only 90P 2T4R need to check
5338                 if(priv->rf_type == RF_2T4R && DM_RxPathSelTable.Enable && bpacket_match_bssid)
5339                 {
5340                         for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5341                         {
5342                                 tmp_pwdb = pcck_buf->adc_pwdb_X[i];
5343                                 cck_adc_pwdb[i] = (char)tmp_pwdb;
5344                                 cck_adc_pwdb[i] /= 2;
5345                                 pstats->cck_adc_pwdb[i] = precord_stats->cck_adc_pwdb[i] = cck_adc_pwdb[i];
5346                                 //DbgPrint("RF-%d tmp_pwdb = 0x%x, cck_adc_pwdb = %d", i, tmp_pwdb, cck_adc_pwdb[i]);
5347                         }
5348                 }
5349 #endif
5350
5351                 if(!reg824_bit9)
5352                 {
5353                         report = pcck_buf->cck_agc_rpt & 0xc0;
5354                         report = report>>6;
5355                         switch(report)
5356                         {
5357                                 //Fixed by Jacken from Bryant 2008-03-20
5358                                 //Original value is -38 , -26 , -14 , -2
5359                                 //Fixed value is -35 , -23 , -11 , 6
5360                                 case 0x3:
5361                                         rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5362                                         break;
5363                                 case 0x2:
5364                                         rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5365                                         break;
5366                                 case 0x1:
5367                                         rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5368                                         break;
5369                                 case 0x0:
5370                                         rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);
5371                                         break;
5372                         }
5373                 }
5374                 else
5375                 {
5376                         report = pcck_buf->cck_agc_rpt & 0x60;
5377                         report = report>>5;
5378                         switch(report)
5379                         {
5380                                 case 0x3:
5381                                         rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5382                                         break;
5383                                 case 0x2:
5384                                         rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5385                                         break;
5386                                 case 0x1:
5387                                         rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5388                                         break;
5389                                 case 0x0:
5390                                         rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5391                                         break;
5392                         }
5393                 }
5394
5395                 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5396                 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5397                 pstats->RecvSignalPower = rx_pwr_all;
5398
5399                 //
5400                 // (3) Get Signal Quality (EVM)
5401                 //
5402                 if(bpacket_match_bssid)
5403                 {
5404                         u8      sq;
5405
5406                         if(pstats->RxPWDBAll > 40)
5407                         {
5408                                 sq = 100;
5409                         }else
5410                         {
5411                                 sq = pcck_buf->sq_rpt;
5412
5413                                 if(pcck_buf->sq_rpt > 64)
5414                                         sq = 0;
5415                                 else if (pcck_buf->sq_rpt < 20)
5416                                         sq = 100;
5417                                 else
5418                                         sq = ((64-sq) * 100) / 44;
5419                         }
5420                         pstats->SignalQuality = precord_stats->SignalQuality = sq;
5421                         pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5422                         pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5423                 }
5424         }
5425         else
5426         {
5427                 priv->stats.numqry_phystatusHT++;
5428                 //
5429                 // (1)Get RSSI for HT rate
5430                 //
5431                 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
5432                 {
5433                         // 2008/01/30 MH we will judge RF RX path now.
5434                         if (priv->brfpath_rxenable[i])
5435                                 rf_rx_num++;
5436                         //else
5437                                 //continue;
5438
5439                         //Fixed by Jacken from Bryant 2008-03-20
5440                         //Original value is 106
5441 #ifdef RTL8190P    //Modify by Jacken 2008/03/31
5442                         rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5443 #else
5444                         rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 110;
5445 #endif
5446
5447                         //Get Rx snr value in DB
5448                         tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5449                         rx_snrX = (char)(tmp_rxsnr);
5450                         rx_snrX /= 2;
5451                         priv->stats.rxSNRdB[i] = (long)rx_snrX;
5452
5453                         /* Translate DBM to percentage. */
5454                         RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5455                         if (priv->brfpath_rxenable[i])
5456                                 total_rssi += RSSI;
5457
5458                         /* Record Signal Strength for next packet */
5459                         if(bpacket_match_bssid)
5460                         {
5461                                 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5462                                 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5463                         }
5464                 }
5465
5466
5467                 //
5468                 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5469                 //
5470                 //Fixed by Jacken from Bryant 2008-03-20
5471                 //Original value is 106
5472                 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5473                 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5474
5475                 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5476                 pstats->RxPower = precord_stats->RxPower =      rx_pwr_all;
5477                 pstats->RecvSignalPower = rx_pwr_all;
5478                 //
5479                 // (3)EVM of HT rate
5480                 //
5481                 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5482                         pdrvinfo->RxRate<=DESC90_RATEMCS15)
5483                         max_spatial_stream = 2; //both spatial stream make sense
5484                 else
5485                         max_spatial_stream = 1; //only spatial stream 1 makes sense
5486
5487                 for(i=0; i<max_spatial_stream; i++)
5488                 {
5489                         tmp_rxevm = pofdm_buf->rxevm_X[i];
5490                         rx_evmX = (char)(tmp_rxevm);
5491
5492                         // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5493                         // fill most significant bit to "zero" when doing shifting operation which may change a negative
5494                         // value to positive one, then the dbm value (which is supposed to be negative)  is not correct anymore.
5495                         rx_evmX /= 2;   //dbm
5496
5497                         evm = rtl819x_evm_dbtopercentage(rx_evmX);
5498 #if 0
5499                         EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
5500 #endif
5501                         if(bpacket_match_bssid)
5502                         {
5503                                 if(i==0) // Fill value in RFD, Get the first spatial stream only
5504                                         pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5505                                 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5506                         }
5507                 }
5508
5509
5510                 /* record rx statistics for debug */
5511                 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5512                 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5513                 if(pdrvinfo->BW)        //40M channel
5514                         priv->stats.received_bwtype[1+prxsc->rxsc]++;
5515                 else                            //20M channel
5516                         priv->stats.received_bwtype[0]++;
5517         }
5518
5519         //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5520         //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5521         if(is_cck_rate)
5522         {
5523                 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5524
5525         }
5526         else
5527         {
5528                 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u1Byte)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u1Byte)(total_rssi/=RF90_PATH_MAX);
5529                 // We can judge RX path number now.
5530                 if (rf_rx_num != 0)
5531                         pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5532         }
5533 }
5534
5535 static void
5536 rtl8192_record_rxdesc_forlateruse(
5537         struct ieee80211_rx_stats * psrc_stats,
5538         struct ieee80211_rx_stats * ptarget_stats
5539 )
5540 {
5541         ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5542         ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5543         //ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5544 }
5545
5546
5547
5548 static void TranslateRxSignalStuff819xpci(struct net_device *dev,
5549         struct sk_buff *skb,
5550         struct ieee80211_rx_stats * pstats,
5551         prx_desc_819x_pci pdesc,
5552         prx_fwinfo_819x_pci pdrvinfo)
5553 {
5554     // TODO: We must only check packet for current MAC address. Not finish
5555     struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5556     bool bpacket_match_bssid, bpacket_toself;
5557     bool bPacketBeacon=false, bToSelfBA=false;
5558     static struct ieee80211_rx_stats  previous_stats;
5559     struct ieee80211_hdr_3addr *hdr;
5560     u16 fc,type;
5561
5562     // Get Signal Quality for only RX data queue (but not command queue)
5563
5564     u8* tmp_buf;
5565     u8  *praddr;
5566
5567     /* Get MAC frame start address. */
5568     tmp_buf = skb->data;
5569
5570     hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5571     fc = le16_to_cpu(hdr->frame_ctl);
5572     type = WLAN_FC_GET_TYPE(fc);
5573     praddr = hdr->addr1;
5574
5575     /* Check if the received packet is acceptabe. */
5576     bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5577             (eqMacAddr(priv->ieee80211->current_network.bssid,  (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5578             && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5579     bpacket_toself =  bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5580 #if 1//cosa
5581     if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5582     {
5583         bPacketBeacon = true;
5584         //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5585     }
5586     if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5587     {
5588         if((eqMacAddr(praddr,dev->dev_addr)))
5589             bToSelfBA = true;
5590         //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5591     }
5592
5593 #endif
5594     if(bpacket_match_bssid)
5595     {
5596         priv->stats.numpacket_matchbssid++;
5597     }
5598     if(bpacket_toself){
5599         priv->stats.numpacket_toself++;
5600     }
5601     //
5602     // Process PHY information for previous packet (RSSI/PWDB/EVM)
5603     //
5604     // Because phy information is contained in the last packet of AMPDU only, so driver
5605     // should process phy information of previous packet
5606     rtl8192_process_phyinfo(priv, tmp_buf,&previous_stats, pstats);
5607     rtl8192_query_rxphystatus(priv, pstats, pdesc, pdrvinfo, &previous_stats, bpacket_match_bssid,
5608             bpacket_toself ,bPacketBeacon, bToSelfBA);
5609     rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5610
5611 }
5612
5613
5614 static void rtl8192_tx_resume(struct net_device *dev)
5615 {
5616         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5617         struct ieee80211_device *ieee = priv->ieee80211;
5618         struct sk_buff *skb;
5619         int queue_index;
5620
5621         for(queue_index = BK_QUEUE; queue_index < TXCMD_QUEUE;queue_index++) {
5622                 while((!skb_queue_empty(&ieee->skb_waitQ[queue_index]))&&
5623                                 (priv->ieee80211->check_nic_enough_desc(dev,queue_index) > 0)) {
5624                         /* 1. dequeue the packet from the wait queue */
5625                         skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
5626                         /* 2. tx the packet directly */
5627                         ieee->softmac_data_hard_start_xmit(skb,dev,0/* rate useless now*/);
5628                         #if 0
5629                         if(queue_index!=MGNT_QUEUE) {
5630                                 ieee->stats.tx_packets++;
5631                                 ieee->stats.tx_bytes += skb->len;
5632                         }
5633                         #endif
5634                 }
5635         }
5636 }
5637
5638 static void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
5639 {
5640        rtl8192_tx_resume(priv->ieee80211->dev);
5641 }
5642
5643 /* Record the received data rate */
5644 static void UpdateReceivedRateHistogramStatistics8190(
5645         struct net_device *dev,
5646         struct ieee80211_rx_stats* pstats
5647         )
5648 {
5649         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5650         u32 rcvType=1;   //0: Total, 1:OK, 2:CRC, 3:ICV
5651         u32 rateIndex;
5652         u32 preamble_guardinterval;  //1: short preamble/GI, 0: long preamble/GI
5653
5654         if(pstats->bCRC)
5655                 rcvType = 2;
5656         else if(pstats->bICV)
5657                 rcvType = 3;
5658
5659         if(pstats->bShortPreamble)
5660                 preamble_guardinterval = 1;// short
5661         else
5662                 preamble_guardinterval = 0;// long
5663
5664         switch(pstats->rate)
5665         {
5666                 //
5667                 // CCK rate
5668                 //
5669                 case MGN_1M:    rateIndex = 0;  break;
5670                 case MGN_2M:    rateIndex = 1;  break;
5671                 case MGN_5_5M:  rateIndex = 2;  break;
5672                 case MGN_11M:   rateIndex = 3;  break;
5673                 //
5674                 // Legacy OFDM rate
5675                 //
5676                 case MGN_6M:    rateIndex = 4;  break;
5677                 case MGN_9M:    rateIndex = 5;  break;
5678                 case MGN_12M:   rateIndex = 6;  break;
5679                 case MGN_18M:   rateIndex = 7;  break;
5680                 case MGN_24M:   rateIndex = 8;  break;
5681                 case MGN_36M:   rateIndex = 9;  break;
5682                 case MGN_48M:   rateIndex = 10; break;
5683                 case MGN_54M:   rateIndex = 11; break;
5684                 //
5685                 // 11n High throughput rate
5686                 //
5687                 case MGN_MCS0:  rateIndex = 12; break;
5688                 case MGN_MCS1:  rateIndex = 13; break;
5689                 case MGN_MCS2:  rateIndex = 14; break;
5690                 case MGN_MCS3:  rateIndex = 15; break;
5691                 case MGN_MCS4:  rateIndex = 16; break;
5692                 case MGN_MCS5:  rateIndex = 17; break;
5693                 case MGN_MCS6:  rateIndex = 18; break;
5694                 case MGN_MCS7:  rateIndex = 19; break;
5695                 case MGN_MCS8:  rateIndex = 20; break;
5696                 case MGN_MCS9:  rateIndex = 21; break;
5697                 case MGN_MCS10: rateIndex = 22; break;
5698                 case MGN_MCS11: rateIndex = 23; break;
5699                 case MGN_MCS12: rateIndex = 24; break;
5700                 case MGN_MCS13: rateIndex = 25; break;
5701                 case MGN_MCS14: rateIndex = 26; break;
5702                 case MGN_MCS15: rateIndex = 27; break;
5703                 default:        rateIndex = 28; break;
5704         }
5705         priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5706         priv->stats.received_rate_histogram[0][rateIndex]++; //total
5707         priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5708 }
5709
5710 static void rtl8192_rx(struct net_device *dev)
5711 {
5712     struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5713     struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5714     bool unicast_packet = false;
5715     struct ieee80211_rx_stats stats = {
5716         .signal = 0,
5717         .noise = -98,
5718         .rate = 0,
5719         .freq = IEEE80211_24GHZ_BAND,
5720     };
5721     unsigned int count = priv->rxringcount;
5722
5723     stats.nic_type = NIC_8192E;
5724
5725     while (count--) {
5726         rx_desc_819x_pci *pdesc = &priv->rx_ring[priv->rx_idx];//rx descriptor
5727         struct sk_buff *skb = priv->rx_buf[priv->rx_idx];//rx pkt
5728
5729         if (pdesc->OWN){
5730             /* wait data to be filled by hardware */
5731             return;
5732         } else {
5733             stats.bICV = pdesc->ICV;
5734             stats.bCRC = pdesc->CRC32;
5735             stats.bHwError = pdesc->CRC32 | pdesc->ICV;
5736
5737             stats.Length = pdesc->Length;
5738             if(stats.Length < 24)
5739                 stats.bHwError |= 1;
5740
5741             if(stats.bHwError) {
5742                 stats.bShift = false;
5743
5744                 if(pdesc->CRC32) {
5745                     if (pdesc->Length <500)
5746                         priv->stats.rxcrcerrmin++;
5747                     else if (pdesc->Length >1000)
5748                         priv->stats.rxcrcerrmax++;
5749                     else
5750                         priv->stats.rxcrcerrmid++;
5751                 }
5752                 goto done;
5753             } else {
5754                 prx_fwinfo_819x_pci pDrvInfo = NULL;
5755                 struct sk_buff *new_skb = dev_alloc_skb(priv->rxbuffersize);
5756
5757                 if (unlikely(!new_skb)) {
5758                     goto done;
5759                 }
5760
5761                 stats.RxDrvInfoSize = pdesc->RxDrvInfoSize;
5762                 stats.RxBufShift = ((pdesc->Shift)&0x03);
5763                 stats.Decrypted = !pdesc->SWDec;
5764
5765                 pci_dma_sync_single_for_cpu(priv->pdev,
5766                      *((dma_addr_t *)skb->cb),
5767                      priv->rxbuffersize,
5768                      PCI_DMA_FROMDEVICE);
5769                 skb_put(skb, pdesc->Length);
5770                 pDrvInfo = (rx_fwinfo_819x_pci *)(skb->data + stats.RxBufShift);
5771                 skb_reserve(skb, stats.RxDrvInfoSize + stats.RxBufShift);
5772
5773                 stats.rate = HwRateToMRate90((bool)pDrvInfo->RxHT, (u8)pDrvInfo->RxRate);
5774                 stats.bShortPreamble = pDrvInfo->SPLCP;
5775
5776                 /* it is debug only. It should be disabled in released driver.
5777                  * 2007.1.11 by Emily
5778                  * */
5779                 UpdateReceivedRateHistogramStatistics8190(dev, &stats);
5780
5781                 stats.bIsAMPDU = (pDrvInfo->PartAggr==1);
5782                 stats.bFirstMPDU = (pDrvInfo->PartAggr==1) && (pDrvInfo->FirstAGGR==1);
5783
5784                 stats.TimeStampLow = pDrvInfo->TSFL;
5785                 stats.TimeStampHigh = read_nic_dword(dev, TSFR+4);
5786
5787                 UpdateRxPktTimeStamp8190(dev, &stats);
5788
5789                 //
5790                 // Get Total offset of MPDU Frame Body
5791                 //
5792                 if((stats.RxBufShift + stats.RxDrvInfoSize) > 0)
5793                     stats.bShift = 1;
5794
5795                 stats.RxIs40MHzPacket = pDrvInfo->BW;
5796
5797                 /* ???? */
5798                 TranslateRxSignalStuff819xpci(dev,skb, &stats, pdesc, pDrvInfo);
5799
5800                 /* Rx A-MPDU */
5801                 if(pDrvInfo->FirstAGGR==1 || pDrvInfo->PartAggr == 1)
5802                     RT_TRACE(COMP_RXDESC, "pDrvInfo->FirstAGGR = %d, pDrvInfo->PartAggr = %d\n",
5803                             pDrvInfo->FirstAGGR, pDrvInfo->PartAggr);
5804                    skb_trim(skb, skb->len - 4/*sCrcLng*/);
5805                 /* rx packets statistics */
5806                 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5807                 unicast_packet = false;
5808
5809                 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5810                     //TODO
5811                 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5812                     //TODO
5813                 }else {
5814                     /* unicast packet */
5815                     unicast_packet = true;
5816                 }
5817
5818                 stats.packetlength = stats.Length-4;
5819                 stats.fraglength = stats.packetlength;
5820                 stats.fragoffset = 0;
5821                 stats.ntotalfrag = 1;
5822
5823                 if(!ieee80211_rtl_rx(priv->ieee80211, skb, &stats)){
5824                     dev_kfree_skb_any(skb);
5825                 } else {
5826                     priv->stats.rxok++;
5827                     if(unicast_packet) {
5828                         priv->stats.rxbytesunicast += skb->len;
5829                     }
5830                 }
5831
5832                 pci_unmap_single(priv->pdev, *((dma_addr_t *) skb->cb),
5833                         priv->rxbuffersize, PCI_DMA_FROMDEVICE);
5834
5835                 skb = new_skb;
5836                 priv->rx_buf[priv->rx_idx] = skb;
5837                 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev, skb_tail_pointer(skb), priv->rxbuffersize, PCI_DMA_FROMDEVICE);
5838             }
5839
5840         }
5841 done:
5842         pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
5843         pdesc->OWN = 1;
5844         pdesc->Length = priv->rxbuffersize;
5845         if (priv->rx_idx == priv->rxringcount-1)
5846             pdesc->EOR = 1;
5847         priv->rx_idx = (priv->rx_idx + 1) % priv->rxringcount;
5848     }
5849
5850 }
5851
5852 static void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5853 {
5854        rtl8192_rx(priv->ieee80211->dev);
5855         /* unmask RDU */
5856        write_nic_dword(priv->ieee80211->dev, INTA_MASK,read_nic_dword(priv->ieee80211->dev, INTA_MASK) | IMR_RDU);
5857 }
5858
5859 static const struct net_device_ops rtl8192_netdev_ops = {
5860         .ndo_open =                     rtl8192_open,
5861         .ndo_stop =                     rtl8192_close,
5862         .ndo_tx_timeout =               tx_timeout,
5863         .ndo_do_ioctl =                 rtl8192_ioctl,
5864         .ndo_set_multicast_list =       r8192_set_multicast,
5865         .ndo_set_mac_address =          r8192_set_mac_adr,
5866         .ndo_start_xmit =               ieee80211_rtl_xmit,
5867 };
5868
5869 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
5870                          const struct pci_device_id *id)
5871 {
5872         unsigned long ioaddr = 0;
5873         struct net_device *dev = NULL;
5874         struct r8192_priv *priv= NULL;
5875         u8 unit = 0;
5876         int ret = -ENODEV;
5877
5878 #ifdef CONFIG_RTL8192_IO_MAP
5879         unsigned long pio_start, pio_len, pio_flags;
5880 #else
5881         unsigned long pmem_start, pmem_len, pmem_flags;
5882 #endif //end #ifdef RTL_IO_MAP
5883
5884         RT_TRACE(COMP_INIT,"Configuring chip resources");
5885
5886         if( pci_enable_device (pdev) ){
5887                 RT_TRACE(COMP_ERR,"Failed to enable PCI device");
5888                 return -EIO;
5889         }
5890
5891         pci_set_master(pdev);
5892         //pci_set_wmi(pdev);
5893         pci_set_dma_mask(pdev, 0xffffff00ULL);
5894         pci_set_consistent_dma_mask(pdev,0xffffff00ULL);
5895         dev = alloc_ieee80211(sizeof(struct r8192_priv));
5896         if (!dev) {
5897                 ret = -ENOMEM;
5898                 goto fail_free;
5899         }
5900
5901         pci_set_drvdata(pdev, dev);
5902         SET_NETDEV_DEV(dev, &pdev->dev);
5903         priv = ieee80211_priv(dev);
5904         priv->ieee80211 = netdev_priv(dev);
5905         priv->pdev=pdev;
5906         if((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK)&&(pdev->subsystem_device == 0x3304)){
5907                 priv->ieee80211->bSupportRemoteWakeUp = 1;
5908         } else
5909         {
5910                 priv->ieee80211->bSupportRemoteWakeUp = 0;
5911         }
5912
5913 #ifdef CONFIG_RTL8192_IO_MAP
5914
5915         pio_start = (unsigned long)pci_resource_start (pdev, 0);
5916         pio_len = (unsigned long)pci_resource_len (pdev, 0);
5917         pio_flags = (unsigned long)pci_resource_flags (pdev, 0);
5918
5919         if (!(pio_flags & IORESOURCE_IO)) {
5920                 RT_TRACE(COMP_ERR,"region #0 not a PIO resource, aborting");
5921                 goto fail;
5922         }
5923
5924         //DMESG("IO space @ 0x%08lx", pio_start );
5925         if( ! request_region( pio_start, pio_len, RTL819xE_MODULE_NAME ) ){
5926                 RT_TRACE(COMP_ERR,"request_region failed!");
5927                 goto fail;
5928         }
5929
5930         ioaddr = pio_start;
5931         dev->base_addr = ioaddr; // device I/O address
5932
5933 #else
5934
5935         pmem_start = pci_resource_start(pdev, 1);
5936         pmem_len = pci_resource_len(pdev, 1);
5937         pmem_flags = pci_resource_flags (pdev, 1);
5938
5939         if (!(pmem_flags & IORESOURCE_MEM)) {
5940                 RT_TRACE(COMP_ERR,"region #1 not a MMIO resource, aborting");
5941                 goto fail;
5942         }
5943
5944         //DMESG("Memory mapped space @ 0x%08lx ", pmem_start);
5945         if( ! request_mem_region(pmem_start, pmem_len, RTL819xE_MODULE_NAME)) {
5946                 RT_TRACE(COMP_ERR,"request_mem_region failed!");
5947                 goto fail;
5948         }
5949
5950
5951         ioaddr = (unsigned long)ioremap_nocache( pmem_start, pmem_len);
5952         if( ioaddr == (unsigned long)NULL ){
5953                 RT_TRACE(COMP_ERR,"ioremap failed!");
5954                // release_mem_region( pmem_start, pmem_len );
5955                 goto fail1;
5956         }
5957
5958         dev->mem_start = ioaddr; // shared mem start
5959         dev->mem_end = ioaddr + pci_resource_len(pdev, 0); // shared mem end
5960
5961 #endif //end #ifdef RTL_IO_MAP
5962
5963         /* We disable the RETRY_TIMEOUT register (0x41) to keep
5964          * PCI Tx retries from interfering with C3 CPU state */
5965          pci_write_config_byte(pdev, 0x41, 0x00);
5966
5967
5968         pci_read_config_byte(pdev, 0x05, &unit);
5969         pci_write_config_byte(pdev, 0x05, unit & (~0x04));
5970
5971         dev->irq = pdev->irq;
5972         priv->irq = 0;
5973
5974         dev->netdev_ops = &rtl8192_netdev_ops;
5975 #if 0
5976         dev->open = rtl8192_open;
5977         dev->stop = rtl8192_close;
5978         //dev->hard_start_xmit = rtl8192_8023_hard_start_xmit;
5979         dev->tx_timeout = tx_timeout;
5980         //dev->wireless_handlers = &r8192_wx_handlers_def;
5981         dev->do_ioctl = rtl8192_ioctl;
5982         dev->set_multicast_list = r8192_set_multicast;
5983         dev->set_mac_address = r8192_set_mac_adr;
5984 #endif
5985
5986          //DMESG("Oops: i'm coming\n");
5987 #if WIRELESS_EXT >= 12
5988 #if WIRELESS_EXT < 17
5989         dev->get_wireless_stats = r8192_get_wireless_stats;
5990 #endif
5991         dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5992 #endif
5993        //dev->get_wireless_stats = r8192_get_wireless_stats;
5994         dev->type=ARPHRD_ETHER;
5995
5996         dev->watchdog_timeo = HZ*3;     //modified by john, 0805
5997
5998         if (dev_alloc_name(dev, ifname) < 0){
5999                 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
6000                 strcpy(ifname, "wlan%d");
6001                 dev_alloc_name(dev, ifname);
6002         }
6003
6004         RT_TRACE(COMP_INIT, "Driver probe completed1\n");
6005         if(rtl8192_init(dev)!=0){
6006                 RT_TRACE(COMP_ERR, "Initialization failed");
6007                 goto fail;
6008         }
6009
6010         netif_carrier_off(dev);
6011         netif_stop_queue(dev);
6012
6013         register_netdev(dev);
6014         RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
6015         rtl8192_proc_init_one(dev);
6016
6017
6018         RT_TRACE(COMP_INIT, "Driver probe completed\n");
6019         return 0;
6020
6021 fail1:
6022
6023 #ifdef CONFIG_RTL8180_IO_MAP
6024
6025         if( dev->base_addr != 0 ){
6026
6027                 release_region(dev->base_addr,
6028                pci_resource_len(pdev, 0) );
6029         }
6030 #else
6031         if( dev->mem_start != (unsigned long)NULL ){
6032                 iounmap( (void *)dev->mem_start );
6033                 release_mem_region( pci_resource_start(pdev, 1),
6034                                     pci_resource_len(pdev, 1) );
6035         }
6036 #endif //end #ifdef RTL_IO_MAP
6037
6038 fail:
6039         if(dev){
6040
6041                 if (priv->irq) {
6042                         free_irq(dev->irq, dev);
6043                         dev->irq=0;
6044                 }
6045                 free_ieee80211(dev);
6046         }
6047
6048 fail_free:
6049         pci_disable_device(pdev);
6050
6051         DMESG("wlan driver load failed\n");
6052         pci_set_drvdata(pdev, NULL);
6053         return ret;
6054
6055 }
6056
6057 /* detach all the work and timer structure declared or inititialized
6058  * in r8192_init function.
6059  * */
6060 static void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
6061 {
6062         /* call cancel_work_sync instead of cancel_delayed_work if and only if Linux_version_code
6063          * is  or is newer than 2.6.20 and work structure is defined to be struct work_struct.
6064          * Otherwise call cancel_delayed_work is enough.
6065          * FIXME (2.6.20 should 2.6.22, work_struct should not cancel)
6066          * */
6067         cancel_delayed_work(&priv->watch_dog_wq);
6068         cancel_delayed_work(&priv->update_beacon_wq);
6069         cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
6070         cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
6071 #ifdef RTL8192E
6072         cancel_delayed_work(&priv->gpio_change_rf_wq);
6073 #endif
6074         cancel_work_sync(&priv->reset_wq);
6075         cancel_work_sync(&priv->qos_activate);
6076         //cancel_work_sync(&priv->SetBWModeWorkItem);
6077         //cancel_work_sync(&priv->SwChnlWorkItem);
6078
6079 }
6080
6081
6082 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
6083 {
6084         struct net_device *dev = pci_get_drvdata(pdev);
6085         struct r8192_priv *priv ;
6086
6087         if(dev){
6088
6089                 unregister_netdev(dev);
6090
6091                 priv=ieee80211_priv(dev);
6092
6093                 rtl8192_proc_remove_one(dev);
6094
6095                 rtl8192_down(dev);
6096                 if (priv->pFirmware)
6097                 {
6098                         vfree(priv->pFirmware);
6099                         priv->pFirmware = NULL;
6100                 }
6101         //      priv->rf_close(dev);
6102         //      rtl8192_usb_deleteendpoints(dev);
6103                 destroy_workqueue(priv->priv_wq);
6104                 /* redundant with rtl8192_down */
6105                // rtl8192_irq_disable(dev);
6106                // rtl8192_reset(dev);
6107                // mdelay(10);
6108                 {
6109                     u32 i;
6110                     /* free tx/rx rings */
6111                     rtl8192_free_rx_ring(dev);
6112                     for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
6113                         rtl8192_free_tx_ring(dev, i);
6114                     }
6115                 }
6116                 if(priv->irq){
6117
6118                         printk("Freeing irq %d\n",dev->irq);
6119                         free_irq(dev->irq, dev);
6120                         priv->irq=0;
6121
6122                 }
6123
6124
6125
6126         //      free_beacon_desc_ring(dev,priv->txbeaconcount);
6127
6128 #ifdef CONFIG_RTL8180_IO_MAP
6129
6130                 if( dev->base_addr != 0 ){
6131
6132                         release_region(dev->base_addr,
6133                                        pci_resource_len(pdev, 0) );
6134                 }
6135 #else
6136                 if( dev->mem_start != (unsigned long)NULL ){
6137                         iounmap( (void *)dev->mem_start );
6138                         release_mem_region( pci_resource_start(pdev, 1),
6139                                             pci_resource_len(pdev, 1) );
6140                 }
6141 #endif /*end #ifdef RTL_IO_MAP*/
6142                 free_ieee80211(dev);
6143
6144         }
6145
6146         pci_disable_device(pdev);
6147         RT_TRACE(COMP_DOWN, "wlan driver removed\n");
6148 }
6149
6150 extern int ieee80211_rtl_init(void);
6151 extern void ieee80211_rtl_exit(void);
6152
6153 static int __init rtl8192_pci_module_init(void)
6154 {
6155         int retval;
6156
6157         retval = ieee80211_rtl_init();
6158         if (retval)
6159                 return retval;
6160
6161         printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
6162         printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
6163         RT_TRACE(COMP_INIT, "Initializing module");
6164         RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
6165         rtl8192_proc_module_init();
6166       if(0!=pci_register_driver(&rtl8192_pci_driver))
6167         {
6168                 DMESG("No device found");
6169                 /*pci_unregister_driver (&rtl8192_pci_driver);*/
6170                 return -ENODEV;
6171         }
6172         return 0;
6173 }
6174
6175
6176 static void __exit rtl8192_pci_module_exit(void)
6177 {
6178         pci_unregister_driver(&rtl8192_pci_driver);
6179
6180         RT_TRACE(COMP_DOWN, "Exiting");
6181         rtl8192_proc_module_remove();
6182         ieee80211_rtl_exit();
6183 }
6184
6185 //warning message WB
6186 static irqreturn_t rtl8192_interrupt(int irq, void *netdev)
6187 {
6188     struct net_device *dev = (struct net_device *) netdev;
6189     struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6190     unsigned long flags;
6191     u32 inta;
6192     /* We should return IRQ_NONE, but for now let me keep this */
6193     if(priv->irq_enabled == 0){
6194         return IRQ_HANDLED;
6195     }
6196
6197     spin_lock_irqsave(&priv->irq_th_lock,flags);
6198
6199     //ISR: 4bytes
6200
6201     inta = read_nic_dword(dev, ISR);// & priv->IntrMask;
6202     write_nic_dword(dev,ISR,inta); // reset int situation
6203
6204     priv->stats.shints++;
6205     //DMESG("Enter interrupt, ISR value = 0x%08x", inta);
6206     if(!inta){
6207         spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6208         return IRQ_HANDLED;
6209         /*
6210            most probably we can safely return IRQ_NONE,
6211            but for now is better to avoid problems
6212            */
6213     }
6214
6215     if(inta == 0xffff){
6216         /* HW disappared */
6217         spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6218         return IRQ_HANDLED;
6219     }
6220
6221     priv->stats.ints++;
6222 #ifdef DEBUG_IRQ
6223     DMESG("NIC irq %x",inta);
6224 #endif
6225     //priv->irqpending = inta;
6226
6227
6228     if(!netif_running(dev)) {
6229         spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6230         return IRQ_HANDLED;
6231     }
6232
6233     if(inta & IMR_TIMEOUT0){
6234         //              write_nic_dword(dev, TimerInt, 0);
6235         //DMESG("=================>waking up");
6236         //              rtl8180_hw_wakeup(dev);
6237     }
6238
6239     if(inta & IMR_TBDOK){
6240         RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6241         rtl8192_tx_isr(dev, BEACON_QUEUE);
6242         priv->stats.txbeaconokint++;
6243     }
6244
6245     if(inta & IMR_TBDER){
6246         RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
6247         rtl8192_tx_isr(dev, BEACON_QUEUE);
6248         priv->stats.txbeaconerr++;
6249     }
6250
6251     if(inta  & IMR_MGNTDOK ) {
6252         RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
6253         priv->stats.txmanageokint++;
6254         rtl8192_tx_isr(dev,MGNT_QUEUE);
6255
6256     }
6257
6258     if(inta & IMR_COMDOK)
6259     {
6260         priv->stats.txcmdpktokint++;
6261         rtl8192_tx_isr(dev,TXCMD_QUEUE);
6262     }
6263
6264     if(inta & IMR_ROK){
6265 #ifdef DEBUG_RX
6266         DMESG("Frame arrived !");
6267 #endif
6268         priv->stats.rxint++;
6269         tasklet_schedule(&priv->irq_rx_tasklet);
6270     }
6271
6272     if(inta & IMR_BcnInt) {
6273         RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
6274         tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
6275     }
6276
6277     if(inta & IMR_RDU){
6278         RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
6279         priv->stats.rxrdu++;
6280         /* reset int situation */
6281         write_nic_dword(dev,INTA_MASK,read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
6282         tasklet_schedule(&priv->irq_rx_tasklet);
6283     }
6284
6285     if(inta & IMR_RXFOVW){
6286         RT_TRACE(COMP_INTR, "rx overflow !\n");
6287         priv->stats.rxoverflow++;
6288         tasklet_schedule(&priv->irq_rx_tasklet);
6289     }
6290
6291     if(inta & IMR_TXFOVW) priv->stats.txoverflow++;
6292
6293     if(inta & IMR_BKDOK){
6294         RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
6295         priv->stats.txbkokint++;
6296         priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6297         rtl8192_tx_isr(dev,BK_QUEUE);
6298         rtl8192_try_wake_queue(dev, BK_QUEUE);
6299     }
6300
6301     if(inta & IMR_BEDOK){
6302         RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
6303         priv->stats.txbeokint++;
6304         priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6305         rtl8192_tx_isr(dev,BE_QUEUE);
6306         rtl8192_try_wake_queue(dev, BE_QUEUE);
6307     }
6308
6309     if(inta & IMR_VIDOK){
6310         RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
6311         priv->stats.txviokint++;
6312         priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6313         rtl8192_tx_isr(dev,VI_QUEUE);
6314         rtl8192_try_wake_queue(dev, VI_QUEUE);
6315     }
6316
6317     if(inta & IMR_VODOK){
6318         priv->stats.txvookint++;
6319         priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
6320         rtl8192_tx_isr(dev,VO_QUEUE);
6321         rtl8192_try_wake_queue(dev, VO_QUEUE);
6322     }
6323
6324     spin_unlock_irqrestore(&priv->irq_th_lock,flags);
6325
6326     return IRQ_HANDLED;
6327 }
6328
6329 static void rtl8192_try_wake_queue(struct net_device *dev, int pri)
6330 {
6331 }
6332
6333
6334 void EnableHWSecurityConfig8192(struct net_device *dev)
6335 {
6336         u8 SECR_value = 0x0;
6337         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6338         struct ieee80211_device* ieee = priv->ieee80211;
6339
6340         SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
6341 #if 1
6342         if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
6343         {
6344                 SECR_value |= SCR_RxUseDK;
6345                 SECR_value |= SCR_TxUseDK;
6346         }
6347         else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6348         {
6349                 SECR_value |= SCR_RxUseDK;
6350                 SECR_value |= SCR_TxUseDK;
6351         }
6352
6353 #endif
6354
6355         //add HWSec active enable here.
6356 //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
6357         ieee->hwsec_active = 1;
6358
6359         if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep)//!ieee->hwsec_support) //add hwsec_support flag to totol control hw_sec on/off
6360         {
6361                 ieee->hwsec_active = 0;
6362                 SECR_value &= ~SCR_RxDecEnable;
6363         }
6364
6365         RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__,
6366                         ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6367         {
6368                 write_nic_byte(dev, SECR,  SECR_value);//SECR_value |  SCR_UseDK );
6369         }
6370
6371 }
6372 #define TOTAL_CAM_ENTRY 32
6373 //#define CAM_CONTENT_COUNT 8
6374 void setKey(    struct net_device *dev,
6375                 u8 EntryNo,
6376                 u8 KeyIndex,
6377                 u16 KeyType,
6378                 const u8 *MacAddr,
6379                 u8 DefaultKey,
6380                 u32 *KeyContent )
6381 {
6382         u32 TargetCommand = 0;
6383         u32 TargetContent = 0;
6384         u16 usConfig = 0;
6385         u8 i;
6386 #ifdef ENABLE_IPS
6387         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6388         RT_RF_POWER_STATE       rtState;
6389         rtState = priv->ieee80211->eRFPowerState;
6390         if(priv->ieee80211->PowerSaveControl.bInactivePs){
6391                 if(rtState == eRfOff){
6392                         if(priv->ieee80211->RfOffReason > RF_CHANGE_BY_IPS)
6393                         {
6394                                 RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",__FUNCTION__);
6395                                 //up(&priv->wx_sem);
6396                                 return ;
6397                         }
6398                         else{
6399                                 down(&priv->ieee80211->ips_sem);
6400                                 IPSLeave(dev);
6401                                 up(&priv->ieee80211->ips_sem);
6402                         }
6403                 }
6404         }
6405         priv->ieee80211->is_set_key = true;
6406 #endif
6407         if (EntryNo >= TOTAL_CAM_ENTRY)
6408                 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6409
6410         RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6411
6412         if (DefaultKey)
6413                 usConfig |= BIT15 | (KeyType<<2);
6414         else
6415                 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6416 //      usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6417
6418
6419         for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6420                 TargetCommand  = i+CAM_CONTENT_COUNT*EntryNo;
6421                 TargetCommand |= BIT31|BIT16;
6422
6423                 if(i==0){//MAC|Config
6424                         TargetContent = (u32)(*(MacAddr+0)) << 16|
6425                                         (u32)(*(MacAddr+1)) << 24|
6426                                         (u32)usConfig;
6427
6428                         write_nic_dword(dev, WCAMI, TargetContent);
6429                         write_nic_dword(dev, RWCAM, TargetCommand);
6430         //              printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6431                 }
6432                 else if(i==1){//MAC
6433                         TargetContent = (u32)(*(MacAddr+2))      |
6434                                         (u32)(*(MacAddr+3)) <<  8|
6435                                         (u32)(*(MacAddr+4)) << 16|
6436                                         (u32)(*(MacAddr+5)) << 24;
6437                         write_nic_dword(dev, WCAMI, TargetContent);
6438                         write_nic_dword(dev, RWCAM, TargetCommand);
6439                 }
6440                 else {  //Key Material
6441                         if(KeyContent != NULL)
6442                         {
6443                         write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6444                         write_nic_dword(dev, RWCAM, TargetCommand);
6445                 }
6446         }
6447         }
6448         RT_TRACE(COMP_SEC,"=========>after set key, usconfig:%x\n", usConfig);
6449 }
6450
6451 bool NicIFEnableNIC(struct net_device* dev)
6452 {
6453         RT_STATUS init_status = RT_STATUS_SUCCESS;
6454         struct r8192_priv* priv = ieee80211_priv(dev);
6455         PRT_POWER_SAVE_CONTROL pPSC = (PRT_POWER_SAVE_CONTROL)(&(priv->ieee80211->PowerSaveControl));
6456
6457         //YJ,add,091109
6458         if (priv->up == 0){
6459                 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",__FUNCTION__);
6460                 priv->bdisable_nic = false;  //YJ,add,091111
6461                 return false;
6462         }
6463         // <1> Reset memory: descriptor, buffer,..
6464         //NicIFResetMemory(Adapter);
6465
6466         // <2> Enable Adapter
6467         //priv->bfirst_init = true;
6468         init_status = rtl8192_adapter_start(dev);
6469         if (init_status != RT_STATUS_SUCCESS) {
6470                 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n",__FUNCTION__);
6471                 priv->bdisable_nic = false;  //YJ,add,091111
6472                 return -1;
6473         }
6474         //printk("start adapter finished\n");
6475         RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
6476         //priv->bfirst_init = false;
6477
6478         // <3> Enable Interrupt
6479         rtl8192_irq_enable(dev);
6480         priv->bdisable_nic = false;
6481
6482         return (init_status == RT_STATUS_SUCCESS);
6483 }
6484
6485 bool NicIFDisableNIC(struct net_device* dev)
6486 {
6487         bool    status = true;
6488         struct r8192_priv* priv = ieee80211_priv(dev);
6489         u8 tmp_state = 0;
6490         // <1> Disable Interrupt
6491
6492         priv->bdisable_nic = true;      //YJ,move,091109
6493         tmp_state = priv->ieee80211->state;
6494
6495         ieee80211_softmac_stop_protocol(priv->ieee80211, false);
6496
6497         priv->ieee80211->state = tmp_state;
6498         rtl8192_cancel_deferred_work(priv);
6499         rtl8192_irq_disable(dev);
6500         // <2> Stop all timer
6501
6502         // <3> Disable Adapter
6503         rtl8192_halt_adapter(dev, false);
6504 //      priv->bdisable_nic = true;
6505
6506         return status;
6507 }
6508
6509 module_init(rtl8192_pci_module_init);
6510 module_exit(rtl8192_pci_module_exit);