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