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