drivers/staging/rtl8192e/rtl_core.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * Based on the r8180 driver, which is:
   5  * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of version 2 of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  18  *
  19  * The full GNU General Public License is included in this distribution in the
  20  * file called LICENSE.
  21  *
  22  * Contact Information:
  23  * wlanfae <wlanfae@realtek.com>
  24 ******************************************************************************/
  25 #undef RX_DONT_PASS_UL
  26 #undef DEBUG_EPROM
  27 #undef DEBUG_RX_VERBOSE
  28 #undef DUMMY_RX
  29 #undef DEBUG_ZERO_RX
  30 #undef DEBUG_RX_SKB
  31 #undef DEBUG_TX_FRAG
  32 #undef DEBUG_RX_FRAG
  33 #undef DEBUG_TX_FILLDESC
  34 #undef DEBUG_TX
  35 #undef DEBUG_IRQ
  36 #undef DEBUG_RX
  37 #undef DEBUG_RXALLOC
  38 #undef DEBUG_REGISTERS
  39 #undef DEBUG_RING
  40 #undef DEBUG_IRQ_TASKLET
  41 #undef DEBUG_TX_ALLOC
  42 #undef DEBUG_TX_DESC
  43
  44 #include <linux/uaccess.h>
  45 #include <linux/pci.h>
  46 #include "rtl_core.h"
  47 #include "r8192E_phy.h"
  48 #include "r8192E_phyreg.h"
  49 #include "r8190P_rtl8256.h"
  50 #include "r8192E_cmdpkt.h"
  51
  52 #include "rtl_wx.h"
  53 #include "rtl_dm.h"
  54
  55 #ifdef CONFIG_PM_RTL
  56 #include "rtl_pm.h"
  57 #endif
  58
  59 int hwwep = 1;
  60 static int channels = 0x3fff;
  61 char *ifname = "wlan%d";
  62
  63
  64 struct rtl819x_ops rtl819xp_ops = {
  65         .nic_type                       = NIC_8192E,
  66         .get_eeprom_size                = rtl8192_get_eeprom_size,
  67         .init_adapter_variable          = rtl8192_InitializeVariables,
  68         .initialize_adapter             = rtl8192_adapter_start,
  69         .link_change                    = rtl8192_link_change,
  70         .tx_fill_descriptor             = rtl8192_tx_fill_desc,
  71         .tx_fill_cmd_descriptor         = rtl8192_tx_fill_cmd_desc,
  72         .rx_query_status_descriptor     = rtl8192_rx_query_status_desc,
  73         .rx_command_packet_handler = NULL,
  74         .stop_adapter                   = rtl8192_halt_adapter,
  75         .update_ratr_table              = rtl8192_update_ratr_table,
  76         .irq_enable                     = rtl8192_EnableInterrupt,
  77         .irq_disable                    = rtl8192_DisableInterrupt,
  78         .irq_clear                      = rtl8192_ClearInterrupt,
  79         .rx_enable                      = rtl8192_enable_rx,
  80         .tx_enable                      = rtl8192_enable_tx,
  81         .interrupt_recognized           = rtl8192_interrupt_recognized,
  82         .TxCheckStuckHandler            = rtl8192_HalTxCheckStuck,
  83         .RxCheckStuckHandler            = rtl8192_HalRxCheckStuck,
  84 };
  85
  86 static struct pci_device_id rtl8192_pci_id_tbl[] __devinitdata = {
  87         {RTL_PCI_DEVICE(0x10ec, 0x8192, rtl819xp_ops)},
  88         {RTL_PCI_DEVICE(0x07aa, 0x0044, rtl819xp_ops)},
  89         {RTL_PCI_DEVICE(0x07aa, 0x0047, rtl819xp_ops)},
  90         {}
  91 };
  92
  93 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
  94
  95 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
  96                         const struct pci_device_id *id);
  97 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev);
  98
  99 static struct pci_driver rtl8192_pci_driver = {
 100         .name = DRV_NAME,       /* Driver name   */
 101         .id_table = rtl8192_pci_id_tbl, /* PCI_ID table  */
 102         .probe  = rtl8192_pci_probe,    /* probe fn      */
 103         .remove  = __devexit_p(rtl8192_pci_disconnect), /* remove fn */
 104         .suspend = rtl8192E_suspend,    /* PM suspend fn */
 105         .resume = rtl8192E_resume,                 /* PM resume fn  */
 106 };
 107
 108 /****************************************************************************
 109    -----------------------------IO STUFF-------------------------
 110 *****************************************************************************/
 111 bool PlatformIOCheckPageLegalAndGetRegMask(u32 u4bPage, u8 *pu1bPageMask)
 112 {
 113         bool            bReturn = false;
 114
 115         *pu1bPageMask = 0xfe;
 116
 117         switch (u4bPage) {
 118         case 1: case 2: case 3: case 4:
 119         case 8: case 9: case 10: case 12: case 13:
 120                 bReturn = true;
 121                 *pu1bPageMask = 0xf0;
 122                 break;
 123
 124         default:
 125                 bReturn = false;
 126                 break;
 127         }
 128
 129         return bReturn;
 130 }
 131
 132 void write_nic_io_byte(struct net_device *dev, int x, u8 y)
 133 {
 134         u32 u4bPage = (x >> 8);
 135         u8 u1PageMask = 0;
 136         bool    bIsLegalPage = false;
 137
 138         if (u4bPage == 0) {
 139                 outb(y&0xff, dev->base_addr + x);
 140
 141         } else {
 142                 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
 143                                &u1PageMask);
 144                 if (bIsLegalPage) {
 145                         u8 u1bPsr = read_nic_io_byte(dev, PSR);
 146
 147                         write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
 148                                           (u8)u4bPage));
 149                         write_nic_io_byte(dev, (x & 0xff), y);
 150                         write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
 151                 }
 152         }
 153 }
 154
 155 void write_nic_io_word(struct net_device *dev, int x, u16 y)
 156 {
 157         u32 u4bPage = (x >> 8);
 158         u8 u1PageMask = 0;
 159         bool    bIsLegalPage = false;
 160
 161         if (u4bPage == 0) {
 162                 outw(y, dev->base_addr + x);
 163         } else {
 164                 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
 165                                                          &u1PageMask);
 166                 if (bIsLegalPage) {
 167                         u8 u1bPsr = read_nic_io_byte(dev, PSR);
 168
 169                         write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
 170                                           (u8)u4bPage));
 171                         write_nic_io_word(dev, (x & 0xff), y);
 172                         write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
 173
 174                 }
 175         }
 176 }
 177
 178 void write_nic_io_dword(struct net_device *dev, int x, u32 y)
 179 {
 180         u32 u4bPage = (x >> 8);
 181         u8 u1PageMask = 0;
 182         bool    bIsLegalPage = false;
 183
 184         if (u4bPage == 0) {
 185                 outl(y, dev->base_addr + x);
 186         } else {
 187                 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
 188                                                  &u1PageMask);
 189                 if (bIsLegalPage) {
 190                         u8 u1bPsr = read_nic_io_byte(dev, PSR);
 191
 192                         write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
 193                                           (u8)u4bPage));
 194                         write_nic_io_dword(dev, (x & 0xff), y);
 195                         write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
 196                 }
 197         }
 198 }
 199
 200 u8 read_nic_io_byte(struct net_device *dev, int x)
 201 {
 202         u32 u4bPage = (x >> 8);
 203         u8 u1PageMask = 0;
 204         bool    bIsLegalPage = false;
 205         u8      Data = 0;
 206
 207         if (u4bPage == 0) {
 208                 return 0xff&inb(dev->base_addr + x);
 209         } else {
 210                 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
 211                                                         &u1PageMask);
 212                 if (bIsLegalPage) {
 213                         u8 u1bPsr = read_nic_io_byte(dev, PSR);
 214
 215                         write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
 216                                           (u8)u4bPage));
 217                         Data = read_nic_io_byte(dev, (x & 0xff));
 218                         write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
 219                 }
 220         }
 221
 222         return Data;
 223 }
 224
 225 u16 read_nic_io_word(struct net_device *dev, int x)
 226 {
 227         u32 u4bPage = (x >> 8);
 228         u8 u1PageMask = 0;
 229         bool    bIsLegalPage = false;
 230         u16     Data = 0;
 231
 232         if (u4bPage == 0) {
 233                 return inw(dev->base_addr + x);
 234         } else {
 235                 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
 236                                &u1PageMask);
 237                 if (bIsLegalPage) {
 238                         u8 u1bPsr = read_nic_io_byte(dev, PSR);
 239
 240                         write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
 241                                           (u8)u4bPage));
 242                         Data = read_nic_io_word(dev, (x & 0xff));
 243                         write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
 244
 245                 }
 246         }
 247
 248         return Data;
 249 }
 250
 251 u32 read_nic_io_dword(struct net_device *dev, int x)
 252 {
 253         u32 u4bPage = (x >> 8);
 254         u8 u1PageMask = 0;
 255         bool    bIsLegalPage = false;
 256         u32     Data = 0;
 257
 258         if (u4bPage == 0) {
 259                 return inl(dev->base_addr + x);
 260         } else {
 261                 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
 262                                &u1PageMask);
 263                 if (bIsLegalPage) {
 264                         u8 u1bPsr = read_nic_io_byte(dev, PSR);
 265
 266                         write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
 267                                           (u8)u4bPage));
 268                         Data = read_nic_io_dword(dev, (x & 0xff));
 269                         write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
 270
 271                 }
 272         }
 273
 274         return Data;
 275 }
 276
 277 u8 read_nic_byte(struct net_device *dev, int x)
 278 {
 279         return 0xff & readb((u8 *)dev->mem_start + x);
 280 }
 281
 282 u32 read_nic_dword(struct net_device *dev, int x)
 283 {
 284         return readl((u8 *)dev->mem_start + x);
 285 }
 286
 287 u16 read_nic_word(struct net_device *dev, int x)
 288 {
 289         return readw((u8 *)dev->mem_start + x);
 290 }
 291
 292 void write_nic_byte(struct net_device *dev, int x, u8 y)
 293 {
 294         writeb(y, (u8 *)dev->mem_start + x);
 295
 296         udelay(20);
 297 }
 298
 299 void write_nic_dword(struct net_device *dev, int x, u32 y)
 300 {
 301         writel(y, (u8 *)dev->mem_start + x);
 302
 303         udelay(20);
 304 }
 305
 306 void write_nic_word(struct net_device *dev, int x, u16 y)
 307 {
 308         writew(y, (u8 *)dev->mem_start + x);
 309
 310         udelay(20);
 311 }
 312
 313 /****************************************************************************
 314    -----------------------------GENERAL FUNCTION-------------------------
 315 *****************************************************************************/
 316 bool MgntActSet_RF_State(struct net_device *dev,
 317                          enum rt_rf_power_state StateToSet,
 318                          RT_RF_CHANGE_SOURCE ChangeSource,
 319                          bool   ProtectOrNot)
 320 {
 321         struct r8192_priv *priv = rtllib_priv(dev);
 322         struct rtllib_device *ieee = priv->rtllib;
 323         bool                    bActionAllowed = false;
 324         bool                    bConnectBySSID = false;
 325         enum rt_rf_power_state rtState;
 326         u16                     RFWaitCounter = 0;
 327         unsigned long flag;
 328         RT_TRACE((COMP_PS | COMP_RF), "===>MgntActSet_RF_State(): "
 329                  "StateToSet(%d)\n", StateToSet);
 330
 331         ProtectOrNot = false;
 332
 333
 334         if (!ProtectOrNot) {
 335                 while (true) {
 336                         spin_lock_irqsave(&priv->rf_ps_lock, flag);
 337                         if (priv->RFChangeInProgress) {
 338                                 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
 339                                 RT_TRACE((COMP_PS | COMP_RF),
 340                                          "MgntActSet_RF_State(): RF Change in "
 341                                          "progress! Wait to set..StateToSet"
 342                                          "(%d).\n", StateToSet);
 343
 344                                 while (priv->RFChangeInProgress) {
 345                                         RFWaitCounter++;
 346                                         RT_TRACE((COMP_PS | COMP_RF),
 347                                                  "MgntActSet_RF_State(): Wait 1"
 348                                                  " ms (%d times)...\n",
 349                                                  RFWaitCounter);
 350                                         mdelay(1);
 351
 352                                         if (RFWaitCounter > 100) {
 353                                                 RT_TRACE(COMP_ERR, "MgntActSet_"
 354                                                          "RF_State(): Wait too "
 355                                                          "logn to set RF\n");
 356                                                 return false;
 357                                         }
 358                                 }
 359                         } else {
 360                                 priv->RFChangeInProgress = true;
 361                                 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
 362                                 break;
 363                         }
 364                 }
 365         }
 366
 367         rtState = priv->rtllib->eRFPowerState;
 368
 369         switch (StateToSet) {
 370         case eRfOn:
 371                 priv->rtllib->RfOffReason &= (~ChangeSource);
 372
 373                 if ((ChangeSource == RF_CHANGE_BY_HW) &&
 374                     (priv->bHwRadioOff == true))
 375                         priv->bHwRadioOff = false;
 376
 377                 if (!priv->rtllib->RfOffReason) {
 378                         priv->rtllib->RfOffReason = 0;
 379                         bActionAllowed = true;
 380
 381
 382                         if (rtState == eRfOff &&
 383                             ChangeSource >= RF_CHANGE_BY_HW)
 384                                 bConnectBySSID = true;
 385                 } else {
 386                         RT_TRACE((COMP_PS | COMP_RF), "MgntActSet_RF_State - "
 387                                  "eRfon reject pMgntInfo->RfOffReason= 0x%x,"
 388                                  " ChangeSource=0x%X\n",
 389                                   priv->rtllib->RfOffReason, ChangeSource);
 390         }
 391
 392                 break;
 393
 394         case eRfOff:
 395
 396                 if ((priv->rtllib->iw_mode == IW_MODE_INFRA) ||
 397                     (priv->rtllib->iw_mode == IW_MODE_ADHOC)) {
 398                         if ((priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) ||
 399                             (ChangeSource > RF_CHANGE_BY_IPS)) {
 400                                 if (ieee->state == RTLLIB_LINKED)
 401                                         priv->blinked_ingpio = true;
 402                                 else
 403                                         priv->blinked_ingpio = false;
 404                                 rtllib_MgntDisconnect(priv->rtllib,
 405                                                       disas_lv_ss);
 406                         }
 407                 }
 408                 if ((ChangeSource == RF_CHANGE_BY_HW) &&
 409                      (priv->bHwRadioOff == false))
 410                         priv->bHwRadioOff = true;
 411                 priv->rtllib->RfOffReason |= ChangeSource;
 412                 bActionAllowed = true;
 413                 break;
 414
 415         case eRfSleep:
 416                 priv->rtllib->RfOffReason |= ChangeSource;
 417                 bActionAllowed = true;
 418                 break;
 419
 420         default:
 421                 break;
 422         }
 423
 424         if (bActionAllowed) {
 425                 RT_TRACE((COMP_PS | COMP_RF), "MgntActSet_RF_State(): Action is"
 426                          " allowed.... StateToSet(%d), RfOffReason(%#X)\n",
 427                          StateToSet, priv->rtllib->RfOffReason);
 428                 PHY_SetRFPowerState(dev, StateToSet);
 429                 if (StateToSet == eRfOn) {
 430
 431                         if (bConnectBySSID && (priv->blinked_ingpio == true)) {
 432                                 queue_delayed_work_rsl(ieee->wq,
 433                                          &ieee->associate_procedure_wq, 0);
 434                                 priv->blinked_ingpio = false;
 435                         }
 436                 }
 437         } else {
 438                 RT_TRACE((COMP_PS | COMP_RF), "MgntActSet_RF_State(): "
 439                          "Action is rejected.... StateToSet(%d), ChangeSource"
 440                          "(%#X), RfOffReason(%#X)\n", StateToSet, ChangeSource,
 441                          priv->rtllib->RfOffReason);
 442         }
 443
 444         if (!ProtectOrNot) {
 445                 spin_lock_irqsave(&priv->rf_ps_lock, flag);
 446                 priv->RFChangeInProgress = false;
 447                 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
 448         }
 449
 450         RT_TRACE((COMP_PS && COMP_RF), "<===MgntActSet_RF_State()\n");
 451         return bActionAllowed;
 452 }
 453
 454
 455 short rtl8192_get_nic_desc_num(struct net_device *dev, int prio)
 456 {
 457         struct r8192_priv *priv = rtllib_priv(dev);
 458         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
 459
 460         /* For now, we reserved two free descriptor as a safety boundary
 461         * between the tail and the head
 462         */
 463         if ((prio == MGNT_QUEUE) && (skb_queue_len(&ring->queue) > 10))
 464                 RT_TRACE(COMP_DBG, "-----[%d]---------ring->idx=%d "
 465                          "queue_len=%d---------\n", prio, ring->idx,
 466                          skb_queue_len(&ring->queue));
 467         return skb_queue_len(&ring->queue);
 468 }
 469
 470 short rtl8192_check_nic_enough_desc(struct net_device *dev, int prio)
 471 {
 472         struct r8192_priv *priv = rtllib_priv(dev);
 473         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
 474
 475         if (ring->entries - skb_queue_len(&ring->queue) >= 2)
 476                 return 1;
 477         return 0;
 478 }
 479
 480 void rtl8192_tx_timeout(struct net_device *dev)
 481 {
 482         struct r8192_priv *priv = rtllib_priv(dev);
 483
 484         schedule_work(&priv->reset_wq);
 485         printk(KERN_INFO "TXTIMEOUT");
 486 }
 487
 488 void rtl8192_irq_enable(struct net_device *dev)
 489 {
 490         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 491         priv->irq_enabled = 1;
 492
 493         priv->ops->irq_enable(dev);
 494 }
 495
 496 void rtl8192_irq_disable(struct net_device *dev)
 497 {
 498         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 499
 500         priv->ops->irq_disable(dev);
 501
 502         priv->irq_enabled = 0;
 503 }
 504
 505 void rtl8192_irq_clear(struct net_device *dev)
 506 {
 507         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 508
 509         priv->ops->irq_clear(dev);
 510 }
 511
 512
 513 void rtl8192_set_chan(struct net_device *dev, short ch)
 514 {
 515         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
 516
 517         RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __func__, ch);
 518         if (priv->chan_forced)
 519                 return;
 520
 521         priv->chan = ch;
 522
 523         if (priv->rf_set_chan)
 524                 priv->rf_set_chan(dev, priv->chan);
 525 }
 526
 527 void rtl8192_update_cap(struct net_device *dev, u16 cap)
 528 {
 529         struct r8192_priv *priv = rtllib_priv(dev);
 530         struct rtllib_network *net = &priv->rtllib->current_network;
 531         bool            ShortPreamble;
 532
 533         if (cap & WLAN_CAPABILITY_SHORT_PREAMBLE) {
 534                 if (priv->dot11CurrentPreambleMode != PREAMBLE_SHORT) {
 535                         ShortPreamble = true;
 536                         priv->dot11CurrentPreambleMode = PREAMBLE_SHORT;
 537                         RT_TRACE(COMP_DBG, "%s(): WLAN_CAPABILITY_SHORT_"
 538                                  "PREAMBLE\n", __func__);
 539                         priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACK_PREAMBLE,
 540                                         (unsigned char *)&ShortPreamble);
 541                 }
 542         } else {
 543                 if (priv->dot11CurrentPreambleMode != PREAMBLE_LONG) {
 544                         ShortPreamble = false;
 545                         priv->dot11CurrentPreambleMode = PREAMBLE_LONG;
 546                         RT_TRACE(COMP_DBG, "%s(): WLAN_CAPABILITY_LONG_"
 547                                  "PREAMBLE\n", __func__);
 548                         priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACK_PREAMBLE,
 549                                               (unsigned char *)&ShortPreamble);
 550                 }
 551         }
 552
 553         if (net->mode & (IEEE_G|IEEE_N_24G)) {
 554                 u8      slot_time_val;
 555                 u8      CurSlotTime = priv->slot_time;
 556
 557                 if ((cap & WLAN_CAPABILITY_SHORT_SLOT_TIME) &&
 558                    (!priv->rtllib->pHTInfo->bCurrentRT2RTLongSlotTime)) {
 559                         if (CurSlotTime != SHORT_SLOT_TIME) {
 560                                 slot_time_val = SHORT_SLOT_TIME;
 561                                 priv->rtllib->SetHwRegHandler(dev,
 562                                          HW_VAR_SLOT_TIME, &slot_time_val);
 563                         }
 564                 } else {
 565                         if (CurSlotTime != NON_SHORT_SLOT_TIME) {
 566                                 slot_time_val = NON_SHORT_SLOT_TIME;
 567                                 priv->rtllib->SetHwRegHandler(dev,
 568                                          HW_VAR_SLOT_TIME, &slot_time_val);
 569                         }
 570                 }
 571         }
 572 }
 573
 574 static struct rtllib_qos_parameters def_qos_parameters = {
 575         {3, 3, 3, 3},
 576         {7, 7, 7, 7},
 577         {2, 2, 2, 2},
 578         {0, 0, 0, 0},
 579         {0, 0, 0, 0}
 580 };
 581
 582 void rtl8192_update_beacon(void *data)
 583 {
 584         struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv,
 585                                   update_beacon_wq.work);
 586         struct net_device *dev = priv->rtllib->dev;
 587         struct rtllib_device *ieee = priv->rtllib;
 588         struct rtllib_network *net = &ieee->current_network;
 589
 590         if (ieee->pHTInfo->bCurrentHTSupport)
 591                 HTUpdateSelfAndPeerSetting(ieee, net);
 592         ieee->pHTInfo->bCurrentRT2RTLongSlotTime =
 593                  net->bssht.bdRT2RTLongSlotTime;
 594         ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.RT2RT_HT_Mode;
 595         rtl8192_update_cap(dev, net->capability);
 596 }
 597
 598 #define MOVE_INTO_HANDLER
 599 int WDCAPARA_ADD[] = {EDCAPARA_BE, EDCAPARA_BK, EDCAPARA_VI, EDCAPARA_VO};
 600
 601 void rtl8192_qos_activate(void *data)
 602 {
 603         struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv,
 604                                   qos_activate);
 605         struct net_device *dev = priv->rtllib->dev;
 606 #ifndef MOVE_INTO_HANDLER
 607         struct rtllib_qos_parameters *qos_parameters =
 608                  &priv->rtllib->current_network.qos_data.parameters;
 609         u8 mode = priv->rtllib->current_network.mode;
 610         u8  u1bAIFS;
 611         u32 u4bAcParam;
 612 #endif
 613         int i;
 614
 615         if (priv == NULL)
 616                 return;
 617
 618         mutex_lock(&priv->mutex);
 619         if (priv->rtllib->state != RTLLIB_LINKED)
 620                 goto success;
 621         RT_TRACE(COMP_QOS, "qos active process with associate response "
 622                  "received\n");
 623
 624         for (i = 0; i <  QOS_QUEUE_NUM; i++) {
 625 #ifndef MOVE_INTO_HANDLER
 626                 u1bAIFS = qos_parameters->aifs[i] *
 627                           ((mode&(IEEE_G|IEEE_N_24G)) ? 9 : 20) + aSifsTime;
 628                 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i])) <<
 629                              AC_PARAM_TXOP_LIMIT_OFFSET) |
 630                              (((u32)(qos_parameters->cw_max[i])) <<
 631                              AC_PARAM_ECW_MAX_OFFSET) |
 632                              (((u32)(qos_parameters->cw_min[i])) <<
 633                              AC_PARAM_ECW_MIN_OFFSET) |
 634                              ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
 635                 RT_TRACE(COMP_DBG, "===>ACI:%d:u4bAcParam:%x\n", i, u4bAcParam);
 636                 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
 637 #else
 638                 priv->rtllib->SetHwRegHandler(dev, HW_VAR_AC_PARAM, (u8 *)(&i));
 639 #endif
 640         }
 641
 642 success:
 643         mutex_unlock(&priv->mutex);
 644 }
 645
 646 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
 647                 int active_network,
 648                 struct rtllib_network *network)
 649 {
 650         int ret = 0;
 651         u32 size = sizeof(struct rtllib_qos_parameters);
 652
 653         if (priv->rtllib->state != RTLLIB_LINKED)
 654                 return ret;
 655
 656         if ((priv->rtllib->iw_mode != IW_MODE_INFRA))
 657                 return ret;
 658
 659         if (network->flags & NETWORK_HAS_QOS_MASK) {
 660                 if (active_network &&
 661                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
 662                         network->qos_data.active = network->qos_data.supported;
 663
 664                 if ((network->qos_data.active == 1) && (active_network == 1) &&
 665                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
 666                                 (network->qos_data.old_param_count !=
 667                                 network->qos_data.param_count)) {
 668                         network->qos_data.old_param_count =
 669                                 network->qos_data.param_count;
 670         priv->rtllib->wmm_acm = network->qos_data.wmm_acm;
 671                         queue_work_rsl(priv->priv_wq, &priv->qos_activate);
 672                         RT_TRACE(COMP_QOS, "QoS parameters change call "
 673                                         "qos_activate\n");
 674                 }
 675         } else {
 676                 memcpy(&priv->rtllib->current_network.qos_data.parameters,
 677                        &def_qos_parameters, size);
 678
 679                 if ((network->qos_data.active == 1) && (active_network == 1)) {
 680                         queue_work_rsl(priv->priv_wq, &priv->qos_activate);
 681                         RT_TRACE(COMP_QOS, "QoS was disabled call qos_"
 682                                  "activate\n");
 683                 }
 684                 network->qos_data.active = 0;
 685                 network->qos_data.supported = 0;
 686         }
 687
 688         return 0;
 689 }
 690
 691 static int rtl8192_handle_beacon(struct net_device *dev,
 692         struct rtllib_beacon *beacon,
 693         struct rtllib_network *network)
 694 {
 695         struct r8192_priv *priv = rtllib_priv(dev);
 696
 697         rtl8192_qos_handle_probe_response(priv, 1, network);
 698
 699         queue_delayed_work_rsl(priv->priv_wq, &priv->update_beacon_wq, 0);
 700         return 0;
 701
 702 }
 703
 704 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
 705         struct rtllib_network *network)
 706 {
 707         int ret = 0;
 708         unsigned long flags;
 709         u32 size = sizeof(struct rtllib_qos_parameters);
 710         int set_qos_param = 0;
 711
 712         if ((priv == NULL) || (network == NULL))
 713                 return ret;
 714
 715         if (priv->rtllib->state != RTLLIB_LINKED)
 716                 return ret;
 717
 718         if ((priv->rtllib->iw_mode != IW_MODE_INFRA))
 719                 return ret;
 720
 721         spin_lock_irqsave(&priv->rtllib->lock, flags);
 722         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
 723                 memcpy(&priv->rtllib->current_network.qos_data.parameters,
 724                        &network->qos_data.parameters,
 725                        sizeof(struct rtllib_qos_parameters));
 726                 priv->rtllib->current_network.qos_data.active = 1;
 727                 priv->rtllib->wmm_acm = network->qos_data.wmm_acm;
 728                 set_qos_param = 1;
 729                 priv->rtllib->current_network.qos_data.old_param_count =
 730                         priv->rtllib->current_network.qos_data.param_count;
 731                 priv->rtllib->current_network.qos_data.param_count =
 732                         network->qos_data.param_count;
 733         } else {
 734                 memcpy(&priv->rtllib->current_network.qos_data.parameters,
 735                 &def_qos_parameters, size);
 736                 priv->rtllib->current_network.qos_data.active = 0;
 737                 priv->rtllib->current_network.qos_data.supported = 0;
 738                 set_qos_param = 1;
 739         }
 740
 741         spin_unlock_irqrestore(&priv->rtllib->lock, flags);
 742
 743         RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __func__,
 744                  network->flags, priv->rtllib->current_network.qos_data.active);
 745         if (set_qos_param == 1) {
 746                 dm_init_edca_turbo(priv->rtllib->dev);
 747                 queue_work_rsl(priv->priv_wq, &priv->qos_activate);
 748         }
 749         return ret;
 750 }
 751
 752 static int rtl8192_handle_assoc_response(struct net_device *dev,
 753                                  struct rtllib_assoc_response_frame *resp,
 754                                  struct rtllib_network *network)
 755 {
 756         struct r8192_priv *priv = rtllib_priv(dev);
 757         rtl8192_qos_association_resp(priv, network);
 758         return 0;
 759 }
 760
 761 void rtl8192_prepare_beacon(struct r8192_priv *priv)
 762 {
 763         struct net_device *dev = priv->rtllib->dev;
 764         struct sk_buff *pskb = NULL, *pnewskb = NULL;
 765         struct cb_desc *tcb_desc = NULL;
 766         struct rtl8192_tx_ring *ring = NULL;
 767         struct tx_desc *pdesc = NULL;
 768
 769         ring = &priv->tx_ring[BEACON_QUEUE];
 770         pskb = __skb_dequeue(&ring->queue);
 771         if (pskb)
 772                 kfree_skb(pskb);
 773
 774         pnewskb = rtllib_get_beacon(priv->rtllib);
 775         if (!pnewskb)
 776                 return;
 777
 778         tcb_desc = (struct cb_desc *)(pnewskb->cb + 8);
 779         tcb_desc->queue_index = BEACON_QUEUE;
 780         tcb_desc->data_rate = 2;
 781         tcb_desc->RATRIndex = 7;
 782         tcb_desc->bTxDisableRateFallBack = 1;
 783         tcb_desc->bTxUseDriverAssingedRate = 1;
 784         skb_push(pnewskb, priv->rtllib->tx_headroom);
 785
 786         pdesc = &ring->desc[0];
 787         priv->ops->tx_fill_descriptor(dev, pdesc, tcb_desc, pnewskb);
 788         __skb_queue_tail(&ring->queue, pnewskb);
 789         pdesc->OWN = 1;
 790
 791         return;
 792 }
 793
 794 void rtl8192_stop_beacon(struct net_device *dev)
 795 {
 796 }
 797
 798 void rtl8192_config_rate(struct net_device *dev, u16 *rate_config)
 799 {
 800         struct r8192_priv *priv = rtllib_priv(dev);
 801         struct rtllib_network *net;
 802         u8 i = 0, basic_rate = 0;
 803         net = &priv->rtllib->current_network;
 804
 805         for (i = 0; i < net->rates_len; i++) {
 806                 basic_rate = net->rates[i] & 0x7f;
 807                 switch (basic_rate) {
 808                 case MGN_1M:
 809                         *rate_config |= RRSR_1M;
 810                         break;
 811                 case MGN_2M:
 812                         *rate_config |= RRSR_2M;
 813                         break;
 814                 case MGN_5_5M:
 815                         *rate_config |= RRSR_5_5M;
 816                         break;
 817                 case MGN_11M:
 818                         *rate_config |= RRSR_11M;
 819                         break;
 820                 case MGN_6M:
 821                         *rate_config |= RRSR_6M;
 822                         break;
 823                 case MGN_9M:
 824                         *rate_config |= RRSR_9M;
 825                         break;
 826                 case MGN_12M:
 827                         *rate_config |= RRSR_12M;
 828                         break;
 829                 case MGN_18M:
 830                         *rate_config |= RRSR_18M;
 831                         break;
 832                 case MGN_24M:
 833                         *rate_config |= RRSR_24M;
 834                         break;
 835                 case MGN_36M:
 836                         *rate_config |= RRSR_36M;
 837                         break;
 838                 case MGN_48M:
 839                         *rate_config |= RRSR_48M;
 840                         break;
 841                 case MGN_54M:
 842                         *rate_config |= RRSR_54M;
 843                         break;
 844                 }
 845         }
 846
 847         for (i = 0; i < net->rates_ex_len; i++) {
 848                 basic_rate = net->rates_ex[i] & 0x7f;
 849                 switch (basic_rate) {
 850                 case MGN_1M:
 851                         *rate_config |= RRSR_1M;
 852                         break;
 853                 case MGN_2M:
 854                         *rate_config |= RRSR_2M;
 855                         break;
 856                 case MGN_5_5M:
 857                         *rate_config |= RRSR_5_5M;
 858                         break;
 859                 case MGN_11M:
 860                         *rate_config |= RRSR_11M;
 861                         break;
 862                 case MGN_6M:
 863                         *rate_config |= RRSR_6M;
 864                         break;
 865                 case MGN_9M:
 866                         *rate_config |= RRSR_9M;
 867                         break;
 868                 case MGN_12M:
 869                         *rate_config |= RRSR_12M;
 870                         break;
 871                 case MGN_18M:
 872                         *rate_config |= RRSR_18M;
 873                         break;
 874                 case MGN_24M:
 875                         *rate_config |= RRSR_24M;
 876                         break;
 877                 case MGN_36M:
 878                         *rate_config |= RRSR_36M;
 879                         break;
 880                 case MGN_48M:
 881                         *rate_config |= RRSR_48M;
 882                         break;
 883                 case MGN_54M:
 884                         *rate_config |= RRSR_54M;
 885                         break;
 886                 }
 887         }
 888 }
 889
 890 void rtl8192_refresh_supportrate(struct r8192_priv *priv)
 891 {
 892         struct rtllib_device *ieee = priv->rtllib;
 893         if (ieee->mode == WIRELESS_MODE_N_24G ||
 894             ieee->mode == WIRELESS_MODE_N_5G) {
 895                 memcpy(ieee->Regdot11HTOperationalRateSet,
 896                        ieee->RegHTSuppRateSet, 16);
 897                 memcpy(ieee->Regdot11TxHTOperationalRateSet,
 898                        ieee->RegHTSuppRateSet, 16);
 899
 900         } else {
 901                 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
 902         }
 903         return;
 904 }
 905
 906 u8 rtl8192_getSupportedWireleeMode(struct net_device *dev)
 907 {
 908         struct r8192_priv *priv = rtllib_priv(dev);
 909         u8 ret = 0;
 910
 911         switch (priv->rf_chip) {
 912         case RF_8225:
 913         case RF_8256:
 914         case RF_6052:
 915         case RF_PSEUDO_11N:
 916                 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G | WIRELESS_MODE_B);
 917                 break;
 918         case RF_8258:
 919                 ret = (WIRELESS_MODE_A | WIRELESS_MODE_N_5G);
 920                 break;
 921         default:
 922                 ret = WIRELESS_MODE_B;
 923                 break;
 924         }
 925         return ret;
 926 }
 927
 928 void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode)
 929 {
 930         struct r8192_priv *priv = rtllib_priv(dev);
 931         u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
 932
 933         if ((wireless_mode == WIRELESS_MODE_AUTO) ||
 934             ((wireless_mode & bSupportMode) == 0)) {
 935                 if (bSupportMode & WIRELESS_MODE_N_24G) {
 936                         wireless_mode = WIRELESS_MODE_N_24G;
 937                 } else if (bSupportMode & WIRELESS_MODE_N_5G) {
 938                         wireless_mode = WIRELESS_MODE_N_5G;
 939                 } else if ((bSupportMode & WIRELESS_MODE_A)) {
 940                         wireless_mode = WIRELESS_MODE_A;
 941                 } else if ((bSupportMode & WIRELESS_MODE_G)) {
 942                         wireless_mode = WIRELESS_MODE_G;
 943                 } else if ((bSupportMode & WIRELESS_MODE_B)) {
 944                         wireless_mode = WIRELESS_MODE_B;
 945                 } else {
 946                         RT_TRACE(COMP_ERR, "%s(), No valid wireless mode "
 947                                  "supported (%x)!!!\n", __func__, bSupportMode);
 948                         wireless_mode = WIRELESS_MODE_B;
 949                 }
 950         }
 951
 952         if ((wireless_mode & (WIRELESS_MODE_B | WIRELESS_MODE_G)) ==
 953             (WIRELESS_MODE_G | WIRELESS_MODE_B))
 954                 wireless_mode = WIRELESS_MODE_G;
 955
 956         priv->rtllib->mode = wireless_mode;
 957
 958         ActUpdateChannelAccessSetting(dev, wireless_mode,
 959                                       &priv->ChannelAccessSetting);
 960
 961         if ((wireless_mode == WIRELESS_MODE_N_24G) ||
 962             (wireless_mode == WIRELESS_MODE_N_5G)) {
 963                 priv->rtllib->pHTInfo->bEnableHT = 1;
 964         RT_TRACE(COMP_DBG, "%s(), wireless_mode:%x, bEnableHT = 1\n",
 965                  __func__, wireless_mode);
 966         } else {
 967                 priv->rtllib->pHTInfo->bEnableHT = 0;
 968                 RT_TRACE(COMP_DBG, "%s(), wireless_mode:%x, bEnableHT = 0\n",
 969                          __func__, wireless_mode);
 970         }
 971
 972         RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
 973         rtl8192_refresh_supportrate(priv);
 974 }
 975
 976 int _rtl8192_sta_up(struct net_device *dev, bool is_silent_reset)
 977 {
 978         struct r8192_priv *priv = rtllib_priv(dev);
 979         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 980                                         (&(priv->rtllib->PowerSaveControl));
 981         bool init_status = true;
 982         priv->bDriverIsGoingToUnload = false;
 983         priv->bdisable_nic = false;
 984
 985         priv->up = 1;
 986         priv->rtllib->ieee_up = 1;
 987
 988         priv->up_first_time = 0;
 989         RT_TRACE(COMP_INIT, "Bringing up iface");
 990         priv->bfirst_init = true;
 991         init_status = priv->ops->initialize_adapter(dev);
 992         if (init_status != true) {
 993                 RT_TRACE(COMP_ERR, "ERR!!! %s(): initialization is failed!\n",
 994                          __func__);
 995                 priv->bfirst_init = false;
 996                 return -1;
 997         }
 998
 999         RT_TRACE(COMP_INIT, "start adapter finished\n");
1000         RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
1001         priv->bfirst_init = false;
1002
1003         if (priv->polling_timer_on == 0)
1004                 check_rfctrl_gpio_timer((unsigned long)dev);
1005
1006         if (priv->rtllib->state != RTLLIB_LINKED)
1007                 rtllib_softmac_start_protocol(priv->rtllib, 0);
1008         rtllib_reset_queue(priv->rtllib);
1009         watch_dog_timer_callback((unsigned long) dev);
1010
1011         if (!netif_queue_stopped(dev))
1012                 netif_start_queue(dev);
1013         else
1014                 netif_wake_queue(dev);
1015
1016         return 0;
1017 }
1018
1019 int rtl8192_sta_down(struct net_device *dev, bool shutdownrf)
1020 {
1021         struct r8192_priv *priv = rtllib_priv(dev);
1022         unsigned long flags = 0;
1023         u8 RFInProgressTimeOut = 0;
1024
1025         if (priv->up == 0)
1026                 return -1;
1027
1028         if (priv->rtllib->rtllib_ips_leave != NULL)
1029                 priv->rtllib->rtllib_ips_leave(dev);
1030
1031         if (priv->rtllib->state == RTLLIB_LINKED)
1032                 LeisurePSLeave(dev);
1033
1034         priv->bDriverIsGoingToUnload = true;
1035         priv->up = 0;
1036         priv->rtllib->ieee_up = 0;
1037         priv->bfirst_after_down = 1;
1038         RT_TRACE(COMP_DOWN, "==========>%s()\n", __func__);
1039         if (!netif_queue_stopped(dev))
1040                 netif_stop_queue(dev);
1041
1042         priv->rtllib->wpa_ie_len = 0;
1043         kfree(priv->rtllib->wpa_ie);
1044         priv->rtllib->wpa_ie = NULL;
1045         CamResetAllEntry(dev);
1046         memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
1047         rtl8192_irq_disable(dev);
1048
1049         del_timer_sync(&priv->watch_dog_timer);
1050         rtl8192_cancel_deferred_work(priv);
1051         cancel_delayed_work(&priv->rtllib->hw_wakeup_wq);
1052
1053         rtllib_softmac_stop_protocol(priv->rtllib, 0, true);
1054         spin_lock_irqsave(&priv->rf_ps_lock, flags);
1055         while (priv->RFChangeInProgress) {
1056                 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
1057                 if (RFInProgressTimeOut > 100) {
1058                         spin_lock_irqsave(&priv->rf_ps_lock, flags);
1059                         break;
1060                 }
1061                 RT_TRACE(COMP_DBG, "===>%s():RF is in progress, need to wait "
1062                          "until rf chang is done.\n", __func__);
1063                 mdelay(1);
1064                 RFInProgressTimeOut++;
1065                 spin_lock_irqsave(&priv->rf_ps_lock, flags);
1066         }
1067         priv->RFChangeInProgress = true;
1068         spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
1069         priv->ops->stop_adapter(dev, false);
1070         spin_lock_irqsave(&priv->rf_ps_lock, flags);
1071         priv->RFChangeInProgress = false;
1072         spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
1073         udelay(100);
1074         memset(&priv->rtllib->current_network, 0,
1075                offsetof(struct rtllib_network, list));
1076         RT_TRACE(COMP_DOWN, "<==========%s()\n", __func__);
1077
1078         return 0;
1079 }
1080
1081 static void rtl8192_init_priv_handler(struct net_device *dev)
1082 {
1083         struct r8192_priv *priv = rtllib_priv(dev);
1084
1085         priv->rtllib->softmac_hard_start_xmit   = rtl8192_hard_start_xmit;
1086         priv->rtllib->set_chan                  = rtl8192_set_chan;
1087         priv->rtllib->link_change               = priv->ops->link_change;
1088         priv->rtllib->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
1089         priv->rtllib->data_hard_stop            = rtl8192_data_hard_stop;
1090         priv->rtllib->data_hard_resume          = rtl8192_data_hard_resume;
1091         priv->rtllib->check_nic_enough_desc     = rtl8192_check_nic_enough_desc;
1092         priv->rtllib->get_nic_desc_num          = rtl8192_get_nic_desc_num;
1093         priv->rtllib->handle_assoc_response     = rtl8192_handle_assoc_response;
1094         priv->rtllib->handle_beacon             = rtl8192_handle_beacon;
1095         priv->rtllib->SetWirelessMode           = rtl8192_SetWirelessMode;
1096         priv->rtllib->LeisurePSLeave            = LeisurePSLeave;
1097         priv->rtllib->SetBWModeHandler          = rtl8192_SetBWMode;
1098         priv->rf_set_chan                       = rtl8192_phy_SwChnl;
1099
1100         priv->rtllib->start_send_beacons = rtl8192e_start_beacon;
1101         priv->rtllib->stop_send_beacons = rtl8192_stop_beacon;
1102
1103         priv->rtllib->sta_wake_up = rtl8192_hw_wakeup;
1104         priv->rtllib->enter_sleep_state = rtl8192_hw_to_sleep;
1105         priv->rtllib->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
1106
1107         priv->rtllib->GetNmodeSupportBySecCfg = rtl8192_GetNmodeSupportBySecCfg;
1108         priv->rtllib->GetHalfNmodeSupportByAPsHandler =
1109                                          rtl8192_GetHalfNmodeSupportByAPs;
1110
1111         priv->rtllib->SetHwRegHandler = rtl8192e_SetHwReg;
1112         priv->rtllib->AllowAllDestAddrHandler = rtl8192_AllowAllDestAddr;
1113         priv->rtllib->SetFwCmdHandler = NULL;
1114         priv->rtllib->InitialGainHandler = InitialGain819xPci;
1115         priv->rtllib->rtllib_ips_leave_wq = rtllib_ips_leave_wq;
1116         priv->rtllib->rtllib_ips_leave = rtllib_ips_leave;
1117
1118         priv->rtllib->LedControlHandler = NULL;
1119         priv->rtllib->UpdateBeaconInterruptHandler = NULL;
1120
1121         priv->rtllib->ScanOperationBackupHandler = PHY_ScanOperationBackup8192;
1122
1123         priv->rtllib->rtllib_rfkill_poll = NULL;
1124 }
1125
1126 static void rtl8192_init_priv_constant(struct net_device *dev)
1127 {
1128         struct r8192_priv *priv = rtllib_priv(dev);
1129         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
1130                                         &(priv->rtllib->PowerSaveControl);
1131
1132         pPSC->RegMaxLPSAwakeIntvl = 5;
1133
1134         priv->RegPciASPM = 2;
1135
1136         priv->RegDevicePciASPMSetting = 0x03;
1137
1138         priv->RegHostPciASPMSetting = 0x02;
1139
1140         priv->RegHwSwRfOffD3 = 2;
1141
1142         priv->RegSupportPciASPM = 2;
1143 }
1144
1145
1146 static void rtl8192_init_priv_variable(struct net_device *dev)
1147 {
1148         struct r8192_priv *priv = rtllib_priv(dev);
1149         u8 i;
1150
1151         priv->AcmMethod = eAcmWay2_SW;
1152         priv->dot11CurrentPreambleMode = PREAMBLE_AUTO;
1153         priv->rtllib->hwscan_sem_up = 1;
1154         priv->rtllib->status = 0;
1155         priv->H2CTxCmdSeq = 0;
1156         priv->bDisableFrameBursting = 0;
1157         priv->bDMInitialGainEnable = 1;
1158         priv->polling_timer_on = 0;
1159         priv->up_first_time = 1;
1160         priv->blinked_ingpio = false;
1161         priv->bDriverIsGoingToUnload = false;
1162         priv->being_init_adapter = false;
1163         priv->initialized_at_probe = false;
1164         priv->sw_radio_on = true;
1165         priv->bdisable_nic = false;
1166         priv->bfirst_init = false;
1167         priv->txringcount = 64;
1168         priv->rxbuffersize = 9100;
1169         priv->rxringcount = MAX_RX_COUNT;
1170         priv->irq_enabled = 0;
1171         priv->chan = 1;
1172         priv->RegWirelessMode = WIRELESS_MODE_AUTO;
1173         priv->RegChannelPlan = 0xf;
1174         priv->nrxAMPDU_size = 0;
1175         priv->nrxAMPDU_aggr_num = 0;
1176         priv->last_rxdesc_tsf_high = 0;
1177         priv->last_rxdesc_tsf_low = 0;
1178         priv->rtllib->mode = WIRELESS_MODE_AUTO;
1179         priv->rtllib->iw_mode = IW_MODE_INFRA;
1180         priv->rtllib->bNetPromiscuousMode = false;
1181         priv->rtllib->IntelPromiscuousModeInfo.bPromiscuousOn = false;
1182         priv->rtllib->IntelPromiscuousModeInfo.bFilterSourceStationFrame =
1183                                                                  false;
1184         priv->rtllib->ieee_up = 0;
1185         priv->retry_rts = DEFAULT_RETRY_RTS;
1186         priv->retry_data = DEFAULT_RETRY_DATA;
1187         priv->rtllib->rts = DEFAULT_RTS_THRESHOLD;
1188         priv->rtllib->rate = 110;
1189         priv->rtllib->short_slot = 1;
1190         priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
1191         priv->bcck_in_ch14 = false;
1192         priv->bfsync_processing  = false;
1193         priv->CCKPresentAttentuation = 0;
1194         priv->rfa_txpowertrackingindex = 0;
1195         priv->rfc_txpowertrackingindex = 0;
1196         priv->CckPwEnl = 6;
1197         priv->ScanDelay = 50;
1198         priv->ResetProgress = RESET_TYPE_NORESET;
1199         priv->bForcedSilentReset = 0;
1200         priv->bDisableNormalResetCheck = false;
1201         priv->force_reset = false;
1202         memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
1203
1204         memset(&priv->InterruptLog, 0, sizeof(struct log_int_8190));
1205         priv->RxCounter = 0;
1206         priv->rtllib->wx_set_enc = 0;
1207         priv->bHwRadioOff = false;
1208         priv->RegRfOff = 0;
1209         priv->isRFOff = false;
1210         priv->bInPowerSaveMode = false;
1211         priv->rtllib->RfOffReason = 0;
1212         priv->RFChangeInProgress = false;
1213         priv->bHwRfOffAction = 0;
1214         priv->SetRFPowerStateInProgress = false;
1215         priv->rtllib->PowerSaveControl.bInactivePs = true;
1216         priv->rtllib->PowerSaveControl.bIPSModeBackup = false;
1217         priv->rtllib->PowerSaveControl.bLeisurePs = true;
1218         priv->rtllib->PowerSaveControl.bFwCtrlLPS = false;
1219         priv->rtllib->LPSDelayCnt = 0;
1220         priv->rtllib->sta_sleep = LPS_IS_WAKE;
1221         priv->rtllib->eRFPowerState = eRfOn;
1222
1223         priv->txpower_checkcnt = 0;
1224         priv->thermal_readback_index = 0;
1225         priv->txpower_tracking_callback_cnt = 0;
1226         priv->ccktxpower_adjustcnt_ch14 = 0;
1227         priv->ccktxpower_adjustcnt_not_ch14 = 0;
1228
1229         priv->rtllib->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
1230         priv->rtllib->iw_mode = IW_MODE_INFRA;
1231         priv->rtllib->active_scan = 1;
1232         priv->rtllib->be_scan_inprogress = false;
1233         priv->rtllib->modulation = RTLLIB_CCK_MODULATION |
1234                                    RTLLIB_OFDM_MODULATION;
1235         priv->rtllib->host_encrypt = 1;
1236         priv->rtllib->host_decrypt = 1;
1237
1238         priv->rtllib->dot11PowerSaveMode = eActive;
1239         priv->rtllib->fts = DEFAULT_FRAG_THRESHOLD;
1240         priv->rtllib->MaxMssDensity = 0;
1241         priv->rtllib->MinSpaceCfg = 0;
1242
1243         priv->card_type = PCI;
1244
1245         priv->AcmControl = 0;
1246         priv->pFirmware = vmalloc(sizeof(struct rt_firmware));
1247         if (priv->pFirmware)
1248                 memset(priv->pFirmware, 0, sizeof(struct rt_firmware));
1249
1250         skb_queue_head_init(&priv->rx_queue);
1251         skb_queue_head_init(&priv->skb_queue);
1252
1253         for (i = 0; i < MAX_QUEUE_SIZE; i++)
1254                 skb_queue_head_init(&priv->rtllib->skb_waitQ[i]);
1255         for (i = 0; i < MAX_QUEUE_SIZE; i++)
1256                 skb_queue_head_init(&priv->rtllib->skb_aggQ[i]);
1257 }
1258
1259 static void rtl8192_init_priv_lock(struct r8192_priv *priv)
1260 {
1261         spin_lock_init(&priv->fw_scan_lock);
1262         spin_lock_init(&priv->tx_lock);
1263         spin_lock_init(&priv->irq_lock);
1264         spin_lock_init(&priv->irq_th_lock);
1265         spin_lock_init(&priv->rf_ps_lock);
1266         spin_lock_init(&priv->ps_lock);
1267         spin_lock_init(&priv->rf_lock);
1268         spin_lock_init(&priv->rt_h2c_lock);
1269         sema_init(&priv->wx_sem, 1);
1270         sema_init(&priv->rf_sem, 1);
1271         mutex_init(&priv->mutex);
1272 }
1273
1274 static void rtl8192_init_priv_task(struct net_device *dev)
1275 {
1276         struct r8192_priv *priv = rtllib_priv(dev);
1277
1278         priv->priv_wq = create_workqueue(DRV_NAME);
1279         INIT_WORK_RSL(&priv->reset_wq, (void *)rtl8192_restart, dev);
1280         INIT_WORK_RSL(&priv->rtllib->ips_leave_wq, (void *)IPSLeave_wq, dev);
1281         INIT_DELAYED_WORK_RSL(&priv->watch_dog_wq,
1282                               (void *)rtl819x_watchdog_wqcallback, dev);
1283         INIT_DELAYED_WORK_RSL(&priv->txpower_tracking_wq,
1284                               (void *)dm_txpower_trackingcallback, dev);
1285         INIT_DELAYED_WORK_RSL(&priv->rfpath_check_wq,
1286                               (void *)dm_rf_pathcheck_workitemcallback, dev);
1287         INIT_DELAYED_WORK_RSL(&priv->update_beacon_wq,
1288                               (void *)rtl8192_update_beacon, dev);
1289         INIT_WORK_RSL(&priv->qos_activate, (void *)rtl8192_qos_activate, dev);
1290         INIT_DELAYED_WORK_RSL(&priv->rtllib->hw_wakeup_wq,
1291                               (void *) rtl8192_hw_wakeup_wq, dev);
1292         INIT_DELAYED_WORK_RSL(&priv->rtllib->hw_sleep_wq,
1293                               (void *) rtl8192_hw_sleep_wq, dev);
1294         tasklet_init(&priv->irq_rx_tasklet,
1295                      (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
1296                      (unsigned long)priv);
1297         tasklet_init(&priv->irq_tx_tasklet,
1298                      (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
1299                      (unsigned long)priv);
1300         tasklet_init(&priv->irq_prepare_beacon_tasklet,
1301                      (void(*)(unsigned long))rtl8192_prepare_beacon,
1302                      (unsigned long)priv);
1303 }
1304
1305 short rtl8192_get_channel_map(struct net_device *dev)
1306 {
1307         int i;
1308
1309         struct r8192_priv *priv = rtllib_priv(dev);
1310         if ((priv->rf_chip != RF_8225) && (priv->rf_chip != RF_8256)
1311                         && (priv->rf_chip != RF_6052)) {
1312                 RT_TRACE(COMP_ERR, "%s: unknown rf chip, can't set channel "
1313                          "map\n", __func__);
1314                 return -1;
1315         }
1316
1317         if (priv->ChannelPlan > COUNTRY_CODE_MAX) {
1318                 printk(KERN_INFO "rtl819x_init:Error channel plan! Set to "
1319                        "default.\n");
1320                 priv->ChannelPlan = COUNTRY_CODE_FCC;
1321         }
1322         RT_TRACE(COMP_INIT, "Channel plan is %d\n", priv->ChannelPlan);
1323         Dot11d_Init(priv->rtllib);
1324         Dot11d_Channelmap(priv->ChannelPlan, priv->rtllib);
1325         for (i = 1; i <= 11; i++)
1326                 (priv->rtllib->active_channel_map)[i] = 1;
1327         (priv->rtllib->active_channel_map)[12] = 2;
1328         (priv->rtllib->active_channel_map)[13] = 2;
1329
1330         return 0;
1331 }
1332
1333 short rtl8192_init(struct net_device *dev)
1334 {
1335         struct r8192_priv *priv = rtllib_priv(dev);
1336
1337         memset(&(priv->stats), 0, sizeof(struct rt_stats));
1338
1339         rtl8192_dbgp_flag_init(dev);
1340         rtl8192_init_priv_handler(dev);
1341         rtl8192_init_priv_constant(dev);
1342         rtl8192_init_priv_variable(dev);
1343         rtl8192_init_priv_lock(priv);
1344         rtl8192_init_priv_task(dev);
1345         priv->ops->get_eeprom_size(dev);
1346         priv->ops->init_adapter_variable(dev);
1347         rtl8192_get_channel_map(dev);
1348
1349         init_hal_dm(dev);
1350
1351         init_timer(&priv->watch_dog_timer);
1352         setup_timer(&priv->watch_dog_timer,
1353                     watch_dog_timer_callback,
1354                     (unsigned long) dev);
1355
1356         init_timer(&priv->gpio_polling_timer);
1357         setup_timer(&priv->gpio_polling_timer,
1358                     check_rfctrl_gpio_timer,
1359                     (unsigned long)dev);
1360
1361         rtl8192_irq_disable(dev);
1362         if (request_irq(dev->irq, (void *)rtl8192_interrupt_rsl, IRQF_SHARED,
1363             dev->name, dev)) {
1364                 printk(KERN_ERR "Error allocating IRQ %d", dev->irq);
1365                 return -1;
1366         } else {
1367                 priv->irq = dev->irq;
1368                 RT_TRACE(COMP_INIT, "IRQ %d\n", dev->irq);
1369         }
1370
1371         if (rtl8192_pci_initdescring(dev) != 0) {
1372                 printk(KERN_ERR "Endopoints initialization failed");
1373                 return -1;
1374         }
1375
1376         return 0;
1377 }
1378
1379 /***************************************************************************
1380         -------------------------------WATCHDOG STUFF---------------------------
1381 ***************************************************************************/
1382 short rtl8192_is_tx_queue_empty(struct net_device *dev)
1383 {
1384         int i = 0;
1385         struct r8192_priv *priv = rtllib_priv(dev);
1386         for (i = 0; i <= MGNT_QUEUE; i++) {
1387                 if ((i == TXCMD_QUEUE) || (i == HCCA_QUEUE))
1388                         continue;
1389                 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0) {
1390                         printk(KERN_INFO "===>tx queue is not empty:%d, %d\n",
1391                                i, skb_queue_len(&(&priv->tx_ring[i])->queue));
1392                         return 0;
1393                 }
1394         }
1395         return 1;
1396 }
1397
1398 enum reset_type rtl819x_TxCheckStuck(struct net_device *dev)
1399 {
1400         struct r8192_priv *priv = rtllib_priv(dev);
1401         u8      QueueID;
1402         u8      ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
1403         bool    bCheckFwTxCnt = false;
1404         struct rtl8192_tx_ring  *ring = NULL;
1405         struct sk_buff *skb = NULL;
1406         struct cb_desc *tcb_desc = NULL;
1407         unsigned long flags = 0;
1408
1409         switch (priv->rtllib->ps) {
1410         case RTLLIB_PS_DISABLED:
1411                 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
1412                 break;
1413         case (RTLLIB_PS_MBCAST|RTLLIB_PS_UNICAST):
1414                 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
1415                 break;
1416         default:
1417                 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
1418                 break;
1419         }
1420         spin_lock_irqsave(&priv->irq_th_lock, flags);
1421         for (QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++) {
1422                 if (QueueID == TXCMD_QUEUE)
1423                         continue;
1424
1425                 if (QueueID == BEACON_QUEUE)
1426                         continue;
1427
1428                 ring = &priv->tx_ring[QueueID];
1429
1430                 if (skb_queue_len(&ring->queue) == 0) {
1431                         continue;
1432                 } else {
1433                         skb = (&ring->queue)->next;
1434                         tcb_desc = (struct cb_desc *)(skb->cb +
1435                                     MAX_DEV_ADDR_SIZE);
1436                         tcb_desc->nStuckCount++;
1437                         bCheckFwTxCnt = true;
1438                         if (tcb_desc->nStuckCount > 1)
1439                                 printk(KERN_INFO "%s: QueueID=%d tcb_desc->n"
1440                                        "StuckCount=%d\n", __func__, QueueID,
1441                                        tcb_desc->nStuckCount);
1442                 }
1443         }
1444         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1445
1446         if (bCheckFwTxCnt) {
1447                 if (priv->ops->TxCheckStuckHandler(dev)) {
1448                         RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no"
1449                                  " Tx condition!\n");
1450                         return RESET_TYPE_SILENT;
1451                 }
1452         }
1453
1454         return RESET_TYPE_NORESET;
1455 }
1456
1457 enum reset_type rtl819x_RxCheckStuck(struct net_device *dev)
1458 {
1459         struct r8192_priv *priv = rtllib_priv(dev);
1460
1461         if (priv->ops->RxCheckStuckHandler(dev)) {
1462                 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
1463                 return RESET_TYPE_SILENT;
1464         }
1465
1466         return RESET_TYPE_NORESET;
1467 }
1468
1469 enum reset_type
1470 rtl819x_ifcheck_resetornot(struct net_device *dev)
1471 {
1472         struct r8192_priv *priv = rtllib_priv(dev);
1473         enum reset_type TxResetType = RESET_TYPE_NORESET;
1474         enum reset_type RxResetType = RESET_TYPE_NORESET;
1475         enum rt_rf_power_state rfState;
1476
1477         rfState = priv->rtllib->eRFPowerState;
1478
1479         if (rfState == eRfOn)
1480                 TxResetType = rtl819x_TxCheckStuck(dev);
1481
1482         if (rfState == eRfOn &&
1483             (priv->rtllib->iw_mode == IW_MODE_INFRA) &&
1484             (priv->rtllib->state == RTLLIB_LINKED))
1485                 RxResetType = rtl819x_RxCheckStuck(dev);
1486
1487         if (TxResetType == RESET_TYPE_NORMAL ||
1488             RxResetType == RESET_TYPE_NORMAL) {
1489                 printk(KERN_INFO "%s(): TxResetType is %d, RxResetType is %d\n",
1490                        __func__, TxResetType, RxResetType);
1491                 return RESET_TYPE_NORMAL;
1492         } else if (TxResetType == RESET_TYPE_SILENT ||
1493                    RxResetType == RESET_TYPE_SILENT) {
1494                 printk(KERN_INFO "%s(): TxResetType is %d, RxResetType is %d\n",
1495                        __func__, TxResetType, RxResetType);
1496                 return RESET_TYPE_SILENT;
1497         } else {
1498                 return RESET_TYPE_NORESET;
1499         }
1500
1501 }
1502
1503 void rtl819x_silentreset_mesh_bk(struct net_device *dev, u8 IsPortal)
1504 {
1505 }
1506
1507 void rtl819x_ifsilentreset(struct net_device *dev)
1508 {
1509         struct r8192_priv *priv = rtllib_priv(dev);
1510         u8      reset_times = 0;
1511         int reset_status = 0;
1512         struct rtllib_device *ieee = priv->rtllib;
1513         unsigned long flag;
1514
1515         u8 IsPortal = 0;
1516
1517
1518         if (priv->ResetProgress == RESET_TYPE_NORESET) {
1519
1520                 RT_TRACE(COMP_RESET, "=========>Reset progress!!\n");
1521
1522                 priv->ResetProgress = RESET_TYPE_SILENT;
1523
1524                 spin_lock_irqsave(&priv->rf_ps_lock, flag);
1525                 if (priv->RFChangeInProgress) {
1526                         spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
1527                         goto END;
1528                 }
1529                 priv->RFChangeInProgress = true;
1530                 priv->bResetInProgress = true;
1531                 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
1532
1533 RESET_START:
1534
1535                 down(&priv->wx_sem);
1536
1537                 if (priv->rtllib->state == RTLLIB_LINKED)
1538                         LeisurePSLeave(dev);
1539
1540                 if (IS_NIC_DOWN(priv)) {
1541                         RT_TRACE(COMP_ERR, "%s():the driver is not up! "
1542                                  "return\n", __func__);
1543                         up(&priv->wx_sem);
1544                         return ;
1545                 }
1546                 priv->up = 0;
1547
1548                 RT_TRACE(COMP_RESET, "%s():======>start to down the driver\n",
1549                           __func__);
1550                 mdelay(1000);
1551                 RT_TRACE(COMP_RESET, "%s():111111111111111111111111======>start"
1552                          " to down the driver\n", __func__);
1553
1554                 if (!netif_queue_stopped(dev))
1555                         netif_stop_queue(dev);
1556
1557                 rtl8192_irq_disable(dev);
1558                 del_timer_sync(&priv->watch_dog_timer);
1559                 rtl8192_cancel_deferred_work(priv);
1560                 deinit_hal_dm(dev);
1561                 rtllib_stop_scan_syncro(ieee);
1562
1563                 if (ieee->state == RTLLIB_LINKED) {
1564                         SEM_DOWN_IEEE_WX(&ieee->wx_sem);
1565                         printk(KERN_INFO "ieee->state is RTLLIB_LINKED\n");
1566                         rtllib_stop_send_beacons(priv->rtllib);
1567                         del_timer_sync(&ieee->associate_timer);
1568                         cancel_delayed_work(&ieee->associate_retry_wq);
1569                         rtllib_stop_scan(ieee);
1570                         netif_carrier_off(dev);
1571                         SEM_UP_IEEE_WX(&ieee->wx_sem);
1572                 } else {
1573                         printk(KERN_INFO "ieee->state is NOT LINKED\n");
1574                         rtllib_softmac_stop_protocol(priv->rtllib, 0 , true);
1575                 }
1576
1577                 dm_backup_dynamic_mechanism_state(dev);
1578
1579                 up(&priv->wx_sem);
1580                 RT_TRACE(COMP_RESET, "%s():<==========down process is "
1581                          "finished\n", __func__);
1582
1583                 RT_TRACE(COMP_RESET, "%s():<===========up process start\n",
1584                          __func__);
1585                 reset_status = _rtl8192_up(dev, true);
1586
1587                 RT_TRACE(COMP_RESET, "%s():<===========up process is "
1588                          "finished\n", __func__);
1589                 if (reset_status == -1) {
1590                         if (reset_times < 3) {
1591                                 reset_times++;
1592                                 goto RESET_START;
1593                         } else {
1594                                 RT_TRACE(COMP_ERR, " ERR!!! %s():  Reset "
1595                                          "Failed!!\n", __func__);
1596                         }
1597                 }
1598
1599                 ieee->is_silent_reset = 1;
1600
1601                 spin_lock_irqsave(&priv->rf_ps_lock, flag);
1602                 priv->RFChangeInProgress = false;
1603                 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
1604
1605                 EnableHWSecurityConfig8192(dev);
1606
1607                 if (ieee->state == RTLLIB_LINKED && ieee->iw_mode ==
1608                     IW_MODE_INFRA) {
1609                         ieee->set_chan(ieee->dev,
1610                                        ieee->current_network.channel);
1611
1612                         queue_work_rsl(ieee->wq, &ieee->associate_complete_wq);
1613
1614                 } else if (ieee->state == RTLLIB_LINKED && ieee->iw_mode ==
1615                            IW_MODE_ADHOC) {
1616                         ieee->set_chan(ieee->dev,
1617                                        ieee->current_network.channel);
1618                         ieee->link_change(ieee->dev);
1619
1620                         notify_wx_assoc_event(ieee);
1621
1622                         rtllib_start_send_beacons(ieee);
1623
1624                         if (ieee->data_hard_resume)
1625                                 ieee->data_hard_resume(ieee->dev);
1626                         netif_carrier_on(ieee->dev);
1627                 } else if (ieee->iw_mode == IW_MODE_MESH) {
1628                         rtl819x_silentreset_mesh_bk(dev, IsPortal);
1629                 }
1630
1631                 CamRestoreAllEntry(dev);
1632                 dm_restore_dynamic_mechanism_state(dev);
1633 END:
1634                 priv->ResetProgress = RESET_TYPE_NORESET;
1635                 priv->reset_count++;
1636
1637                 priv->bForcedSilentReset = false;
1638                 priv->bResetInProgress = false;
1639
1640                 write_nic_byte(dev, UFWP, 1);
1641                 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n",
1642                          priv->reset_count);
1643         }
1644 }
1645
1646 void rtl819x_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum,
1647                              u32 *TotalRxDataNum)
1648 {
1649         u16     SlotIndex;
1650         u8      i;
1651
1652         *TotalRxBcnNum = 0;
1653         *TotalRxDataNum = 0;
1654
1655         SlotIndex = (priv->rtllib->LinkDetectInfo.SlotIndex++) %
1656                         (priv->rtllib->LinkDetectInfo.SlotNum);
1657         priv->rtllib->LinkDetectInfo.RxBcnNum[SlotIndex] =
1658                         priv->rtllib->LinkDetectInfo.NumRecvBcnInPeriod;
1659         priv->rtllib->LinkDetectInfo.RxDataNum[SlotIndex] =
1660                         priv->rtllib->LinkDetectInfo.NumRecvDataInPeriod;
1661         for (i = 0; i < priv->rtllib->LinkDetectInfo.SlotNum; i++) {
1662                 *TotalRxBcnNum += priv->rtllib->LinkDetectInfo.RxBcnNum[i];
1663                 *TotalRxDataNum += priv->rtllib->LinkDetectInfo.RxDataNum[i];
1664         }
1665 }
1666
1667
1668 void    rtl819x_watchdog_wqcallback(void *data)
1669 {
1670         struct r8192_priv *priv = container_of_dwork_rsl(data,
1671                                   struct r8192_priv, watch_dog_wq);
1672         struct net_device *dev = priv->rtllib->dev;
1673         struct rtllib_device *ieee = priv->rtllib;
1674         enum reset_type ResetType = RESET_TYPE_NORESET;
1675         static u8 check_reset_cnt;
1676         unsigned long flags;
1677         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
1678                                         (&(priv->rtllib->PowerSaveControl));
1679         bool bBusyTraffic = false;
1680         bool    bHigherBusyTraffic = false;
1681         bool    bHigherBusyRxTraffic = false;
1682         bool bEnterPS = false;
1683
1684         if (IS_NIC_DOWN(priv) || (priv->bHwRadioOff == true))
1685                 return;
1686
1687         if (priv->rtllib->state >= RTLLIB_LINKED) {
1688                 if (priv->rtllib->CntAfterLink < 2)
1689                         priv->rtllib->CntAfterLink++;
1690         } else {
1691                 priv->rtllib->CntAfterLink = 0;
1692         }
1693
1694         hal_dm_watchdog(dev);
1695
1696         if (rtllib_act_scanning(priv->rtllib, false) == false) {
1697                 if ((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state ==
1698                      RTLLIB_NOLINK) &&
1699                      (ieee->eRFPowerState == eRfOn) && !ieee->is_set_key &&
1700                      (!ieee->proto_stoppping) && !ieee->wx_set_enc) {
1701                         if ((ieee->PowerSaveControl.ReturnPoint ==
1702                              IPS_CALLBACK_NONE) &&
1703                              (!ieee->bNetPromiscuousMode)) {
1704                                 RT_TRACE(COMP_PS, "====================>haha: "
1705                                          "IPSEnter()\n");
1706                                 IPSEnter(dev);
1707                         }
1708                 }
1709         }
1710         if ((ieee->state == RTLLIB_LINKED) && (ieee->iw_mode ==
1711              IW_MODE_INFRA) && (!ieee->bNetPromiscuousMode)) {
1712                 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 100 ||
1713                 ieee->LinkDetectInfo.NumTxOkInPeriod > 100)
1714                         bBusyTraffic = true;
1715
1716
1717                 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
1718                     ieee->LinkDetectInfo.NumTxOkInPeriod > 4000) {
1719                         bHigherBusyTraffic = true;
1720                         if (ieee->LinkDetectInfo.NumRxOkInPeriod > 5000)
1721                                 bHigherBusyRxTraffic = true;
1722                         else
1723                                 bHigherBusyRxTraffic = false;
1724                 }
1725
1726                 if (((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod +
1727                     ieee->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
1728                     (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))
1729                         bEnterPS = false;
1730                 else
1731                         bEnterPS = true;
1732
1733                 if (ieee->current_network.beacon_interval < 95)
1734                         bEnterPS = false;
1735
1736                 if (bEnterPS)
1737                         LeisurePSEnter(dev);
1738                 else
1739                         LeisurePSLeave(dev);
1740
1741         } else {
1742                 RT_TRACE(COMP_LPS, "====>no link LPS leave\n");
1743                 LeisurePSLeave(dev);
1744         }
1745
1746         ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
1747         ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
1748         ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
1749         ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
1750
1751         ieee->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
1752         ieee->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1753
1754         if (ieee->state == RTLLIB_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
1755                 u32     TotalRxBcnNum = 0;
1756                 u32     TotalRxDataNum = 0;
1757
1758                 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
1759
1760                 if ((TotalRxBcnNum+TotalRxDataNum) == 0)
1761                         priv->check_roaming_cnt++;
1762                 else
1763                         priv->check_roaming_cnt = 0;
1764
1765
1766                 if (priv->check_roaming_cnt > 0) {
1767                         if (ieee->eRFPowerState == eRfOff)
1768                                 RT_TRACE(COMP_ERR, "========>%s()\n", __func__);
1769
1770                         printk(KERN_INFO "===>%s(): AP is power off, chan:%d,"
1771                                " connect another one\n", __func__, priv->chan);
1772
1773                         ieee->state = RTLLIB_ASSOCIATING;
1774
1775                         RemovePeerTS(priv->rtllib,
1776                                      priv->rtllib->current_network.bssid);
1777                         ieee->is_roaming = true;
1778                         ieee->is_set_key = false;
1779                         ieee->link_change(dev);
1780                         if (ieee->LedControlHandler)
1781                                 ieee->LedControlHandler(ieee->dev,
1782                                                         LED_CTL_START_TO_LINK);
1783
1784                         notify_wx_assoc_event(ieee);
1785
1786                         if (!(ieee->rtllib_ap_sec_type(ieee) &
1787                              (SEC_ALG_CCMP|SEC_ALG_TKIP)))
1788                                 queue_delayed_work_rsl(ieee->wq,
1789                                         &ieee->associate_procedure_wq, 0);
1790
1791                         priv->check_roaming_cnt = 0;
1792                 }
1793                 ieee->LinkDetectInfo.NumRecvBcnInPeriod = 0;
1794                 ieee->LinkDetectInfo.NumRecvDataInPeriod = 0;
1795
1796         }
1797
1798         spin_lock_irqsave(&priv->tx_lock, flags);
1799         if ((check_reset_cnt++ >= 3) && (!ieee->is_roaming) &&
1800             (!priv->RFChangeInProgress) && (!pPSC->bSwRfProcessing)) {
1801                 ResetType = rtl819x_ifcheck_resetornot(dev);
1802                 check_reset_cnt = 3;
1803         }
1804         spin_unlock_irqrestore(&priv->tx_lock, flags);
1805
1806         if (!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL) {
1807                 priv->ResetProgress = RESET_TYPE_NORMAL;
1808                 RT_TRACE(COMP_RESET, "%s(): NOMAL RESET\n", __func__);
1809                 return;
1810         }
1811
1812         if (((priv->force_reset) || (!priv->bDisableNormalResetCheck &&
1813               ResetType == RESET_TYPE_SILENT)))
1814                 rtl819x_ifsilentreset(dev);
1815         priv->force_reset = false;
1816         priv->bForcedSilentReset = false;
1817         priv->bResetInProgress = false;
1818         RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
1819 }
1820
1821 void watch_dog_timer_callback(unsigned long data)
1822 {
1823         struct r8192_priv *priv = rtllib_priv((struct net_device *)data);
1824         queue_delayed_work_rsl(priv->priv_wq, &priv->watch_dog_wq, 0);
1825         mod_timer(&priv->watch_dog_timer, jiffies +
1826                   MSECS(RTLLIB_WATCH_DOG_TIME));
1827 }
1828
1829 /****************************************************************************
1830  ---------------------------- NIC TX/RX STUFF---------------------------
1831 *****************************************************************************/
1832 void rtl8192_rx_enable(struct net_device *dev)
1833 {
1834         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1835         priv->ops->rx_enable(dev);
1836 }
1837
1838 void rtl8192_tx_enable(struct net_device *dev)
1839 {
1840         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1841
1842         priv->ops->tx_enable(dev);
1843
1844         rtllib_reset_queue(priv->rtllib);
1845 }
1846
1847
1848 static void rtl8192_free_rx_ring(struct net_device *dev)
1849 {
1850         struct r8192_priv *priv = rtllib_priv(dev);
1851         int i, rx_queue_idx;
1852
1853         for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE;
1854              rx_queue_idx++) {
1855                 for (i = 0; i < priv->rxringcount; i++) {
1856                         struct sk_buff *skb = priv->rx_buf[rx_queue_idx][i];
1857                         if (!skb)
1858                                 continue;
1859
1860                         pci_unmap_single(priv->pdev,
1861                                 *((dma_addr_t *)skb->cb),
1862                                 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1863                                 kfree_skb(skb);
1864                 }
1865
1866                 pci_free_consistent(priv->pdev,
1867                         sizeof(*priv->rx_ring[rx_queue_idx]) *
1868                         priv->rxringcount,
1869                         priv->rx_ring[rx_queue_idx],
1870                         priv->rx_ring_dma[rx_queue_idx]);
1871                 priv->rx_ring[rx_queue_idx] = NULL;
1872         }
1873 }
1874
1875 static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
1876 {
1877         struct r8192_priv *priv = rtllib_priv(dev);
1878         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1879
1880         while (skb_queue_len(&ring->queue)) {
1881                 struct tx_desc *entry = &ring->desc[ring->idx];
1882                 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1883
1884                 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1885                         skb->len, PCI_DMA_TODEVICE);
1886                 kfree_skb(skb);
1887                 ring->idx = (ring->idx + 1) % ring->entries;
1888         }
1889
1890         pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
1891         ring->desc, ring->dma);
1892         ring->desc = NULL;
1893 }
1894
1895 void rtl8192_data_hard_stop(struct net_device *dev)
1896 {
1897 }
1898
1899
1900 void rtl8192_data_hard_resume(struct net_device *dev)
1901 {
1902 }
1903
1904 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev,
1905                             int rate)
1906 {
1907         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1908         int ret;
1909         struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1910                                     MAX_DEV_ADDR_SIZE);
1911         u8 queue_index = tcb_desc->queue_index;
1912
1913         if ((priv->rtllib->eRFPowerState == eRfOff) || IS_NIC_DOWN(priv) ||
1914              priv->bResetInProgress) {
1915                 kfree_skb(skb);
1916                 return;
1917         }
1918
1919         assert(queue_index != TXCMD_QUEUE);
1920
1921
1922         memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
1923         skb_push(skb, priv->rtllib->tx_headroom);
1924         ret = rtl8192_tx(dev, skb);
1925         if (ret != 0) {
1926                 kfree_skb(skb);
1927         };
1928
1929         if (queue_index != MGNT_QUEUE) {
1930                 priv->rtllib->stats.tx_bytes += (skb->len -
1931                                                  priv->rtllib->tx_headroom);
1932                 priv->rtllib->stats.tx_packets++;
1933         }
1934
1935
1936         return;
1937 }
1938
1939 int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1940 {
1941         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1942         int ret;
1943         struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1944                                     MAX_DEV_ADDR_SIZE);
1945         u8 queue_index = tcb_desc->queue_index;
1946
1947         if (queue_index != TXCMD_QUEUE) {
1948                 if ((priv->rtllib->eRFPowerState == eRfOff) ||
1949                      IS_NIC_DOWN(priv) || priv->bResetInProgress) {
1950                         kfree_skb(skb);
1951                         return 0;
1952                 }
1953         }
1954
1955         memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
1956         if (queue_index == TXCMD_QUEUE) {
1957                 rtl8192_tx_cmd(dev, skb);
1958                 ret = 0;
1959                 return ret;
1960         } else {
1961                 tcb_desc->RATRIndex = 7;
1962                 tcb_desc->bTxDisableRateFallBack = 1;
1963                 tcb_desc->bTxUseDriverAssingedRate = 1;
1964                 tcb_desc->bTxEnableFwCalcDur = 1;
1965                 skb_push(skb, priv->rtllib->tx_headroom);
1966                 ret = rtl8192_tx(dev, skb);
1967                 if (ret != 0) {
1968                         kfree_skb(skb);
1969                 };
1970         }
1971
1972
1973
1974         return ret;
1975
1976 }
1977
1978 void rtl8192_tx_isr(struct net_device *dev, int prio)
1979 {
1980         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1981
1982         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1983
1984         while (skb_queue_len(&ring->queue)) {
1985                 struct tx_desc *entry = &ring->desc[ring->idx];
1986                 struct sk_buff *skb;
1987
1988                 if (prio != BEACON_QUEUE) {
1989                         if (entry->OWN)
1990                                 return;
1991                         ring->idx = (ring->idx + 1) % ring->entries;
1992                 }
1993
1994                 skb = __skb_dequeue(&ring->queue);
1995                 pci_unmap_single(priv->pdev, le32_to_cpu(entry->TxBuffAddr),
1996                 skb->len, PCI_DMA_TODEVICE);
1997
1998                 kfree_skb(skb);
1999         }
2000         if (prio != BEACON_QUEUE)
2001                 tasklet_schedule(&priv->irq_tx_tasklet);
2002 }
2003
2004 void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb)
2005 {
2006         struct r8192_priv *priv = rtllib_priv(dev);
2007         struct rtl8192_tx_ring *ring;
2008         struct tx_desc_cmd *entry;
2009         unsigned int idx;
2010         struct cb_desc *tcb_desc;
2011         unsigned long flags;
2012
2013         spin_lock_irqsave(&priv->irq_th_lock, flags);
2014         ring = &priv->tx_ring[TXCMD_QUEUE];
2015
2016         idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
2017         entry = (struct tx_desc_cmd *) &ring->desc[idx];
2018
2019         tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2020
2021         priv->ops->tx_fill_cmd_descriptor(dev, entry, tcb_desc, skb);
2022
2023         __skb_queue_tail(&ring->queue, skb);
2024         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2025
2026         return;
2027 }
2028
2029 short rtl8192_tx(struct net_device *dev, struct sk_buff *skb)
2030 {
2031         struct r8192_priv *priv = rtllib_priv(dev);
2032         struct rtl8192_tx_ring  *ring;
2033         unsigned long flags;
2034         struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
2035                                     MAX_DEV_ADDR_SIZE);
2036         struct tx_desc *pdesc = NULL;
2037         struct rtllib_hdr_1addr *header = NULL;
2038         u16 fc = 0, type = 0, stype = 0;
2039         bool  multi_addr = false, broad_addr = false, uni_addr = false;
2040         u8 *pda_addr = NULL;
2041         int   idx;
2042         u32 fwinfo_size = 0;
2043
2044         if (priv->bdisable_nic) {
2045                 RT_TRACE(COMP_ERR, "%s: ERR!! Nic is disabled! Can't tx packet"
2046                          " len=%d qidx=%d!!!\n", __func__, skb->len,
2047                          tcb_desc->queue_index);
2048                 return skb->len;
2049         }
2050
2051         priv->rtllib->bAwakePktSent = true;
2052
2053         fwinfo_size = sizeof(struct tx_fwinfo_8190pci);
2054
2055         header = (struct rtllib_hdr_1addr *)(((u8 *)skb->data) + fwinfo_size);
2056         fc = header->frame_ctl;
2057         type = WLAN_FC_GET_TYPE(fc);
2058         stype = WLAN_FC_GET_STYPE(fc);
2059         pda_addr = header->addr1;
2060
2061         if (is_multicast_ether_addr(pda_addr))
2062                 multi_addr = true;
2063         else if (is_broadcast_ether_addr(pda_addr))
2064                 broad_addr = true;
2065         else
2066                 uni_addr = true;
2067
2068         if (uni_addr)
2069                 priv->stats.txbytesunicast += skb->len - fwinfo_size;
2070         else if (multi_addr)
2071                 priv->stats.txbytesmulticast += skb->len - fwinfo_size;
2072         else
2073                 priv->stats.txbytesbroadcast += skb->len - fwinfo_size;
2074
2075         spin_lock_irqsave(&priv->irq_th_lock, flags);
2076         ring = &priv->tx_ring[tcb_desc->queue_index];
2077         if (tcb_desc->queue_index != BEACON_QUEUE)
2078                 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
2079         else
2080                 idx = 0;
2081
2082         pdesc = &ring->desc[idx];
2083         if ((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
2084                 RT_TRACE(COMP_ERR, "No more TX desc@%d, ring->idx = %d, idx = "
2085                          "%d, skblen = 0x%x queuelen=%d",
2086                          tcb_desc->queue_index, ring->idx, idx, skb->len,
2087                          skb_queue_len(&ring->queue));
2088                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2089                 return skb->len;
2090         }
2091
2092         if (type == RTLLIB_FTYPE_DATA) {
2093                 if (priv->rtllib->LedControlHandler)
2094                         priv->rtllib->LedControlHandler(dev, LED_CTL_TX);
2095         }
2096         priv->ops->tx_fill_descriptor(dev, pdesc, tcb_desc, skb);
2097         __skb_queue_tail(&ring->queue, skb);
2098         pdesc->OWN = 1;
2099         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2100         dev->trans_start = jiffies;
2101
2102         write_nic_word(dev, TPPoll, 0x01 << tcb_desc->queue_index);
2103         return 0;
2104 }
2105
2106 short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
2107 {
2108         struct r8192_priv *priv = rtllib_priv(dev);
2109         struct rx_desc *entry = NULL;
2110         int i, rx_queue_idx;
2111
2112         for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE; rx_queue_idx++) {
2113                 priv->rx_ring[rx_queue_idx] = pci_alloc_consistent(priv->pdev,
2114                                         sizeof(*priv->rx_ring[rx_queue_idx]) *
2115                                         priv->rxringcount,
2116                                         &priv->rx_ring_dma[rx_queue_idx]);
2117
2118                 if (!priv->rx_ring[rx_queue_idx] ||
2119                     (unsigned long)priv->rx_ring[rx_queue_idx] & 0xFF) {
2120                         RT_TRACE(COMP_ERR, "Cannot allocate RX ring\n");
2121                         return -ENOMEM;
2122                 }
2123
2124                 memset(priv->rx_ring[rx_queue_idx], 0,
2125                        sizeof(*priv->rx_ring[rx_queue_idx]) *
2126                        priv->rxringcount);
2127                 priv->rx_idx[rx_queue_idx] = 0;
2128
2129                 for (i = 0; i < priv->rxringcount; i++) {
2130                         struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
2131                         dma_addr_t *mapping;
2132                         entry = &priv->rx_ring[rx_queue_idx][i];
2133                         if (!skb)
2134                                 return 0;
2135                         skb->dev = dev;
2136                         priv->rx_buf[rx_queue_idx][i] = skb;
2137                         mapping = (dma_addr_t *)skb->cb;
2138                         *mapping = pci_map_single(priv->pdev,
2139                                                   skb_tail_pointer_rsl(skb),
2140                                                   priv->rxbuffersize,
2141                                                   PCI_DMA_FROMDEVICE);
2142
2143                         entry->BufferAddress = cpu_to_le32(*mapping);
2144
2145                         entry->Length = priv->rxbuffersize;
2146                         entry->OWN = 1;
2147                 }
2148
2149                 entry->EOR = 1;
2150         }
2151         return 0;
2152 }
2153
2154 static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
2155         unsigned int prio, unsigned int entries)
2156 {
2157         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2158         struct tx_desc *ring;
2159         dma_addr_t dma;
2160         int i;
2161
2162         ring = pci_alloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
2163         if (!ring || (unsigned long)ring & 0xFF) {
2164                 RT_TRACE(COMP_ERR, "Cannot allocate TX ring (prio = %d)\n",
2165                          prio);
2166                 return -ENOMEM;
2167         }
2168
2169         memset(ring, 0, sizeof(*ring)*entries);
2170         priv->tx_ring[prio].desc = ring;
2171         priv->tx_ring[prio].dma = dma;
2172         priv->tx_ring[prio].idx = 0;
2173         priv->tx_ring[prio].entries = entries;
2174         skb_queue_head_init(&priv->tx_ring[prio].queue);
2175
2176         for (i = 0; i < entries; i++)
2177                 ring[i].NextDescAddress =
2178                         cpu_to_le32((u32)dma + ((i + 1) % entries) *
2179                         sizeof(*ring));
2180
2181         return 0;
2182 }
2183
2184
2185 short rtl8192_pci_initdescring(struct net_device *dev)
2186 {
2187         u32 ret;
2188         int i;
2189         struct r8192_priv *priv = rtllib_priv(dev);
2190
2191         ret = rtl8192_alloc_rx_desc_ring(dev);
2192         if (ret)
2193                 return ret;
2194
2195         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
2196                 ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount);
2197                 if (ret)
2198                         goto err_free_rings;
2199         }
2200
2201         return 0;
2202
2203 err_free_rings:
2204         rtl8192_free_rx_ring(dev);
2205         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
2206                 if (priv->tx_ring[i].desc)
2207                         rtl8192_free_tx_ring(dev, i);
2208         return 1;
2209 }
2210
2211 void rtl8192_pci_resetdescring(struct net_device *dev)
2212 {
2213         struct r8192_priv *priv = rtllib_priv(dev);
2214         int i, rx_queue_idx;
2215         unsigned long flags = 0;
2216
2217         for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE; rx_queue_idx++) {
2218                 if (priv->rx_ring[rx_queue_idx]) {
2219                         struct rx_desc *entry = NULL;
2220                         for (i = 0; i < priv->rxringcount; i++) {
2221                                 entry = &priv->rx_ring[rx_queue_idx][i];
2222                                 entry->OWN = 1;
2223                         }
2224                         priv->rx_idx[rx_queue_idx] = 0;
2225                 }
2226         }
2227
2228         spin_lock_irqsave(&priv->irq_th_lock, flags);
2229         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
2230                 if (priv->tx_ring[i].desc) {
2231                         struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
2232
2233                         while (skb_queue_len(&ring->queue)) {
2234                                 struct tx_desc *entry = &ring->desc[ring->idx];
2235                                 struct sk_buff *skb =
2236                                                  __skb_dequeue(&ring->queue);
2237
2238                                 pci_unmap_single(priv->pdev,
2239                                                  le32_to_cpu(entry->TxBuffAddr),
2240                                                  skb->len, PCI_DMA_TODEVICE);
2241                                 kfree_skb(skb);
2242                                 ring->idx = (ring->idx + 1) % ring->entries;
2243                         }
2244                         ring->idx = 0;
2245                 }
2246         }
2247         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2248 }
2249
2250 void rtl819x_UpdateRxPktTimeStamp(struct net_device *dev,
2251                                   struct rtllib_rx_stats *stats)
2252 {
2253         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2254
2255         if (stats->bIsAMPDU && !stats->bFirstMPDU)
2256                 stats->mac_time = priv->LastRxDescTSF;
2257         else
2258                 priv->LastRxDescTSF = stats->mac_time;
2259 }
2260
2261 long rtl819x_translate_todbm(struct r8192_priv *priv, u8 signal_strength_index)
2262 {
2263         long    signal_power;
2264
2265         signal_power = (long)((signal_strength_index + 1) >> 1);
2266         signal_power -= 95;
2267
2268         return signal_power;
2269 }
2270
2271
2272 void
2273 rtl819x_update_rxsignalstatistics8190pci(
2274         struct r8192_priv *priv,
2275         struct rtllib_rx_stats *pprevious_stats
2276         )
2277 {
2278         int weighting = 0;
2279
2280
2281         if (priv->stats.recv_signal_power == 0)
2282                 priv->stats.recv_signal_power =
2283                                          pprevious_stats->RecvSignalPower;
2284
2285         if (pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
2286                 weighting = 5;
2287         else if (pprevious_stats->RecvSignalPower <
2288                  priv->stats.recv_signal_power)
2289                 weighting = (-5);
2290         priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 +
2291                                         pprevious_stats->RecvSignalPower +
2292                                         weighting) / 6;
2293 }
2294
2295 void rtl819x_process_cck_rxpathsel(struct r8192_priv *priv,
2296                                    struct rtllib_rx_stats *pprevious_stats)
2297 {
2298 }
2299
2300
2301 u8 rtl819x_query_rxpwrpercentage(char antpower)
2302 {
2303         if ((antpower <= -100) || (antpower >= 20))
2304                 return  0;
2305         else if (antpower >= 0)
2306                 return  100;
2307         else
2308                 return  100 + antpower;
2309
2310 }       /* QueryRxPwrPercentage */
2311
2312 u8
2313 rtl819x_evm_dbtopercentage(
2314         char value
2315         )
2316 {
2317         char ret_val;
2318
2319         ret_val = value;
2320
2321         if (ret_val >= 0)
2322                 ret_val = 0;
2323         if (ret_val <= -33)
2324                 ret_val = -33;
2325         ret_val = 0 - ret_val;
2326         ret_val *= 3;
2327         if (ret_val == 99)
2328                 ret_val = 100;
2329         return ret_val;
2330 }
2331
2332 void
2333 rtl8192_record_rxdesc_forlateruse(
2334         struct rtllib_rx_stats *psrc_stats,
2335         struct rtllib_rx_stats *ptarget_stats
2336 )
2337 {
2338         ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
2339         ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
2340 }
2341
2342
2343
2344 void rtl8192_rx_normal(struct net_device *dev)
2345 {
2346         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2347         struct rtllib_hdr_1addr *rtllib_hdr = NULL;
2348         bool unicast_packet = false;
2349         bool bLedBlinking = true;
2350         u16 fc = 0, type = 0;
2351         u32 skb_len = 0;
2352         int rx_queue_idx = RX_MPDU_QUEUE;
2353
2354         struct rtllib_rx_stats stats = {
2355                 .signal = 0,
2356                 .noise = -98,
2357                 .rate = 0,
2358                 .freq = RTLLIB_24GHZ_BAND,
2359         };
2360         unsigned int count = priv->rxringcount;
2361
2362         stats.nic_type = NIC_8192E;
2363
2364         while (count--) {
2365                 struct rx_desc *pdesc = &priv->rx_ring[rx_queue_idx]
2366                                         [priv->rx_idx[rx_queue_idx]];
2367                 struct sk_buff *skb = priv->rx_buf[rx_queue_idx]
2368                                       [priv->rx_idx[rx_queue_idx]];
2369
2370                 if (pdesc->OWN) {
2371                         return;
2372                 } else {
2373                         struct sk_buff *new_skb;
2374
2375                         if (!priv->ops->rx_query_status_descriptor(dev, &stats,
2376                         pdesc, skb))
2377                                 goto done;
2378                         new_skb = dev_alloc_skb(priv->rxbuffersize);
2379                         /* if allocation of new skb failed - drop current packet
2380                         * and reuse skb */
2381                         if (unlikely(!new_skb))
2382                                 goto done;
2383
2384                         pci_unmap_single(priv->pdev,
2385                                         *((dma_addr_t *)skb->cb),
2386                                         priv->rxbuffersize,
2387                                         PCI_DMA_FROMDEVICE);
2388
2389                         skb_put(skb, pdesc->Length);
2390                         skb_reserve(skb, stats.RxDrvInfoSize +
2391                                 stats.RxBufShift);
2392                         skb_trim(skb, skb->len - 4/*sCrcLng*/);
2393                         rtllib_hdr = (struct rtllib_hdr_1addr *)skb->data;
2394                         if (!is_broadcast_ether_addr(rtllib_hdr->addr1) &&
2395                         !is_multicast_ether_addr(rtllib_hdr->addr1)) {
2396                                 /* unicast packet */
2397                                 unicast_packet = true;
2398                         }
2399                         fc = le16_to_cpu(rtllib_hdr->frame_ctl);
2400                         type = WLAN_FC_GET_TYPE(fc);
2401                         if (type == RTLLIB_FTYPE_MGMT)
2402                                 bLedBlinking = false;
2403
2404                         if (bLedBlinking)
2405                                 if (priv->rtllib->LedControlHandler)
2406                                         priv->rtllib->LedControlHandler(dev,
2407                                                                 LED_CTL_RX);
2408
2409                         if (stats.bCRC) {
2410                                 if (type != RTLLIB_FTYPE_MGMT)
2411                                         priv->stats.rxdatacrcerr++;
2412                                 else
2413                                         priv->stats.rxmgmtcrcerr++;
2414                         }
2415
2416                         skb_len = skb->len;
2417
2418                         if (!rtllib_rx(priv->rtllib, skb, &stats)) {
2419                                 dev_kfree_skb_any(skb);
2420                         } else {
2421                                 priv->stats.rxok++;
2422                                 if (unicast_packet)
2423                                         priv->stats.rxbytesunicast += skb_len;
2424                         }
2425
2426                         skb = new_skb;
2427                         skb->dev = dev;
2428
2429                         priv->rx_buf[rx_queue_idx][priv->rx_idx[rx_queue_idx]] =
2430                                                                          skb;
2431                         *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev,
2432                                                     skb_tail_pointer_rsl(skb),
2433                                                     priv->rxbuffersize,
2434                                                     PCI_DMA_FROMDEVICE);
2435
2436                 }
2437 done:
2438                 pdesc->BufferAddress = cpu_to_le32(*((dma_addr_t *)skb->cb));
2439                 pdesc->OWN = 1;
2440                 pdesc->Length = priv->rxbuffersize;
2441                 if (priv->rx_idx[rx_queue_idx] == priv->rxringcount-1)
2442                         pdesc->EOR = 1;
2443                 priv->rx_idx[rx_queue_idx] = (priv->rx_idx[rx_queue_idx] + 1) %
2444                                               priv->rxringcount;
2445         }
2446
2447 }
2448
2449 void rtl8192_rx_cmd(struct net_device *dev)
2450 {
2451 }
2452
2453
2454 void rtl8192_tx_resume(struct net_device *dev)
2455 {
2456         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2457         struct rtllib_device *ieee = priv->rtllib;
2458         struct sk_buff *skb;
2459         int queue_index;
2460
2461         for (queue_index = BK_QUEUE;
2462              queue_index < MAX_QUEUE_SIZE; queue_index++) {
2463                 while ((!skb_queue_empty(&ieee->skb_waitQ[queue_index])) &&
2464                 (priv->rtllib->check_nic_enough_desc(dev, queue_index) > 0)) {
2465                         skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
2466                         ieee->softmac_data_hard_start_xmit(skb, dev, 0);
2467                 }
2468         }
2469 }
2470
2471 void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
2472 {
2473         rtl8192_tx_resume(priv->rtllib->dev);
2474 }
2475
2476 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
2477 {
2478         rtl8192_rx_normal(priv->rtllib->dev);
2479
2480         if (MAX_RX_QUEUE > 1)
2481                 rtl8192_rx_cmd(priv->rtllib->dev);
2482
2483         write_nic_dword(priv->rtllib->dev, INTA_MASK,
2484                         read_nic_dword(priv->rtllib->dev, INTA_MASK) | IMR_RDU);
2485 }
2486
2487 /****************************************************************************
2488  ---------------------------- NIC START/CLOSE STUFF---------------------------
2489 *****************************************************************************/
2490 void rtl8192_cancel_deferred_work(struct r8192_priv *priv)
2491 {
2492         cancel_delayed_work(&priv->watch_dog_wq);
2493         cancel_delayed_work(&priv->update_beacon_wq);
2494         cancel_delayed_work(&priv->rtllib->hw_sleep_wq);
2495         cancel_work_sync(&priv->reset_wq);
2496         cancel_work_sync(&priv->qos_activate);
2497 }
2498
2499 int _rtl8192_up(struct net_device *dev, bool is_silent_reset)
2500 {
2501         if (_rtl8192_sta_up(dev, is_silent_reset) == -1)
2502                 return -1;
2503         return 0;
2504 }
2505
2506
2507 int rtl8192_open(struct net_device *dev)
2508 {
2509         struct r8192_priv *priv = rtllib_priv(dev);
2510         int ret;
2511
2512         down(&priv->wx_sem);
2513         ret = rtl8192_up(dev);
2514         up(&priv->wx_sem);
2515         return ret;
2516
2517 }
2518
2519
2520 int rtl8192_up(struct net_device *dev)
2521 {
2522         struct r8192_priv *priv = rtllib_priv(dev);
2523
2524         if (priv->up == 1)
2525                 return -1;
2526         return _rtl8192_up(dev, false);
2527 }
2528
2529
2530 int rtl8192_close(struct net_device *dev)
2531 {
2532         struct r8192_priv *priv = rtllib_priv(dev);
2533         int ret;
2534
2535         if ((rtllib_act_scanning(priv->rtllib, false)) &&
2536                 !(priv->rtllib->softmac_features & IEEE_SOFTMAC_SCAN)) {
2537                 rtllib_stop_scan(priv->rtllib);
2538         }
2539
2540         down(&priv->wx_sem);
2541
2542         ret = rtl8192_down(dev, true);
2543
2544         up(&priv->wx_sem);
2545
2546         return ret;
2547
2548 }
2549
2550 int rtl8192_down(struct net_device *dev, bool shutdownrf)
2551 {
2552         if (rtl8192_sta_down(dev, shutdownrf) == -1)
2553                 return -1;
2554
2555         return 0;
2556 }
2557
2558 void rtl8192_commit(struct net_device *dev)
2559 {
2560         struct r8192_priv *priv = rtllib_priv(dev);
2561
2562         if (priv->up == 0)
2563                 return;
2564         rtllib_softmac_stop_protocol(priv->rtllib, 0 , true);
2565         rtl8192_irq_disable(dev);
2566         priv->ops->stop_adapter(dev, true);
2567         _rtl8192_up(dev, false);
2568 }
2569
2570 void rtl8192_restart(void *data)
2571 {
2572         struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv,
2573                                   reset_wq);
2574         struct net_device *dev = priv->rtllib->dev;
2575
2576         down(&priv->wx_sem);
2577
2578         rtl8192_commit(dev);
2579
2580         up(&priv->wx_sem);
2581 }
2582
2583 static void r8192_set_multicast(struct net_device *dev)
2584 {
2585         struct r8192_priv *priv = rtllib_priv(dev);
2586         short promisc;
2587
2588         promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2589         priv->promisc = promisc;
2590
2591 }
2592
2593
2594 int r8192_set_mac_adr(struct net_device *dev, void *mac)
2595 {
2596         struct r8192_priv *priv = rtllib_priv(dev);
2597         struct sockaddr *addr = mac;
2598
2599         down(&priv->wx_sem);
2600
2601         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
2602
2603         schedule_work(&priv->reset_wq);
2604         up(&priv->wx_sem);
2605
2606         return 0;
2607 }
2608
2609 /* based on ipw2200 driver */
2610 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2611 {
2612         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2613         struct iwreq *wrq = (struct iwreq *)rq;
2614         int ret = -1;
2615         struct rtllib_device *ieee = priv->rtllib;
2616         u32 key[4];
2617         u8 broadcast_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
2618         u8 zero_addr[6] = {0};
2619         struct iw_point *p = &wrq->u.data;
2620         struct ieee_param *ipw = NULL;
2621
2622         down(&priv->wx_sem);
2623
2624         switch (cmd) {
2625         case RTL_IOCTL_WPA_SUPPLICANT:
2626                 if (p->length < sizeof(struct ieee_param) || !p->pointer) {
2627                         ret = -EINVAL;
2628                         goto out;
2629                 }
2630
2631                 ipw = kmalloc(p->length, GFP_KERNEL);
2632                 if (ipw == NULL) {
2633                         ret = -ENOMEM;
2634                         goto out;
2635                 }
2636                 if (copy_from_user(ipw, p->pointer, p->length)) {
2637                         kfree(ipw);
2638                         ret = -EFAULT;
2639                         goto out;
2640                 }
2641
2642                 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION) {
2643                         if (ipw->u.crypt.set_tx) {
2644                                 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
2645                                         ieee->pairwise_key_type = KEY_TYPE_CCMP;
2646                                 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
2647                                         ieee->pairwise_key_type = KEY_TYPE_TKIP;
2648                                 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
2649                                         if (ipw->u.crypt.key_len == 13)
2650                                                 ieee->pairwise_key_type =
2651                                                          KEY_TYPE_WEP104;
2652                                         else if (ipw->u.crypt.key_len == 5)
2653                                                 ieee->pairwise_key_type =
2654                                                          KEY_TYPE_WEP40;
2655                                 } else {
2656                                         ieee->pairwise_key_type = KEY_TYPE_NA;
2657                                 }
2658
2659                                 if (ieee->pairwise_key_type) {
2660                                         if (memcmp(ieee->ap_mac_addr, zero_addr,
2661                                             6) == 0)
2662                                                 ieee->iw_mode = IW_MODE_ADHOC;
2663                                         memcpy((u8 *)key, ipw->u.crypt.key, 16);
2664                                         EnableHWSecurityConfig8192(dev);
2665                                         set_swcam(dev, 4, ipw->u.crypt.idx,
2666                                                   ieee->pairwise_key_type,
2667                                                   (u8 *)ieee->ap_mac_addr,
2668                                                   0, key, 0);
2669                                         setKey(dev, 4, ipw->u.crypt.idx,
2670                                                ieee->pairwise_key_type,
2671                                                (u8 *)ieee->ap_mac_addr, 0, key);
2672                                         if (ieee->iw_mode == IW_MODE_ADHOC) {
2673                                                 set_swcam(dev, ipw->u.crypt.idx,
2674                                                         ipw->u.crypt.idx,
2675                                                         ieee->pairwise_key_type,
2676                                                         (u8 *)ieee->ap_mac_addr,
2677                                                         0, key, 0);
2678                                                 setKey(dev, ipw->u.crypt.idx,
2679                                                        ipw->u.crypt.idx,
2680                                                        ieee->pairwise_key_type,
2681                                                        (u8 *)ieee->ap_mac_addr,
2682                                                        0, key);
2683                                         }
2684                                 }
2685                                 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP)
2686                                      && ieee->pHTInfo->bCurrentHTSupport) {
2687                                         write_nic_byte(dev, 0x173, 1);
2688                                 }
2689
2690                         } else {
2691                                 memcpy((u8 *)key, ipw->u.crypt.key, 16);
2692                                 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
2693                                         ieee->group_key_type = KEY_TYPE_CCMP;
2694                                 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
2695                                         ieee->group_key_type = KEY_TYPE_TKIP;
2696                                 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
2697                                         if (ipw->u.crypt.key_len == 13)
2698                                                 ieee->group_key_type =
2699                                                          KEY_TYPE_WEP104;
2700                                         else if (ipw->u.crypt.key_len == 5)
2701                                                 ieee->group_key_type =
2702                                                          KEY_TYPE_WEP40;
2703                                 } else
2704                                         ieee->group_key_type = KEY_TYPE_NA;
2705
2706                                 if (ieee->group_key_type) {
2707                                         set_swcam(dev, ipw->u.crypt.idx,
2708                                                   ipw->u.crypt.idx,
2709                                                   ieee->group_key_type,
2710                                                   broadcast_addr, 0, key, 0);
2711                                         setKey(dev, ipw->u.crypt.idx,
2712                                                ipw->u.crypt.idx,
2713                                                ieee->group_key_type,
2714                                                broadcast_addr, 0, key);
2715                                 }
2716                         }
2717                 }
2718
2719                 ret = rtllib_wpa_supplicant_ioctl(priv->rtllib, &wrq->u.data,
2720                                                   0);
2721                 kfree(ipw);
2722                 break;
2723         default:
2724                 ret = -EOPNOTSUPP;
2725                 break;
2726         }
2727
2728 out:
2729         up(&priv->wx_sem);
2730
2731         return ret;
2732 }
2733
2734 void FairBeacon(struct net_device *dev)
2735 {
2736         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2737         struct rtllib_network *net = &priv->rtllib->current_network;
2738         static u8 i = 100;
2739         static u8 forceturn;
2740         u16 beaconint = net->beacon_interval;
2741
2742         if (priv->rtllib->iw_mode != IW_MODE_ADHOC)
2743                 return;
2744
2745         if (priv->bIbssCoordinator) {
2746                 i--;
2747
2748                 if (forceturn == 2) {
2749                         forceturn = 0;
2750                         priv->rtllib->SetHwRegHandler(dev,
2751                                                       HW_VAR_BEACON_INTERVAL,
2752                                                       (u8 *)(&beaconint));
2753                         i = 100;
2754                 }
2755
2756                 if (i <= 94) {
2757                         beaconint = beaconint+2;
2758                         priv->rtllib->SetHwRegHandler(dev,
2759                                                       HW_VAR_BEACON_INTERVAL,
2760                                                       (u8 *)(&beaconint));
2761                         forceturn = 1;
2762                 }
2763         } else {
2764                 i++;
2765
2766                 if (forceturn == 1) {
2767                         forceturn = 0;
2768                         priv->rtllib->SetHwRegHandler(dev,
2769                                                       HW_VAR_BEACON_INTERVAL,
2770                                                       (u8 *)(&beaconint));
2771                         i = 100;
2772                 }
2773
2774                 if (i >= 106) {
2775                         beaconint = beaconint-2;
2776                         priv->rtllib->SetHwRegHandler(dev,
2777                                                       HW_VAR_BEACON_INTERVAL,
2778                                                       (u8 *)(&beaconint));
2779                         forceturn = 2;
2780                 }
2781         }
2782 }
2783
2784
2785 irqreturn_type rtl8192_interrupt(int irq, void *netdev, struct pt_regs *regs)
2786 {
2787         struct net_device *dev = (struct net_device *) netdev;
2788         struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2789         unsigned long flags;
2790         u32 inta;
2791         u32 intb;
2792         intb = 0;
2793
2794         if (priv->irq_enabled == 0)
2795                 goto done;
2796
2797         spin_lock_irqsave(&priv->irq_th_lock, flags);
2798
2799         priv->ops->interrupt_recognized(dev, &inta, &intb);
2800         priv->stats.shints++;
2801
2802         if (!inta) {
2803                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2804                 goto done;
2805         }
2806
2807         if (inta == 0xffff) {
2808                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2809                 goto done;
2810         }
2811
2812         priv->stats.ints++;
2813
2814         if (!netif_running(dev)) {
2815                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2816                 goto done;
2817         }
2818
2819         if (inta & IMR_TBDOK) {
2820                 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
2821                 priv->stats.txbeaconokint++;
2822         }
2823
2824         if (inta & IMR_TBDER) {
2825                 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
2826                 priv->stats.txbeaconerr++;
2827         }
2828
2829         if (inta & IMR_BDOK)
2830                 RT_TRACE(COMP_INTR, "beacon interrupt!\n");
2831
2832         if (inta  & IMR_MGNTDOK) {
2833                 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
2834                 priv->stats.txmanageokint++;
2835                 rtl8192_tx_isr(dev, MGNT_QUEUE);
2836                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2837                 if (priv->rtllib->ack_tx_to_ieee) {
2838                         if (rtl8192_is_tx_queue_empty(dev)) {
2839                                 priv->rtllib->ack_tx_to_ieee = 0;
2840                                 rtllib_ps_tx_ack(priv->rtllib, 1);
2841                         }
2842                 }
2843                 spin_lock_irqsave(&priv->irq_th_lock, flags);
2844         }
2845
2846         if (inta & IMR_COMDOK) {
2847                 priv->stats.txcmdpktokint++;
2848                 rtl8192_tx_isr(dev, TXCMD_QUEUE);
2849         }
2850
2851         if (inta & IMR_HIGHDOK)
2852                 rtl8192_tx_isr(dev, HIGH_QUEUE);
2853
2854         if (inta & IMR_ROK) {
2855                 priv->stats.rxint++;
2856                 priv->InterruptLog.nIMR_ROK++;
2857                 tasklet_schedule(&priv->irq_rx_tasklet);
2858         }
2859
2860         if (inta & IMR_BcnInt) {
2861                 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
2862                 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
2863         }
2864
2865         if (inta & IMR_RDU) {
2866                 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
2867                 priv->stats.rxrdu++;
2868                 write_nic_dword(dev, INTA_MASK,
2869                                 read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
2870                 tasklet_schedule(&priv->irq_rx_tasklet);
2871         }
2872
2873         if (inta & IMR_RXFOVW) {
2874                 RT_TRACE(COMP_INTR, "rx overflow !\n");
2875                 priv->stats.rxoverflow++;
2876                 tasklet_schedule(&priv->irq_rx_tasklet);
2877         }
2878
2879         if (inta & IMR_TXFOVW)
2880                 priv->stats.txoverflow++;
2881
2882         if (inta & IMR_BKDOK) {
2883                 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
2884                 priv->stats.txbkokint++;
2885                 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
2886                 rtl8192_tx_isr(dev, BK_QUEUE);
2887         }
2888
2889         if (inta & IMR_BEDOK) {
2890                 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
2891                 priv->stats.txbeokint++;
2892                 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
2893                 rtl8192_tx_isr(dev, BE_QUEUE);
2894         }
2895
2896         if (inta & IMR_VIDOK) {
2897                 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
2898                 priv->stats.txviokint++;
2899                 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
2900                 rtl8192_tx_isr(dev, VI_QUEUE);
2901         }
2902
2903         if (inta & IMR_VODOK) {
2904                 priv->stats.txvookint++;
2905                 RT_TRACE(COMP_INTR, "Vo TX OK interrupt!\n");
2906                 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
2907                 rtl8192_tx_isr(dev, VO_QUEUE);
2908         }
2909
2910         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2911
2912 done:
2913
2914         return IRQ_HANDLED;
2915 }
2916
2917
2918
2919 /****************************************************************************
2920         ---------------------------- PCI_STUFF---------------------------
2921 *****************************************************************************/
2922 #ifdef HAVE_NET_DEVICE_OPS
2923 static const struct net_device_ops rtl8192_netdev_ops = {
2924         .ndo_open = rtl8192_open,
2925         .ndo_stop = rtl8192_close,
2926         .ndo_tx_timeout = rtl8192_tx_timeout,
2927         .ndo_do_ioctl = rtl8192_ioctl,
2928         .ndo_set_multicast_list = r8192_set_multicast,
2929         .ndo_set_mac_address = r8192_set_mac_adr,
2930         .ndo_validate_addr = eth_validate_addr,
2931         .ndo_change_mtu = eth_change_mtu,
2932         .ndo_start_xmit = rtllib_xmit,
2933 };
2934 #endif
2935
2936 static int __devinit rtl8192_pci_probe(struct pci_dev *pdev,
2937                         const struct pci_device_id *id)
2938 {
2939         unsigned long ioaddr = 0;
2940         struct net_device *dev = NULL;
2941         struct r8192_priv *priv = NULL;
2942         struct rtl819x_ops *ops = (struct rtl819x_ops *)(id->driver_data);
2943         unsigned long pmem_start, pmem_len, pmem_flags;
2944         int err = 0;
2945         bool bdma64 = false;
2946         u8 revision_id;
2947
2948         RT_TRACE(COMP_INIT, "Configuring chip resources");
2949
2950         if (pci_enable_device(pdev)) {
2951                 RT_TRACE(COMP_ERR, "Failed to enable PCI device");
2952                 return -EIO;
2953         }
2954
2955         pci_set_master(pdev);
2956
2957         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
2958                 if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
2959                         printk(KERN_INFO "Unable to obtain 32bit DMA for consistent allocations\n");
2960                         pci_disable_device(pdev);
2961                         return -ENOMEM;
2962                 }
2963         }
2964         dev = alloc_rtllib(sizeof(struct r8192_priv));
2965         if (!dev)
2966                 return -ENOMEM;
2967
2968         if (bdma64)
2969                 dev->features |= NETIF_F_HIGHDMA;
2970
2971         pci_set_drvdata(pdev, dev);
2972         SET_NETDEV_DEV(dev, &pdev->dev);
2973         priv = rtllib_priv(dev);
2974         priv->rtllib = (struct rtllib_device *)netdev_priv_rsl(dev);
2975         priv->pdev = pdev;
2976         priv->rtllib->pdev = pdev;
2977         if ((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK) &&
2978             (pdev->subsystem_device == 0x3304))
2979                 priv->rtllib->bSupportRemoteWakeUp = 1;
2980         else
2981                 priv->rtllib->bSupportRemoteWakeUp = 0;
2982
2983         pmem_start = pci_resource_start(pdev, 1);
2984         pmem_len = pci_resource_len(pdev, 1);
2985         pmem_flags = pci_resource_flags(pdev, 1);
2986
2987         if (!(pmem_flags & IORESOURCE_MEM)) {
2988                 RT_TRACE(COMP_ERR, "region #1 not a MMIO resource, aborting");
2989                 goto fail;
2990         }
2991
2992         printk(KERN_INFO "Memory mapped space start: 0x%08lx\n", pmem_start);
2993         if (!request_mem_region(pmem_start, pmem_len, DRV_NAME)) {
2994                 RT_TRACE(COMP_ERR, "request_mem_region failed!");
2995                 goto fail;
2996         }
2997
2998
2999         ioaddr = (unsigned long)ioremap_nocache(pmem_start, pmem_len);
3000         if (ioaddr == (unsigned long)NULL) {
3001                 RT_TRACE(COMP_ERR, "ioremap failed!");
3002                 goto fail1;
3003         }
3004
3005         dev->mem_start = ioaddr;
3006         dev->mem_end = ioaddr + pci_resource_len(pdev, 0);
3007
3008         pci_read_config_byte(pdev, 0x08, &revision_id);
3009         /* If the revisionid is 0x10, the device uses rtl8192se. */
3010         if (pdev->device == 0x8192 && revision_id == 0x10)
3011                 goto fail1;
3012
3013         priv->ops = ops;
3014
3015         if (rtl8192_pci_findadapter(pdev, dev) == false)
3016                 goto fail1;
3017
3018         dev->irq = pdev->irq;
3019         priv->irq = 0;
3020
3021 #ifdef HAVE_NET_DEVICE_OPS
3022         dev->netdev_ops = &rtl8192_netdev_ops;
3023 #else
3024         dev->open = rtl8192_open;
3025         dev->stop = rtl8192_close;
3026         dev->tx_timeout = rtl8192_tx_timeout;
3027         dev->do_ioctl = rtl8192_ioctl;
3028         dev->set_multicast_list = r8192_set_multicast;
3029         dev->set_mac_address = r8192_set_mac_adr;
3030         dev->hard_start_xmit = rtllib_xmit;
3031 #endif
3032
3033         dev->wireless_handlers = (struct iw_handler_def *)
3034                                  &r8192_wx_handlers_def;
3035         dev->ethtool_ops = &rtl819x_ethtool_ops;
3036
3037         dev->type = ARPHRD_ETHER;
3038         dev->watchdog_timeo = HZ * 3;
3039
3040         if (dev_alloc_name(dev, ifname) < 0) {
3041                 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying "
3042                          "wlan%%d...\n");
3043                         dev_alloc_name(dev, ifname);
3044         }
3045
3046         RT_TRACE(COMP_INIT, "Driver probe completed1\n");
3047         if (rtl8192_init(dev) != 0) {
3048                 RT_TRACE(COMP_ERR, "Initialization failed");
3049                 goto fail1;
3050         }
3051
3052         netif_carrier_off(dev);
3053         netif_stop_queue(dev);
3054
3055         register_netdev(dev);
3056         RT_TRACE(COMP_INIT, "dev name: %s\n", dev->name);
3057         err = rtl_debug_module_init(priv, dev->name);
3058         if (err)
3059                 RT_TRACE(COMP_DBG, "failed to create debugfs files. Ignoring "
3060                          "error: %d\n", err);
3061         rtl8192_proc_init_one(dev);
3062
3063         if (priv->polling_timer_on == 0)
3064                 check_rfctrl_gpio_timer((unsigned long)dev);
3065
3066         RT_TRACE(COMP_INIT, "Driver probe completed\n");
3067         return 0;
3068
3069 fail1:
3070         if (dev->mem_start != (unsigned long)NULL) {
3071                 iounmap((void *)dev->mem_start);
3072                 release_mem_region(pci_resource_start(pdev, 1),
3073                                 pci_resource_len(pdev, 1));
3074         }
3075
3076 fail:
3077         if (dev) {
3078                 if (priv->irq) {
3079                         free_irq(dev->irq, dev);
3080                         dev->irq = 0;
3081                 }
3082                 free_rtllib(dev);
3083         }
3084
3085         pci_disable_device(pdev);
3086
3087         DMESG("wlan driver load failed\n");
3088         pci_set_drvdata(pdev, NULL);
3089         return -ENODEV;
3090
3091 }
3092
3093 static void __devexit rtl8192_pci_disconnect(struct pci_dev *pdev)
3094 {
3095         struct net_device *dev = pci_get_drvdata(pdev);
3096         struct r8192_priv *priv ;
3097         u32 i;
3098
3099         if (dev) {
3100                 unregister_netdev(dev);
3101
3102                 priv = rtllib_priv(dev);
3103
3104                 del_timer_sync(&priv->gpio_polling_timer);
3105                 cancel_delayed_work(&priv->gpio_change_rf_wq);
3106                 priv->polling_timer_on = 0;
3107                 rtl_debug_module_remove(priv);
3108                 rtl8192_proc_remove_one(dev);
3109                 rtl8192_down(dev, true);
3110                 deinit_hal_dm(dev);
3111                 if (priv->pFirmware) {
3112                         vfree(priv->pFirmware);
3113                         priv->pFirmware = NULL;
3114                 }
3115                 destroy_workqueue(priv->priv_wq);
3116                 rtl8192_free_rx_ring(dev);
3117                 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
3118                         rtl8192_free_tx_ring(dev, i);
3119
3120                 if (priv->irq) {
3121                         printk(KERN_INFO "Freeing irq %d\n", dev->irq);
3122                         free_irq(dev->irq, dev);
3123                         priv->irq = 0;
3124                 }
3125                 free_rtllib(dev);
3126
3127                 kfree(priv->scan_cmd);
3128
3129                 if (dev->mem_start != 0) {
3130                         iounmap((void *)dev->mem_start);
3131                         release_mem_region(pci_resource_start(pdev, 1),
3132                                         pci_resource_len(pdev, 1));
3133                 }
3134         } else {
3135                 priv = rtllib_priv(dev);
3136         }
3137
3138         pci_disable_device(pdev);
3139         RT_TRACE(COMP_DOWN, "wlan driver removed\n");
3140 }
3141
3142 bool NicIFEnableNIC(struct net_device *dev)
3143 {
3144         bool init_status = true;
3145         struct r8192_priv *priv = rtllib_priv(dev);
3146         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
3147                                         (&(priv->rtllib->PowerSaveControl));
3148
3149         if (IS_NIC_DOWN(priv)) {
3150                 RT_TRACE(COMP_ERR, "ERR!!! %s(): Driver is already down!\n",
3151                          __func__);
3152                 priv->bdisable_nic = false;
3153                 return RT_STATUS_FAILURE;
3154         }
3155
3156         RT_TRACE(COMP_PS, "===========>%s()\n", __func__);
3157         priv->bfirst_init = true;
3158         init_status = priv->ops->initialize_adapter(dev);
3159         if (init_status != true) {
3160                 RT_TRACE(COMP_ERR, "ERR!!! %s(): initialization is failed!\n",
3161                          __func__);
3162                 priv->bdisable_nic = false;
3163                 return -1;
3164         }
3165         RT_TRACE(COMP_INIT, "start adapter finished\n");
3166         RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
3167         priv->bfirst_init = false;
3168
3169         rtl8192_irq_enable(dev);
3170         priv->bdisable_nic = false;
3171         RT_TRACE(COMP_PS, "<===========%s()\n", __func__);
3172         return init_status;
3173 }
3174 bool NicIFDisableNIC(struct net_device *dev)
3175 {
3176         bool    status = true;
3177         struct r8192_priv *priv = rtllib_priv(dev);
3178         u8 tmp_state = 0;
3179         RT_TRACE(COMP_PS, "=========>%s()\n", __func__);
3180         priv->bdisable_nic = true;
3181         tmp_state = priv->rtllib->state;
3182         rtllib_softmac_stop_protocol(priv->rtllib, 0, false);
3183         priv->rtllib->state = tmp_state;
3184         rtl8192_cancel_deferred_work(priv);
3185         rtl8192_irq_disable(dev);
3186
3187         priv->ops->stop_adapter(dev, false);
3188         RT_TRACE(COMP_PS, "<=========%s()\n", __func__);
3189
3190         return status;
3191 }
3192
3193 static int __init rtl8192_pci_module_init(void)
3194 {
3195         int ret;
3196         int error;
3197
3198         ret = rtllib_init();
3199         if (ret) {
3200                 printk(KERN_ERR "rtllib_init() failed %d\n", ret);
3201                 return ret;
3202         }
3203         ret = rtllib_crypto_init();
3204         if (ret) {
3205                 printk(KERN_ERR "rtllib_crypto_init() failed %d\n", ret);
3206                 return ret;
3207         }
3208         ret = rtllib_crypto_tkip_init();
3209         if (ret) {
3210                 printk(KERN_ERR "rtllib_crypto_tkip_init() failed %d\n", ret);
3211                 return ret;
3212         }
3213         ret = rtllib_crypto_ccmp_init();
3214         if (ret) {
3215                 printk(KERN_ERR "rtllib_crypto_ccmp_init() failed %d\n", ret);
3216                 return ret;
3217         }
3218         ret = rtllib_crypto_wep_init();
3219         if (ret) {
3220                 printk(KERN_ERR "rtllib_crypto_wep_init() failed %d\n", ret);
3221                 return ret;
3222         }
3223         printk(KERN_INFO "\nLinux kernel driver for RTL8192E WLAN cards\n");
3224         printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan Driver\n");
3225
3226         error = rtl_create_debugfs_root();
3227         if (error) {
3228                 RT_TRACE(COMP_DBG, "Create debugfs root fail: %d\n", error);
3229                 goto err_out;
3230         }
3231
3232         rtl8192_proc_module_init();
3233         if (0 != pci_register_driver(&rtl8192_pci_driver)) {
3234                 DMESG("No device found");
3235                 /*pci_unregister_driver (&rtl8192_pci_driver);*/
3236                 return -ENODEV;
3237         }
3238         return 0;
3239 err_out:
3240         return error;
3241
3242 }
3243
3244 static void __exit rtl8192_pci_module_exit(void)
3245 {
3246         pci_unregister_driver(&rtl8192_pci_driver);
3247
3248         RT_TRACE(COMP_DOWN, "Exiting");
3249         rtl8192_proc_module_remove();
3250         rtl_remove_debugfs_root();
3251         rtllib_crypto_tkip_exit();
3252         rtllib_crypto_ccmp_exit();
3253         rtllib_crypto_wep_exit();
3254         rtllib_crypto_deinit();
3255         rtllib_exit();
3256 }
3257
3258 void check_rfctrl_gpio_timer(unsigned long data)
3259 {
3260         struct r8192_priv *priv = rtllib_priv((struct net_device *)data);
3261
3262         priv->polling_timer_on = 1;
3263
3264         queue_delayed_work_rsl(priv->priv_wq, &priv->gpio_change_rf_wq, 0);
3265
3266         mod_timer(&priv->gpio_polling_timer, jiffies +
3267                   MSECS(RTLLIB_WATCH_DOG_TIME));
3268 }
3269
3270 /***************************************************************************
3271         ------------------- module init / exit stubs ----------------
3272 ****************************************************************************/
3273 module_init(rtl8192_pci_module_init);
3274 module_exit(rtl8192_pci_module_exit);
3275
3276 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
3277 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
3278 MODULE_VERSION(DRV_VERSION);
3279 MODULE_LICENSE("GPL");
3280
3281 module_param(ifname, charp, S_IRUGO|S_IWUSR);
3282 module_param(hwwep, int, S_IRUGO|S_IWUSR);
3283 module_param(channels, int, S_IRUGO|S_IWUSR);
3284
3285 MODULE_PARM_DESC(ifname, " Net interface name, wlan%d=default");
3286 MODULE_PARM_DESC(hwwep, " Try to use hardware WEP support(default use hw. set 0 to use software security)");
3287 MODULE_PARM_DESC(channels, " Channel bitmask for specific locales. NYI");