drivers/staging/rtl8192e/rtl8192e/rtl_core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   4  *
   5  * Based on the r8180 driver, which is:
   6  * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
   7  *
   8  * Contact Information: wlanfae <wlanfae@realtek.com>
   9  */
  10 #include <linux/uaccess.h>
  11 #include <linux/pci.h>
  12 #include <linux/vmalloc.h>
  13 #include <linux/ieee80211.h>
  14 #include "rtl_core.h"
  15 #include "r8192E_phy.h"
  16 #include "r8192E_phyreg.h"
  17 #include "r8190P_rtl8256.h"
  18 #include "r8192E_cmdpkt.h"
  19
  20 #include "rtl_wx.h"
  21 #include "rtl_dm.h"
  22
  23 #include "rtl_pm.h"
  24
  25 int hwwep = 1;
  26 static char *ifname = "wlan%d";
  27
  28 static struct pci_device_id rtl8192_pci_id_tbl[] = {
  29         {PCI_DEVICE(0x10ec, 0x8192)},
  30         {PCI_DEVICE(0x07aa, 0x0044)},
  31         {PCI_DEVICE(0x07aa, 0x0047)},
  32         {}
  33 };
  34
  35 MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
  36
  37 static int _rtl92e_pci_probe(struct pci_dev *pdev,
  38                              const struct pci_device_id *id);
  39 static void _rtl92e_pci_disconnect(struct pci_dev *pdev);
  40 static irqreturn_t _rtl92e_irq(int irq, void *netdev);
  41
  42 static SIMPLE_DEV_PM_OPS(rtl92e_pm_ops, rtl92e_suspend, rtl92e_resume);
  43
  44 static struct pci_driver rtl8192_pci_driver = {
  45         .name = DRV_NAME,       /* Driver name   */
  46         .id_table = rtl8192_pci_id_tbl, /* PCI_ID table  */
  47         .probe  = _rtl92e_pci_probe,    /* probe fn      */
  48         .remove  = _rtl92e_pci_disconnect,      /* remove fn */
  49         .driver.pm = &rtl92e_pm_ops,
  50 };
  51
  52 static short _rtl92e_is_tx_queue_empty(struct net_device *dev);
  53 static void _rtl92e_watchdog_wq_cb(void *data);
  54 static void _rtl92e_watchdog_timer_cb(struct timer_list *t);
  55 static void _rtl92e_hard_data_xmit(struct sk_buff *skb, struct net_device *dev,
  56                                    int rate);
  57 static int _rtl92e_hard_start_xmit(struct sk_buff *skb, struct net_device *dev);
  58 static void _rtl92e_tx_cmd(struct net_device *dev, struct sk_buff *skb);
  59 static short _rtl92e_tx(struct net_device *dev, struct sk_buff *skb);
  60 static short _rtl92e_pci_initdescring(struct net_device *dev);
  61 static void _rtl92e_irq_tx_tasklet(struct tasklet_struct *t);
  62 static void _rtl92e_irq_rx_tasklet(struct tasklet_struct *t);
  63 static void _rtl92e_cancel_deferred_work(struct r8192_priv *priv);
  64 static int _rtl92e_up(struct net_device *dev);
  65 static int _rtl92e_try_up(struct net_device *dev);
  66 static int _rtl92e_down(struct net_device *dev, bool shutdownrf);
  67 static void _rtl92e_restart(void *data);
  68
  69 /****************************************************************************
  70  *  -----------------------------IO STUFF-------------------------
  71  ****************************************************************************/
  72
  73 u8 rtl92e_readb(struct net_device *dev, int x)
  74 {
  75         return 0xff & readb((u8 __iomem *)dev->mem_start + x);
  76 }
  77
  78 u32 rtl92e_readl(struct net_device *dev, int x)
  79 {
  80         return readl((u8 __iomem *)dev->mem_start + x);
  81 }
  82
  83 u16 rtl92e_readw(struct net_device *dev, int x)
  84 {
  85         return readw((u8 __iomem *)dev->mem_start + x);
  86 }
  87
  88 void rtl92e_writeb(struct net_device *dev, int x, u8 y)
  89 {
  90         writeb(y, (u8 __iomem *)dev->mem_start + x);
  91
  92         udelay(20);
  93 }
  94
  95 void rtl92e_writel(struct net_device *dev, int x, u32 y)
  96 {
  97         writel(y, (u8 __iomem *)dev->mem_start + x);
  98
  99         udelay(20);
 100 }
 101
 102 void rtl92e_writew(struct net_device *dev, int x, u16 y)
 103 {
 104         writew(y, (u8 __iomem *)dev->mem_start + x);
 105
 106         udelay(20);
 107 }
 108
 109 /****************************************************************************
 110  *  -----------------------------GENERAL FUNCTION-------------------------
 111  ****************************************************************************/
 112 bool rtl92e_set_rf_state(struct net_device *dev,
 113                          enum rt_rf_power_state state_to_set,
 114                          RT_RF_CHANGE_SOURCE change_source)
 115 {
 116         struct r8192_priv *priv = rtllib_priv(dev);
 117         struct rtllib_device *ieee = priv->rtllib;
 118         bool action_allowed = false;
 119         bool connect_by_ssid = false;
 120         enum rt_rf_power_state rt_state;
 121         u16 rf_wait_counter = 0;
 122         unsigned long flag;
 123
 124         while (true) {
 125                 spin_lock_irqsave(&priv->rf_ps_lock, flag);
 126                 if (priv->rf_change_in_progress) {
 127                         spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
 128
 129                         while (priv->rf_change_in_progress) {
 130                                 rf_wait_counter++;
 131                                 mdelay(1);
 132
 133                                 if (rf_wait_counter > 100) {
 134                                         netdev_warn(dev,
 135                                                     "%s(): Timeout waiting for RF change.\n",
 136                                                     __func__);
 137                                         return false;
 138                                 }
 139                         }
 140                 } else {
 141                         priv->rf_change_in_progress = true;
 142                         spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
 143                         break;
 144                 }
 145         }
 146
 147         rt_state = priv->rtllib->rf_power_state;
 148
 149         switch (state_to_set) {
 150         case rf_on:
 151                 priv->rtllib->rf_off_reason &= (~change_source);
 152
 153                 if ((change_source == RF_CHANGE_BY_HW) && priv->hw_radio_off)
 154                         priv->hw_radio_off = false;
 155
 156                 if (!priv->rtllib->rf_off_reason) {
 157                         priv->rtllib->rf_off_reason = 0;
 158                         action_allowed = true;
 159
 160                         if (rt_state == rf_off &&
 161                             change_source >= RF_CHANGE_BY_HW)
 162                                 connect_by_ssid = true;
 163                 }
 164                 break;
 165
 166         case rf_off:
 167
 168                 if (priv->rtllib->iw_mode == IW_MODE_INFRA) {
 169                         if ((priv->rtllib->rf_off_reason > RF_CHANGE_BY_IPS) ||
 170                             (change_source > RF_CHANGE_BY_IPS)) {
 171                                 if (ieee->link_state == MAC80211_LINKED)
 172                                         priv->blinked_ingpio = true;
 173                                 else
 174                                         priv->blinked_ingpio = false;
 175                                 rtllib_MgntDisconnect(priv->rtllib,
 176                                                       WLAN_REASON_DISASSOC_STA_HAS_LEFT);
 177                         }
 178                 }
 179                 if ((change_source == RF_CHANGE_BY_HW) && !priv->hw_radio_off)
 180                         priv->hw_radio_off = true;
 181                 priv->rtllib->rf_off_reason |= change_source;
 182                 action_allowed = true;
 183                 break;
 184
 185         case rf_sleep:
 186                 priv->rtllib->rf_off_reason |= change_source;
 187                 action_allowed = true;
 188                 break;
 189
 190         default:
 191                 break;
 192         }
 193
 194         if (action_allowed) {
 195                 rtl92e_set_rf_power_state(dev, state_to_set);
 196                 if (state_to_set == rf_on) {
 197                         if (connect_by_ssid && priv->blinked_ingpio) {
 198                                 schedule_delayed_work(
 199                                          &ieee->associate_procedure_wq, 0);
 200                                 priv->blinked_ingpio = false;
 201                         }
 202                 }
 203         }
 204
 205         spin_lock_irqsave(&priv->rf_ps_lock, flag);
 206         priv->rf_change_in_progress = false;
 207         spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
 208         return action_allowed;
 209 }
 210
 211 static short _rtl92e_check_nic_enough_desc(struct net_device *dev, int prio)
 212 {
 213         struct r8192_priv *priv = rtllib_priv(dev);
 214         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
 215
 216         if (ring->entries - skb_queue_len(&ring->queue) >= 2)
 217                 return 1;
 218         return 0;
 219 }
 220
 221 static void _rtl92e_tx_timeout(struct net_device *dev, unsigned int txqueue)
 222 {
 223         struct r8192_priv *priv = rtllib_priv(dev);
 224
 225         schedule_work(&priv->reset_wq);
 226         netdev_info(dev, "TXTIMEOUT");
 227 }
 228
 229 static void _rtl92e_update_cap(struct net_device *dev, u16 cap)
 230 {
 231         struct r8192_priv *priv = rtllib_priv(dev);
 232         struct rtllib_network *net = &priv->rtllib->current_network;
 233         bool            ShortPreamble;
 234
 235         if (cap & WLAN_CAPABILITY_SHORT_PREAMBLE) {
 236                 if (priv->dot11_current_preamble_mode != PREAMBLE_SHORT) {
 237                         ShortPreamble = true;
 238                         priv->dot11_current_preamble_mode = PREAMBLE_SHORT;
 239                         priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACK_PREAMBLE,
 240                                         (unsigned char *)&ShortPreamble);
 241                 }
 242         } else {
 243                 if (priv->dot11_current_preamble_mode != PREAMBLE_LONG) {
 244                         ShortPreamble = false;
 245                         priv->dot11_current_preamble_mode = PREAMBLE_LONG;
 246                         priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACK_PREAMBLE,
 247                                               (unsigned char *)&ShortPreamble);
 248                 }
 249         }
 250
 251         if (net->mode & (WIRELESS_MODE_G | WIRELESS_MODE_N_24G)) {
 252                 u8      slot_time_val;
 253                 u8      cur_slot_time = priv->slot_time;
 254
 255                 if ((cap & WLAN_CAPABILITY_SHORT_SLOT_TIME) &&
 256                    (!priv->rtllib->ht_info->current_rt2rt_long_slot_time)) {
 257                         if (cur_slot_time != SHORT_SLOT_TIME) {
 258                                 slot_time_val = SHORT_SLOT_TIME;
 259                                 priv->rtllib->SetHwRegHandler(dev,
 260                                          HW_VAR_SLOT_TIME, &slot_time_val);
 261                         }
 262                 } else {
 263                         if (cur_slot_time != NON_SHORT_SLOT_TIME) {
 264                                 slot_time_val = NON_SHORT_SLOT_TIME;
 265                                 priv->rtllib->SetHwRegHandler(dev,
 266                                          HW_VAR_SLOT_TIME, &slot_time_val);
 267                         }
 268                 }
 269         }
 270 }
 271
 272 static const struct rtllib_qos_parameters def_qos_parameters = {
 273         {cpu_to_le16(3), cpu_to_le16(3), cpu_to_le16(3), cpu_to_le16(3)},
 274         {cpu_to_le16(7), cpu_to_le16(7), cpu_to_le16(7), cpu_to_le16(7)},
 275         {2, 2, 2, 2},
 276         {0, 0, 0, 0},
 277         {0, 0, 0, 0}
 278 };
 279
 280 static void _rtl92e_update_beacon(void *data)
 281 {
 282         struct r8192_priv *priv = container_of(data, struct r8192_priv, update_beacon_wq.work);
 283         struct net_device *dev = priv->rtllib->dev;
 284         struct rtllib_device *ieee = priv->rtllib;
 285         struct rtllib_network *net = &ieee->current_network;
 286
 287         if (ieee->ht_info->current_ht_support)
 288                 HT_update_self_and_peer_setting(ieee, net);
 289         ieee->ht_info->current_rt2rt_long_slot_time = net->bssht.bd_rt2rt_long_slot_time;
 290         _rtl92e_update_cap(dev, net->capability);
 291 }
 292
 293 static void _rtl92e_qos_activate(void *data)
 294 {
 295         struct r8192_priv *priv = container_of(data, struct r8192_priv, qos_activate);
 296         struct net_device *dev = priv->rtllib->dev;
 297         int i;
 298
 299         mutex_lock(&priv->mutex);
 300         if (priv->rtllib->link_state != MAC80211_LINKED)
 301                 goto success;
 302
 303         for (i = 0; i <  QOS_QUEUE_NUM; i++)
 304                 priv->rtllib->SetHwRegHandler(dev, HW_VAR_AC_PARAM, (u8 *)(&i));
 305
 306 success:
 307         mutex_unlock(&priv->mutex);
 308 }
 309
 310 static int _rtl92e_qos_handle_probe_response(struct r8192_priv *priv,
 311                                              int active_network,
 312                                              struct rtllib_network *network)
 313 {
 314         int ret = 0;
 315         u32 size = sizeof(struct rtllib_qos_parameters);
 316
 317         if (priv->rtllib->link_state != MAC80211_LINKED)
 318                 return ret;
 319
 320         if (priv->rtllib->iw_mode != IW_MODE_INFRA)
 321                 return ret;
 322
 323         if (network->flags & NETWORK_HAS_QOS_MASK) {
 324                 if (active_network &&
 325                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
 326                         network->qos_data.active = network->qos_data.supported;
 327
 328                 if ((network->qos_data.active == 1) && (active_network == 1) &&
 329                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
 330                                 (network->qos_data.old_param_count !=
 331                                 network->qos_data.param_count)) {
 332                         network->qos_data.old_param_count =
 333                                 network->qos_data.param_count;
 334                         priv->rtllib->wmm_acm = network->qos_data.wmm_acm;
 335                         schedule_work(&priv->qos_activate);
 336                 }
 337         } else {
 338                 memcpy(&priv->rtllib->current_network.qos_data.parameters,
 339                        &def_qos_parameters, size);
 340
 341                 if ((network->qos_data.active == 1) && (active_network == 1))
 342                         schedule_work(&priv->qos_activate);
 343
 344                 network->qos_data.active = 0;
 345                 network->qos_data.supported = 0;
 346         }
 347
 348         return 0;
 349 }
 350
 351 static int _rtl92e_handle_beacon(struct net_device *dev,
 352                                  struct rtllib_beacon *beacon,
 353                                  struct rtllib_network *network)
 354 {
 355         struct r8192_priv *priv = rtllib_priv(dev);
 356
 357         _rtl92e_qos_handle_probe_response(priv, 1, network);
 358
 359         schedule_delayed_work(&priv->update_beacon_wq, 0);
 360         return 0;
 361 }
 362
 363 static int _rtl92e_qos_assoc_resp(struct r8192_priv *priv,
 364                                   struct rtllib_network *network)
 365 {
 366         unsigned long flags;
 367         u32 size = sizeof(struct rtllib_qos_parameters);
 368         int set_qos_param = 0;
 369
 370         if (!priv || !network)
 371                 return 0;
 372
 373         if (priv->rtllib->link_state != MAC80211_LINKED)
 374                 return 0;
 375
 376         if (priv->rtllib->iw_mode != IW_MODE_INFRA)
 377                 return 0;
 378
 379         spin_lock_irqsave(&priv->rtllib->lock, flags);
 380         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
 381                 memcpy(&priv->rtllib->current_network.qos_data.parameters,
 382                        &network->qos_data.parameters,
 383                        sizeof(struct rtllib_qos_parameters));
 384                 priv->rtllib->current_network.qos_data.active = 1;
 385                 priv->rtllib->wmm_acm = network->qos_data.wmm_acm;
 386                 set_qos_param = 1;
 387                 priv->rtllib->current_network.qos_data.old_param_count =
 388                         priv->rtllib->current_network.qos_data.param_count;
 389                 priv->rtllib->current_network.qos_data.param_count =
 390                         network->qos_data.param_count;
 391         } else {
 392                 memcpy(&priv->rtllib->current_network.qos_data.parameters,
 393                 &def_qos_parameters, size);
 394                 priv->rtllib->current_network.qos_data.active = 0;
 395                 priv->rtllib->current_network.qos_data.supported = 0;
 396                 set_qos_param = 1;
 397         }
 398
 399         spin_unlock_irqrestore(&priv->rtllib->lock, flags);
 400
 401         if (set_qos_param == 1) {
 402                 rtl92e_dm_init_edca_turbo(priv->rtllib->dev);
 403                 schedule_work(&priv->qos_activate);
 404         }
 405         return 0;
 406 }
 407
 408 static int _rtl92e_handle_assoc_response(struct net_device *dev,
 409                                  struct rtllib_assoc_response_frame *resp,
 410                                  struct rtllib_network *network)
 411 {
 412         struct r8192_priv *priv = rtllib_priv(dev);
 413
 414         _rtl92e_qos_assoc_resp(priv, network);
 415         return 0;
 416 }
 417
 418 void rtl92e_config_rate(struct net_device *dev, u16 *rate_config)
 419 {
 420         struct r8192_priv *priv = rtllib_priv(dev);
 421         struct rtllib_network *net;
 422         u8 i = 0, basic_rate = 0;
 423
 424         net = &priv->rtllib->current_network;
 425
 426         for (i = 0; i < net->rates_len; i++) {
 427                 basic_rate = net->rates[i] & 0x7f;
 428                 switch (basic_rate) {
 429                 case MGN_1M:
 430                         *rate_config |= RRSR_1M;
 431                         break;
 432                 case MGN_2M:
 433                         *rate_config |= RRSR_2M;
 434                         break;
 435                 case MGN_5_5M:
 436                         *rate_config |= RRSR_5_5M;
 437                         break;
 438                 case MGN_11M:
 439                         *rate_config |= RRSR_11M;
 440                         break;
 441                 case MGN_6M:
 442                         *rate_config |= RRSR_6M;
 443                         break;
 444                 case MGN_9M:
 445                         *rate_config |= RRSR_9M;
 446                         break;
 447                 case MGN_12M:
 448                         *rate_config |= RRSR_12M;
 449                         break;
 450                 case MGN_18M:
 451                         *rate_config |= RRSR_18M;
 452                         break;
 453                 case MGN_24M:
 454                         *rate_config |= RRSR_24M;
 455                         break;
 456                 case MGN_36M:
 457                         *rate_config |= RRSR_36M;
 458                         break;
 459                 case MGN_48M:
 460                         *rate_config |= RRSR_48M;
 461                         break;
 462                 case MGN_54M:
 463                         *rate_config |= RRSR_54M;
 464                         break;
 465                 }
 466         }
 467
 468         for (i = 0; i < net->rates_ex_len; i++) {
 469                 basic_rate = net->rates_ex[i] & 0x7f;
 470                 switch (basic_rate) {
 471                 case MGN_1M:
 472                         *rate_config |= RRSR_1M;
 473                         break;
 474                 case MGN_2M:
 475                         *rate_config |= RRSR_2M;
 476                         break;
 477                 case MGN_5_5M:
 478                         *rate_config |= RRSR_5_5M;
 479                         break;
 480                 case MGN_11M:
 481                         *rate_config |= RRSR_11M;
 482                         break;
 483                 case MGN_6M:
 484                         *rate_config |= RRSR_6M;
 485                         break;
 486                 case MGN_9M:
 487                         *rate_config |= RRSR_9M;
 488                         break;
 489                 case MGN_12M:
 490                         *rate_config |= RRSR_12M;
 491                         break;
 492                 case MGN_18M:
 493                         *rate_config |= RRSR_18M;
 494                         break;
 495                 case MGN_24M:
 496                         *rate_config |= RRSR_24M;
 497                         break;
 498                 case MGN_36M:
 499                         *rate_config |= RRSR_36M;
 500                         break;
 501                 case MGN_48M:
 502                         *rate_config |= RRSR_48M;
 503                         break;
 504                 case MGN_54M:
 505                         *rate_config |= RRSR_54M;
 506                         break;
 507                 }
 508         }
 509 }
 510
 511 static void _rtl92e_refresh_support_rate(struct r8192_priv *priv)
 512 {
 513         struct rtllib_device *ieee = priv->rtllib;
 514
 515         if (ieee->mode == WIRELESS_MODE_N_24G) {
 516                 memcpy(ieee->reg_dot11ht_oper_rate_set,
 517                        ieee->reg_ht_supp_rate_set, 16);
 518                 memcpy(ieee->reg_dot11tx_ht_oper_rate_set,
 519                        ieee->reg_ht_supp_rate_set, 16);
 520
 521         } else {
 522                 memset(ieee->reg_dot11ht_oper_rate_set, 0, 16);
 523         }
 524 }
 525
 526 void rtl92e_set_wireless_mode(struct net_device *dev, u8 wireless_mode)
 527 {
 528         struct r8192_priv *priv = rtllib_priv(dev);
 529         u8 support_mode = (WIRELESS_MODE_N_24G | WIRELESS_MODE_G | WIRELESS_MODE_B);
 530
 531         if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode & support_mode) == 0))
 532                 wireless_mode = WIRELESS_MODE_N_24G;
 533
 534         if ((wireless_mode & (WIRELESS_MODE_B | WIRELESS_MODE_G)) ==
 535             (WIRELESS_MODE_G | WIRELESS_MODE_B))
 536                 wireless_mode = WIRELESS_MODE_G;
 537
 538         priv->rtllib->mode = wireless_mode;
 539
 540         if (wireless_mode == WIRELESS_MODE_N_24G)
 541                 priv->rtllib->ht_info->enable_ht = 1;
 542         else
 543                 priv->rtllib->ht_info->enable_ht = 0;
 544
 545         _rtl92e_refresh_support_rate(priv);
 546 }
 547
 548 static int _rtl92e_sta_up(struct net_device *dev)
 549 {
 550         struct r8192_priv *priv = rtllib_priv(dev);
 551         struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *)
 552                                         (&priv->rtllib->pwr_save_ctrl);
 553         bool init_status;
 554
 555         priv->up = 1;
 556         priv->rtllib->ieee_up = 1;
 557
 558         priv->up_first_time = 0;
 559         init_status = rtl92e_start_adapter(dev);
 560         if (!init_status) {
 561                 netdev_err(dev, "%s(): Initialization failed!\n", __func__);
 562                 return -1;
 563         }
 564
 565         RT_CLEAR_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC);
 566
 567         if (priv->polling_timer_on == 0)
 568                 rtl92e_check_rfctrl_gpio_timer(&priv->gpio_polling_timer);
 569
 570         if (priv->rtllib->link_state != MAC80211_LINKED)
 571                 rtllib_softmac_start_protocol(priv->rtllib);
 572         rtllib_reset_queue(priv->rtllib);
 573         _rtl92e_watchdog_timer_cb(&priv->watch_dog_timer);
 574
 575         if (!netif_queue_stopped(dev))
 576                 netif_start_queue(dev);
 577         else
 578                 netif_wake_queue(dev);
 579
 580         priv->bfirst_after_down = false;
 581         return 0;
 582 }
 583
 584 static int _rtl92e_sta_down(struct net_device *dev, bool shutdownrf)
 585 {
 586         struct r8192_priv *priv = rtllib_priv(dev);
 587         unsigned long flags = 0;
 588         u8 rf_in_progress_timeout = 0;
 589
 590         if (priv->up == 0)
 591                 return -1;
 592
 593         priv->rtllib->rtllib_ips_leave(dev);
 594
 595         if (priv->rtllib->link_state == MAC80211_LINKED)
 596                 rtl92e_leisure_ps_leave(dev);
 597
 598         priv->up = 0;
 599         priv->rtllib->ieee_up = 0;
 600         priv->bfirst_after_down = true;
 601         if (!netif_queue_stopped(dev))
 602                 netif_stop_queue(dev);
 603
 604         priv->rtllib->wpa_ie_len = 0;
 605         kfree(priv->rtllib->wpa_ie);
 606         priv->rtllib->wpa_ie = NULL;
 607         rtl92e_cam_reset(dev);
 608         memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
 609         rtl92e_irq_disable(dev);
 610
 611         del_timer_sync(&priv->watch_dog_timer);
 612         _rtl92e_cancel_deferred_work(priv);
 613         cancel_delayed_work(&priv->rtllib->hw_wakeup_wq);
 614
 615         rtllib_softmac_stop_protocol(priv->rtllib);
 616         spin_lock_irqsave(&priv->rf_ps_lock, flags);
 617         while (priv->rf_change_in_progress) {
 618                 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
 619                 if (rf_in_progress_timeout > 100) {
 620                         spin_lock_irqsave(&priv->rf_ps_lock, flags);
 621                         break;
 622                 }
 623                 mdelay(1);
 624                 rf_in_progress_timeout++;
 625                 spin_lock_irqsave(&priv->rf_ps_lock, flags);
 626         }
 627         priv->rf_change_in_progress = true;
 628         spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
 629         rtl92e_stop_adapter(dev, false);
 630         spin_lock_irqsave(&priv->rf_ps_lock, flags);
 631         priv->rf_change_in_progress = false;
 632         spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
 633         udelay(100);
 634         memset(&priv->rtllib->current_network, 0,
 635                offsetof(struct rtllib_network, list));
 636
 637         return 0;
 638 }
 639
 640 static void _rtl92e_init_priv_handler(struct net_device *dev)
 641 {
 642         struct r8192_priv *priv = rtllib_priv(dev);
 643
 644         priv->rtllib->softmac_hard_start_xmit   = _rtl92e_hard_start_xmit;
 645         priv->rtllib->set_chan                  = rtl92e_set_channel;
 646         priv->rtllib->link_change               = rtl92e_link_change;
 647         priv->rtllib->softmac_data_hard_start_xmit = _rtl92e_hard_data_xmit;
 648         priv->rtllib->check_nic_enough_desc     = _rtl92e_check_nic_enough_desc;
 649         priv->rtllib->handle_assoc_response     = _rtl92e_handle_assoc_response;
 650         priv->rtllib->handle_beacon             = _rtl92e_handle_beacon;
 651         priv->rtllib->set_wireless_mode         = rtl92e_set_wireless_mode;
 652         priv->rtllib->leisure_ps_leave          = rtl92e_leisure_ps_leave;
 653         priv->rtllib->set_bw_mode_handler       = rtl92e_set_bw_mode;
 654
 655         priv->rtllib->sta_wake_up = rtl92e_hw_wakeup;
 656         priv->rtllib->enter_sleep_state = rtl92e_enter_sleep;
 657         priv->rtllib->ps_is_queue_empty = _rtl92e_is_tx_queue_empty;
 658
 659         priv->rtllib->GetNmodeSupportBySecCfg = rtl92e_get_nmode_support_by_sec;
 660         priv->rtllib->GetHalfNmodeSupportByAPsHandler =
 661                                                 rtl92e_is_halfn_supported_by_ap;
 662
 663         priv->rtllib->SetHwRegHandler = rtl92e_set_reg;
 664         priv->rtllib->AllowAllDestAddrHandler = rtl92e_set_monitor_mode;
 665         priv->rtllib->init_gain_handler = rtl92e_init_gain;
 666         priv->rtllib->rtllib_ips_leave_wq = rtl92e_rtllib_ips_leave_wq;
 667         priv->rtllib->rtllib_ips_leave = rtl92e_rtllib_ips_leave;
 668         priv->rtllib->ScanOperationBackupHandler = rtl92e_scan_op_backup;
 669 }
 670
 671 static void _rtl92e_init_priv_variable(struct net_device *dev)
 672 {
 673         struct r8192_priv *priv = rtllib_priv(dev);
 674         u8 i;
 675
 676         priv->dot11_current_preamble_mode = PREAMBLE_AUTO;
 677         priv->rtllib->status = 0;
 678         priv->polling_timer_on = 0;
 679         priv->up_first_time = 1;
 680         priv->blinked_ingpio = false;
 681         priv->being_init_adapter = false;
 682         priv->txringcount = 64;
 683         priv->rxbuffersize = 9100;
 684         priv->rxringcount = MAX_RX_COUNT;
 685         priv->irq_enabled = 0;
 686         priv->chan = 1;
 687         priv->rtllib->mode = WIRELESS_MODE_AUTO;
 688         priv->rtllib->iw_mode = IW_MODE_INFRA;
 689         priv->rtllib->ieee_up = 0;
 690         priv->retry_rts = DEFAULT_RETRY_RTS;
 691         priv->retry_data = DEFAULT_RETRY_DATA;
 692         priv->rtllib->rts = DEFAULT_RTS_THRESHOLD;
 693         priv->rtllib->rate = 110;
 694         priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
 695         priv->bcck_in_ch14 = false;
 696         priv->cck_present_attn = 0;
 697         priv->rfa_txpowertrackingindex = 0;
 698         priv->cck_pwr_enl = 6;
 699         memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
 700         priv->rx_ctr = 0;
 701         priv->rtllib->wx_set_enc = 0;
 702         priv->hw_radio_off = false;
 703         priv->rtllib->rf_off_reason = 0;
 704         priv->rf_change_in_progress = false;
 705         priv->hw_rf_off_action = 0;
 706         priv->set_rf_pwr_state_in_progress = false;
 707         priv->rtllib->pwr_save_ctrl.bLeisurePs = true;
 708         priv->rtllib->LPSDelayCnt = 0;
 709         priv->rtllib->sta_sleep = LPS_IS_WAKE;
 710         priv->rtllib->rf_power_state = rf_on;
 711
 712         priv->rtllib->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
 713         priv->rtllib->iw_mode = IW_MODE_INFRA;
 714         priv->rtllib->be_scan_inprogress = false;
 715
 716         priv->rtllib->fts = DEFAULT_FRAG_THRESHOLD;
 717
 718         priv->fw_info = vzalloc(sizeof(struct rt_firmware));
 719         if (!priv->fw_info)
 720                 netdev_err(dev,
 721                            "rtl8192e: Unable to allocate space for firmware\n");
 722
 723         skb_queue_head_init(&priv->skb_queue);
 724
 725         for (i = 0; i < MAX_QUEUE_SIZE; i++)
 726                 skb_queue_head_init(&priv->rtllib->skb_waitq[i]);
 727 }
 728
 729 static void _rtl92e_init_priv_lock(struct r8192_priv *priv)
 730 {
 731         spin_lock_init(&priv->tx_lock);
 732         spin_lock_init(&priv->irq_th_lock);
 733         spin_lock_init(&priv->rf_ps_lock);
 734         spin_lock_init(&priv->ps_lock);
 735         mutex_init(&priv->wx_mutex);
 736         mutex_init(&priv->rf_mutex);
 737         mutex_init(&priv->mutex);
 738 }
 739
 740 static void _rtl92e_init_priv_task(struct net_device *dev)
 741 {
 742         struct r8192_priv *priv = rtllib_priv(dev);
 743
 744         INIT_WORK(&priv->reset_wq, (void *)_rtl92e_restart);
 745         INIT_WORK(&priv->rtllib->ips_leave_wq, (void *)rtl92e_ips_leave_wq);
 746         INIT_DELAYED_WORK(&priv->watch_dog_wq, (void *)_rtl92e_watchdog_wq_cb);
 747         INIT_DELAYED_WORK(&priv->txpower_tracking_wq, (void *)rtl92e_dm_txpower_tracking_wq);
 748         INIT_DELAYED_WORK(&priv->rfpath_check_wq, (void *)rtl92e_dm_rf_pathcheck_wq);
 749         INIT_DELAYED_WORK(&priv->update_beacon_wq, (void *)_rtl92e_update_beacon);
 750         INIT_WORK(&priv->qos_activate, (void *)_rtl92e_qos_activate);
 751         INIT_DELAYED_WORK(&priv->rtllib->hw_wakeup_wq, (void *)rtl92e_hw_wakeup_wq);
 752         INIT_DELAYED_WORK(&priv->rtllib->hw_sleep_wq, (void *)rtl92e_hw_sleep_wq);
 753         tasklet_setup(&priv->irq_rx_tasklet, _rtl92e_irq_rx_tasklet);
 754         tasklet_setup(&priv->irq_tx_tasklet, _rtl92e_irq_tx_tasklet);
 755 }
 756
 757 static short _rtl92e_get_channel_map(struct net_device *dev)
 758 {
 759         int i;
 760
 761         struct r8192_priv *priv = rtllib_priv(dev);
 762
 763         for (i = 1; i <= 11; i++)
 764                 (priv->rtllib->active_channel_map)[i] = 1;
 765         (priv->rtllib->active_channel_map)[12] = 2;
 766         (priv->rtllib->active_channel_map)[13] = 2;
 767
 768         return 0;
 769 }
 770
 771 static short _rtl92e_init(struct net_device *dev)
 772 {
 773         struct r8192_priv *priv = rtllib_priv(dev);
 774
 775         memset(&priv->stats, 0, sizeof(struct rt_stats));
 776
 777         _rtl92e_init_priv_handler(dev);
 778         _rtl92e_init_priv_variable(dev);
 779         _rtl92e_init_priv_lock(priv);
 780         _rtl92e_init_priv_task(dev);
 781         rtl92e_get_eeprom_size(dev);
 782         rtl92e_init_variables(dev);
 783         _rtl92e_get_channel_map(dev);
 784
 785         rtl92e_dm_init(dev);
 786
 787         timer_setup(&priv->watch_dog_timer, _rtl92e_watchdog_timer_cb, 0);
 788
 789         timer_setup(&priv->gpio_polling_timer, rtl92e_check_rfctrl_gpio_timer,
 790                     0);
 791
 792         rtl92e_irq_disable(dev);
 793         if (request_irq(dev->irq, _rtl92e_irq, IRQF_SHARED, dev->name, dev)) {
 794                 netdev_err(dev, "Error allocating IRQ %d", dev->irq);
 795                 return -1;
 796         }
 797
 798         priv->irq = dev->irq;
 799
 800         if (_rtl92e_pci_initdescring(dev) != 0) {
 801                 netdev_err(dev, "Endopoints initialization failed");
 802                 free_irq(dev->irq, dev);
 803                 return -1;
 804         }
 805
 806         return 0;
 807 }
 808
 809 /***************************************************************************
 810  * -------------------------------WATCHDOG STUFF---------------------------
 811  **************************************************************************/
 812 static short _rtl92e_is_tx_queue_empty(struct net_device *dev)
 813 {
 814         int i = 0;
 815         struct r8192_priv *priv = rtllib_priv(dev);
 816
 817         for (i = 0; i <= MGNT_QUEUE; i++) {
 818                 if ((i == TXCMD_QUEUE) || (i == HCCA_QUEUE))
 819                         continue;
 820                 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0) {
 821                         netdev_info(dev, "===>tx queue is not empty:%d, %d\n",
 822                                i, skb_queue_len(&(&priv->tx_ring[i])->queue));
 823                         return 0;
 824                 }
 825         }
 826         return 1;
 827 }
 828
 829 static enum reset_type _rtl92e_tx_check_stuck(struct net_device *dev)
 830 {
 831         struct r8192_priv *priv = rtllib_priv(dev);
 832         u8      QueueID;
 833         bool    bCheckFwTxCnt = false;
 834         struct rtl8192_tx_ring  *ring = NULL;
 835         struct sk_buff *skb = NULL;
 836         struct cb_desc *tcb_desc = NULL;
 837         unsigned long flags = 0;
 838
 839         switch (priv->rtllib->ps) {
 840         case RTLLIB_PS_DISABLED:
 841                 break;
 842         case (RTLLIB_PS_MBCAST | RTLLIB_PS_UNICAST):
 843                 break;
 844         default:
 845                 break;
 846         }
 847         spin_lock_irqsave(&priv->irq_th_lock, flags);
 848         for (QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++) {
 849                 if (QueueID == TXCMD_QUEUE)
 850                         continue;
 851
 852                 if (QueueID == BEACON_QUEUE)
 853                         continue;
 854
 855                 ring = &priv->tx_ring[QueueID];
 856
 857                 if (skb_queue_len(&ring->queue) == 0) {
 858                         continue;
 859                 } else {
 860                         skb = __skb_peek(&ring->queue);
 861                         tcb_desc = (struct cb_desc *)(skb->cb +
 862                                     MAX_DEV_ADDR_SIZE);
 863                         tcb_desc->nStuckCount++;
 864                         bCheckFwTxCnt = true;
 865                         if (tcb_desc->nStuckCount > 1)
 866                                 netdev_info(dev,
 867                                             "%s: QueueID=%d tcb_desc->nStuckCount=%d\n",
 868                                             __func__, QueueID,
 869                                             tcb_desc->nStuckCount);
 870                 }
 871         }
 872         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
 873
 874         if (bCheckFwTxCnt) {
 875                 if (rtl92e_is_tx_stuck(dev))
 876                         return RESET_TYPE_SILENT;
 877         }
 878
 879         return RESET_TYPE_NORESET;
 880 }
 881
 882 static enum reset_type _rtl92e_rx_check_stuck(struct net_device *dev)
 883 {
 884         if (rtl92e_is_rx_stuck(dev))
 885                 return RESET_TYPE_SILENT;
 886
 887         return RESET_TYPE_NORESET;
 888 }
 889
 890 static void _rtl92e_if_check_reset(struct net_device *dev)
 891 {
 892         struct r8192_priv *priv = rtllib_priv(dev);
 893         enum reset_type TxResetType = RESET_TYPE_NORESET;
 894         enum reset_type RxResetType = RESET_TYPE_NORESET;
 895         enum rt_rf_power_state rfState;
 896
 897         rfState = priv->rtllib->rf_power_state;
 898
 899         if (rfState == rf_on)
 900                 TxResetType = _rtl92e_tx_check_stuck(dev);
 901
 902         if (rfState == rf_on &&
 903             (priv->rtllib->iw_mode == IW_MODE_INFRA) &&
 904             (priv->rtllib->link_state == MAC80211_LINKED))
 905                 RxResetType = _rtl92e_rx_check_stuck(dev);
 906
 907         if (TxResetType == RESET_TYPE_SILENT ||
 908                    RxResetType == RESET_TYPE_SILENT) {
 909                 netdev_info(dev, "%s(): TxResetType is %d, RxResetType is %d\n",
 910                             __func__, TxResetType, RxResetType);
 911         }
 912         return;
 913 }
 914
 915 static void _rtl92e_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum,
 916                                     u32 *TotalRxDataNum)
 917 {
 918         u16     SlotIndex;
 919         u8      i;
 920
 921         *TotalRxBcnNum = 0;
 922         *TotalRxDataNum = 0;
 923
 924         SlotIndex = (priv->rtllib->link_detect_info.SlotIndex++) %
 925                         (priv->rtllib->link_detect_info.SlotNum);
 926         priv->rtllib->link_detect_info.RxBcnNum[SlotIndex] =
 927                         priv->rtllib->link_detect_info.NumRecvBcnInPeriod;
 928         priv->rtllib->link_detect_info.RxDataNum[SlotIndex] =
 929                         priv->rtllib->link_detect_info.NumRecvDataInPeriod;
 930         for (i = 0; i < priv->rtllib->link_detect_info.SlotNum; i++) {
 931                 *TotalRxBcnNum += priv->rtllib->link_detect_info.RxBcnNum[i];
 932                 *TotalRxDataNum += priv->rtllib->link_detect_info.RxDataNum[i];
 933         }
 934 }
 935
 936 static void _rtl92e_watchdog_wq_cb(void *data)
 937 {
 938         struct r8192_priv *priv = container_of_dwork_rsl(data,
 939                                   struct r8192_priv, watch_dog_wq);
 940         struct net_device *dev = priv->rtllib->dev;
 941         struct rtllib_device *ieee = priv->rtllib;
 942         static u8 check_reset_cnt;
 943         unsigned long flags;
 944         struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *)
 945                                         (&priv->rtllib->pwr_save_ctrl);
 946         bool bBusyTraffic = false;
 947         bool    bHigherBusyTraffic = false;
 948         bool    bHigherBusyRxTraffic = false;
 949         bool bEnterPS = false;
 950
 951         if (!priv->up || priv->hw_radio_off)
 952                 return;
 953
 954         if (priv->rtllib->link_state >= MAC80211_LINKED) {
 955                 if (priv->rtllib->CntAfterLink < 2)
 956                         priv->rtllib->CntAfterLink++;
 957         } else {
 958                 priv->rtllib->CntAfterLink = 0;
 959         }
 960
 961         rtl92e_dm_watchdog(dev);
 962
 963         if (!rtllib_act_scanning(priv->rtllib, false)) {
 964                 if ((ieee->iw_mode == IW_MODE_INFRA) && (ieee->link_state ==
 965                      MAC80211_NOLINK) &&
 966                      (ieee->rf_power_state == rf_on) && !ieee->is_set_key &&
 967                      (!ieee->proto_stoppping) && !ieee->wx_set_enc) {
 968                         if (ieee->pwr_save_ctrl.ReturnPoint == IPS_CALLBACK_NONE) {
 969                                 rtl92e_ips_enter(dev);
 970                         }
 971                 }
 972         }
 973         if ((ieee->link_state == MAC80211_LINKED) && (ieee->iw_mode == IW_MODE_INFRA)) {
 974                 if (ieee->link_detect_info.num_rx_ok_in_period > 100 ||
 975                 ieee->link_detect_info.num_tx_ok_in_period > 100)
 976                         bBusyTraffic = true;
 977
 978                 if (ieee->link_detect_info.num_rx_ok_in_period > 4000 ||
 979                     ieee->link_detect_info.num_tx_ok_in_period > 4000) {
 980                         bHigherBusyTraffic = true;
 981                         if (ieee->link_detect_info.num_rx_ok_in_period > 5000)
 982                                 bHigherBusyRxTraffic = true;
 983                         else
 984                                 bHigherBusyRxTraffic = false;
 985                 }
 986
 987                 if (((ieee->link_detect_info.NumRxUnicastOkInPeriod +
 988                     ieee->link_detect_info.num_tx_ok_in_period) > 8) ||
 989                     (ieee->link_detect_info.NumRxUnicastOkInPeriod > 2))
 990                         bEnterPS = false;
 991                 else
 992                         bEnterPS = true;
 993
 994                 if (ieee->current_network.beacon_interval < 95)
 995                         bEnterPS = false;
 996
 997                 if (bEnterPS)
 998                         rtl92e_leisure_ps_enter(dev);
 999                 else
1000                         rtl92e_leisure_ps_leave(dev);
1001
1002         } else {
1003                 rtl92e_leisure_ps_leave(dev);
1004         }
1005
1006         ieee->link_detect_info.num_rx_ok_in_period = 0;
1007         ieee->link_detect_info.num_tx_ok_in_period = 0;
1008         ieee->link_detect_info.NumRxUnicastOkInPeriod = 0;
1009         ieee->link_detect_info.bBusyTraffic = bBusyTraffic;
1010
1011         ieee->link_detect_info.bHigherBusyTraffic = bHigherBusyTraffic;
1012         ieee->link_detect_info.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
1013
1014         if (ieee->link_state == MAC80211_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
1015                 u32     TotalRxBcnNum = 0;
1016                 u32     TotalRxDataNum = 0;
1017
1018                 _rtl92e_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
1019
1020                 if ((TotalRxBcnNum + TotalRxDataNum) == 0)
1021                         priv->check_roaming_cnt++;
1022                 else
1023                         priv->check_roaming_cnt = 0;
1024
1025                 if (priv->check_roaming_cnt > 0) {
1026                         if (ieee->rf_power_state == rf_off)
1027                                 netdev_info(dev, "%s(): RF is off\n", __func__);
1028
1029                         netdev_info(dev,
1030                                     "===>%s(): AP is power off, chan:%d, connect another one\n",
1031                                     __func__, priv->chan);
1032
1033                         ieee->link_state = RTLLIB_ASSOCIATING;
1034
1035                         RemovePeerTS(priv->rtllib,
1036                                      priv->rtllib->current_network.bssid);
1037                         ieee->is_roaming = true;
1038                         ieee->is_set_key = false;
1039                         ieee->link_change(dev);
1040                         notify_wx_assoc_event(ieee);
1041
1042                         if (!(ieee->rtllib_ap_sec_type(ieee) &
1043                              (SEC_ALG_CCMP | SEC_ALG_TKIP)))
1044                                 schedule_delayed_work(
1045                                         &ieee->associate_procedure_wq, 0);
1046
1047                         priv->check_roaming_cnt = 0;
1048                 }
1049                 ieee->link_detect_info.NumRecvBcnInPeriod = 0;
1050                 ieee->link_detect_info.NumRecvDataInPeriod = 0;
1051         }
1052
1053         spin_lock_irqsave(&priv->tx_lock, flags);
1054         if ((check_reset_cnt++ >= 3) && (!ieee->is_roaming) &&
1055             (!priv->rf_change_in_progress) && (!psc->bSwRfProcessing)) {
1056                 _rtl92e_if_check_reset(dev);
1057                 check_reset_cnt = 3;
1058         }
1059         spin_unlock_irqrestore(&priv->tx_lock, flags);
1060 }
1061
1062 static void _rtl92e_watchdog_timer_cb(struct timer_list *t)
1063 {
1064         struct r8192_priv *priv = from_timer(priv, t, watch_dog_timer);
1065
1066         schedule_delayed_work(&priv->watch_dog_wq, 0);
1067         mod_timer(&priv->watch_dog_timer, jiffies +
1068                   msecs_to_jiffies(RTLLIB_WATCH_DOG_TIME));
1069 }
1070
1071 /****************************************************************************
1072  * ---------------------------- NIC TX/RX STUFF---------------------------
1073  ****************************************************************************/
1074 void rtl92e_rx_enable(struct net_device *dev)
1075 {
1076         rtl92e_enable_rx(dev);
1077 }
1078
1079 void rtl92e_tx_enable(struct net_device *dev)
1080 {
1081         struct r8192_priv *priv = rtllib_priv(dev);
1082
1083         rtl92e_enable_tx(dev);
1084
1085         rtllib_reset_queue(priv->rtllib);
1086 }
1087
1088 static void _rtl92e_free_rx_ring(struct net_device *dev)
1089 {
1090         struct r8192_priv *priv = rtllib_priv(dev);
1091         int i;
1092
1093         for (i = 0; i < priv->rxringcount; i++) {
1094                 struct sk_buff *skb = priv->rx_buf[i];
1095
1096                 if (!skb)
1097                         continue;
1098
1099                 dma_unmap_single(&priv->pdev->dev,
1100                                  *((dma_addr_t *)skb->cb),
1101                                  priv->rxbuffersize, DMA_FROM_DEVICE);
1102                 kfree_skb(skb);
1103         }
1104
1105         dma_free_coherent(&priv->pdev->dev,
1106                           sizeof(*priv->rx_ring) * priv->rxringcount,
1107                           priv->rx_ring,
1108                           priv->rx_ring_dma);
1109         priv->rx_ring = NULL;
1110 }
1111
1112 static void _rtl92e_free_tx_ring(struct net_device *dev, unsigned int prio)
1113 {
1114         struct r8192_priv *priv = rtllib_priv(dev);
1115         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1116
1117         while (skb_queue_len(&ring->queue)) {
1118                 struct tx_desc *entry = &ring->desc[ring->idx];
1119                 struct sk_buff *skb = __skb_dequeue(&ring->queue);
1120
1121                 dma_unmap_single(&priv->pdev->dev, entry->TxBuffAddr,
1122                                  skb->len, DMA_TO_DEVICE);
1123                 kfree_skb(skb);
1124                 ring->idx = (ring->idx + 1) % ring->entries;
1125         }
1126
1127         dma_free_coherent(&priv->pdev->dev,
1128                           sizeof(*ring->desc) * ring->entries, ring->desc,
1129                           ring->dma);
1130         ring->desc = NULL;
1131 }
1132
1133 static void _rtl92e_hard_data_xmit(struct sk_buff *skb, struct net_device *dev,
1134                                    int rate)
1135 {
1136         struct r8192_priv *priv = rtllib_priv(dev);
1137         int ret;
1138         struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1139                                     MAX_DEV_ADDR_SIZE);
1140         u8 queue_index = tcb_desc->queue_index;
1141
1142         if ((priv->rtllib->rf_power_state == rf_off) || !priv->up) {
1143                 kfree_skb(skb);
1144                 return;
1145         }
1146
1147         if (queue_index == TXCMD_QUEUE)
1148                 netdev_warn(dev, "%s(): queue index == TXCMD_QUEUE\n",
1149                             __func__);
1150
1151         memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
1152         skb_push(skb, priv->rtllib->tx_headroom);
1153         ret = _rtl92e_tx(dev, skb);
1154
1155         if (queue_index != MGNT_QUEUE) {
1156                 priv->rtllib->stats.tx_bytes += (skb->len -
1157                                                  priv->rtllib->tx_headroom);
1158                 priv->rtllib->stats.tx_packets++;
1159         }
1160
1161         if (ret != 0)
1162                 kfree_skb(skb);
1163 }
1164
1165 static int _rtl92e_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1166 {
1167         struct r8192_priv *priv = rtllib_priv(dev);
1168         int ret;
1169         struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1170                                     MAX_DEV_ADDR_SIZE);
1171         u8 queue_index = tcb_desc->queue_index;
1172
1173         if (queue_index != TXCMD_QUEUE) {
1174                 if ((priv->rtllib->rf_power_state == rf_off) ||
1175                      !priv->up) {
1176                         kfree_skb(skb);
1177                         return 0;
1178                 }
1179         }
1180
1181         memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
1182         if (queue_index == TXCMD_QUEUE) {
1183                 _rtl92e_tx_cmd(dev, skb);
1184                 return 0;
1185         }
1186
1187         tcb_desc->ratr_index = 7;
1188         tcb_desc->tx_dis_rate_fallback = 1;
1189         tcb_desc->tx_use_drv_assinged_rate = 1;
1190         tcb_desc->tx_enable_fw_calc_dur = 1;
1191         skb_push(skb, priv->rtllib->tx_headroom);
1192         ret = _rtl92e_tx(dev, skb);
1193         if (ret != 0)
1194                 kfree_skb(skb);
1195         return ret;
1196 }
1197
1198 static void _rtl92e_tx_isr(struct net_device *dev, int prio)
1199 {
1200         struct r8192_priv *priv = rtllib_priv(dev);
1201
1202         struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
1203
1204         while (skb_queue_len(&ring->queue)) {
1205                 struct tx_desc *entry = &ring->desc[ring->idx];
1206                 struct sk_buff *skb;
1207
1208                 if (prio != BEACON_QUEUE) {
1209                         if (entry->OWN)
1210                                 return;
1211                         ring->idx = (ring->idx + 1) % ring->entries;
1212                 }
1213
1214                 skb = __skb_dequeue(&ring->queue);
1215                 dma_unmap_single(&priv->pdev->dev, entry->TxBuffAddr,
1216                                  skb->len, DMA_TO_DEVICE);
1217
1218                 kfree_skb(skb);
1219         }
1220         if (prio != BEACON_QUEUE)
1221                 tasklet_schedule(&priv->irq_tx_tasklet);
1222 }
1223
1224 static void _rtl92e_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1225 {
1226         struct r8192_priv *priv = rtllib_priv(dev);
1227         struct rtl8192_tx_ring *ring;
1228         struct tx_desc_cmd *entry;
1229         unsigned int idx;
1230         struct cb_desc *tcb_desc;
1231         unsigned long flags;
1232
1233         spin_lock_irqsave(&priv->irq_th_lock, flags);
1234         ring = &priv->tx_ring[TXCMD_QUEUE];
1235
1236         idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1237         entry = (struct tx_desc_cmd *)&ring->desc[idx];
1238
1239         tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1240
1241         rtl92e_fill_tx_cmd_desc(dev, entry, tcb_desc, skb);
1242
1243         __skb_queue_tail(&ring->queue, skb);
1244         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1245 }
1246
1247 static short _rtl92e_tx(struct net_device *dev, struct sk_buff *skb)
1248 {
1249         struct r8192_priv *priv = rtllib_priv(dev);
1250         struct rtl8192_tx_ring  *ring;
1251         unsigned long flags;
1252         struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1253                                     MAX_DEV_ADDR_SIZE);
1254         struct tx_desc *pdesc = NULL;
1255         struct ieee80211_hdr *header = NULL;
1256         u8 *pda_addr = NULL;
1257         int   idx;
1258         u32 fwinfo_size = 0;
1259
1260         priv->rtllib->bAwakePktSent = true;
1261
1262         fwinfo_size = sizeof(struct tx_fwinfo_8190pci);
1263
1264         header = (struct ieee80211_hdr *)(((u8 *)skb->data) + fwinfo_size);
1265         pda_addr = header->addr1;
1266
1267         if (!is_broadcast_ether_addr(pda_addr) && !is_multicast_ether_addr(pda_addr))
1268                 priv->stats.txbytesunicast += skb->len - fwinfo_size;
1269
1270         spin_lock_irqsave(&priv->irq_th_lock, flags);
1271         ring = &priv->tx_ring[tcb_desc->queue_index];
1272         if (tcb_desc->queue_index != BEACON_QUEUE)
1273                 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1274         else
1275                 idx = 0;
1276
1277         pdesc = &ring->desc[idx];
1278         if ((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
1279                 netdev_warn(dev,
1280                             "No more TX desc@%d, ring->idx = %d, idx = %d, skblen = 0x%x queuelen=%d",
1281                             tcb_desc->queue_index, ring->idx, idx, skb->len,
1282                             skb_queue_len(&ring->queue));
1283                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1284                 return skb->len;
1285         }
1286         rtl92e_fill_tx_desc(dev, pdesc, tcb_desc, skb);
1287         __skb_queue_tail(&ring->queue, skb);
1288         pdesc->OWN = 1;
1289         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1290         netif_trans_update(dev);
1291
1292         rtl92e_writew(dev, TP_POLL, 0x01 << tcb_desc->queue_index);
1293         return 0;
1294 }
1295
1296 static short _rtl92e_alloc_rx_ring(struct net_device *dev)
1297 {
1298         struct r8192_priv *priv = rtllib_priv(dev);
1299         struct rx_desc *entry = NULL;
1300         int i;
1301
1302         priv->rx_ring = dma_alloc_coherent(&priv->pdev->dev,
1303                                            sizeof(*priv->rx_ring) * priv->rxringcount,
1304                                            &priv->rx_ring_dma,
1305                                            GFP_ATOMIC);
1306         if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
1307                 netdev_warn(dev, "Cannot allocate RX ring\n");
1308                 return -ENOMEM;
1309         }
1310
1311         priv->rx_idx = 0;
1312
1313         for (i = 0; i < priv->rxringcount; i++) {
1314                 struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
1315                 dma_addr_t *mapping;
1316
1317                 entry = &priv->rx_ring[i];
1318                 if (!skb)
1319                         return 0;
1320                 skb->dev = dev;
1321                 priv->rx_buf[i] = skb;
1322                 mapping = (dma_addr_t *)skb->cb;
1323                 *mapping = dma_map_single(&priv->pdev->dev,
1324                                           skb_tail_pointer(skb),
1325                                           priv->rxbuffersize, DMA_FROM_DEVICE);
1326                 if (dma_mapping_error(&priv->pdev->dev, *mapping)) {
1327                         dev_kfree_skb_any(skb);
1328                         return -1;
1329                 }
1330                 entry->BufferAddress = *mapping;
1331
1332                 entry->Length = priv->rxbuffersize;
1333                 entry->OWN = 1;
1334         }
1335
1336         if (entry)
1337                 entry->EOR = 1;
1338         return 0;
1339 }
1340
1341 static int _rtl92e_alloc_tx_ring(struct net_device *dev, unsigned int prio,
1342                                  unsigned int entries)
1343 {
1344         struct r8192_priv *priv = rtllib_priv(dev);
1345         struct tx_desc *ring;
1346         dma_addr_t dma;
1347         int i;
1348
1349         ring = dma_alloc_coherent(&priv->pdev->dev, sizeof(*ring) * entries,
1350                                   &dma, GFP_ATOMIC);
1351         if (!ring || (unsigned long)ring & 0xFF) {
1352                 netdev_warn(dev, "Cannot allocate TX ring (prio = %d)\n", prio);
1353                 return -ENOMEM;
1354         }
1355
1356         priv->tx_ring[prio].desc = ring;
1357         priv->tx_ring[prio].dma = dma;
1358         priv->tx_ring[prio].idx = 0;
1359         priv->tx_ring[prio].entries = entries;
1360         skb_queue_head_init(&priv->tx_ring[prio].queue);
1361
1362         for (i = 0; i < entries; i++)
1363                 ring[i].NextDescAddress =
1364                         (u32)dma + ((i + 1) % entries) *
1365                         sizeof(*ring);
1366
1367         return 0;
1368 }
1369
1370 static short _rtl92e_pci_initdescring(struct net_device *dev)
1371 {
1372         u32 ret;
1373         int i;
1374         struct r8192_priv *priv = rtllib_priv(dev);
1375
1376         ret = _rtl92e_alloc_rx_ring(dev);
1377         if (ret)
1378                 return ret;
1379
1380         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1381                 ret = _rtl92e_alloc_tx_ring(dev, i, priv->txringcount);
1382                 if (ret)
1383                         goto err_free_rings;
1384         }
1385
1386         return 0;
1387
1388 err_free_rings:
1389         _rtl92e_free_rx_ring(dev);
1390         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1391                 if (priv->tx_ring[i].desc)
1392                         _rtl92e_free_tx_ring(dev, i);
1393         return 1;
1394 }
1395
1396 void rtl92e_reset_desc_ring(struct net_device *dev)
1397 {
1398         struct r8192_priv *priv = rtllib_priv(dev);
1399         int i;
1400         unsigned long flags = 0;
1401
1402         if (priv->rx_ring) {
1403                 struct rx_desc *entry = NULL;
1404
1405                 for (i = 0; i < priv->rxringcount; i++) {
1406                         entry = &priv->rx_ring[i];
1407                         entry->OWN = 1;
1408                 }
1409                 priv->rx_idx = 0;
1410         }
1411
1412         spin_lock_irqsave(&priv->irq_th_lock, flags);
1413         for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
1414                 if (priv->tx_ring[i].desc) {
1415                         struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
1416
1417                         while (skb_queue_len(&ring->queue)) {
1418                                 struct tx_desc *entry = &ring->desc[ring->idx];
1419                                 struct sk_buff *skb =
1420                                                  __skb_dequeue(&ring->queue);
1421
1422                                 dma_unmap_single(&priv->pdev->dev,
1423                                                  entry->TxBuffAddr, skb->len,
1424                                                  DMA_TO_DEVICE);
1425                                 kfree_skb(skb);
1426                                 ring->idx = (ring->idx + 1) % ring->entries;
1427                         }
1428                         ring->idx = 0;
1429                 }
1430         }
1431         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1432 }
1433
1434 long rtl92e_translate_to_dbm(struct r8192_priv *priv, u8 signal_strength_index)
1435 {
1436         long    signal_power;
1437
1438         signal_power = (long)((signal_strength_index + 1) >> 1);
1439         signal_power -= 95;
1440
1441         return signal_power;
1442 }
1443
1444 void rtl92e_update_rx_statistics(struct r8192_priv *priv,
1445                                  struct rtllib_rx_stats *pprevious_stats)
1446 {
1447         int weighting = 0;
1448
1449         if (priv->stats.recv_signal_power == 0)
1450                 priv->stats.recv_signal_power =
1451                                          pprevious_stats->RecvSignalPower;
1452
1453         if (pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
1454                 weighting = 5;
1455         else if (pprevious_stats->RecvSignalPower <
1456                  priv->stats.recv_signal_power)
1457                 weighting = (-5);
1458         priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 +
1459                                         pprevious_stats->RecvSignalPower +
1460                                         weighting) / 6;
1461 }
1462
1463 u8 rtl92e_rx_db_to_percent(s8 antpower)
1464 {
1465         if ((antpower <= -100) || (antpower >= 20))
1466                 return  0;
1467         else if (antpower >= 0)
1468                 return  100;
1469         else
1470                 return  100 + antpower;
1471
1472 }       /* QueryRxPwrPercentage */
1473
1474 u8 rtl92e_evm_db_to_percent(s8 value)
1475 {
1476         s8 ret_val = clamp(-value, 0, 33) * 3;
1477
1478         if (ret_val == 99)
1479                 ret_val = 100;
1480
1481         return ret_val;
1482 }
1483
1484 void rtl92e_copy_mpdu_stats(struct rtllib_rx_stats *psrc_stats,
1485                             struct rtllib_rx_stats *ptarget_stats)
1486 {
1487         ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
1488         ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
1489 }
1490
1491 static void _rtl92e_rx_normal(struct net_device *dev)
1492 {
1493         struct r8192_priv *priv = rtllib_priv(dev);
1494         struct ieee80211_hdr *rtllib_hdr = NULL;
1495         bool unicast_packet = false;
1496         u32 skb_len = 0;
1497
1498         struct rtllib_rx_stats stats = {
1499                 .signal = 0,
1500                 .noise = (u8)-98,
1501                 .rate = 0,
1502         };
1503         unsigned int count = priv->rxringcount;
1504
1505         stats.nic_type = NIC_8192E;
1506
1507         while (count--) {
1508                 struct rx_desc *pdesc = &priv->rx_ring
1509                                         [priv->rx_idx];
1510                 struct sk_buff *skb = priv->rx_buf
1511                                       [priv->rx_idx];
1512                 struct sk_buff *new_skb;
1513
1514                 if (pdesc->OWN)
1515                         return;
1516                 if (!rtl92e_get_rx_stats(dev, &stats, pdesc, skb))
1517                         goto done;
1518                 new_skb = dev_alloc_skb(priv->rxbuffersize);
1519                 /* if allocation of new skb failed - drop current packet
1520                  * and reuse skb
1521                  */
1522                 if (unlikely(!new_skb))
1523                         goto done;
1524
1525                 dma_unmap_single(&priv->pdev->dev, *((dma_addr_t *)skb->cb),
1526                                  priv->rxbuffersize, DMA_FROM_DEVICE);
1527
1528                 skb_put(skb, pdesc->Length);
1529                 skb_reserve(skb, stats.RxDrvInfoSize +
1530                         stats.RxBufShift);
1531                 skb_trim(skb, skb->len - S_CRC_LEN);
1532                 rtllib_hdr = (struct ieee80211_hdr *)skb->data;
1533                 if (!is_multicast_ether_addr(rtllib_hdr->addr1)) {
1534                         /* unicast packet */
1535                         unicast_packet = true;
1536                 }
1537                 skb_len = skb->len;
1538
1539                 if (!rtllib_rx(priv->rtllib, skb, &stats)) {
1540                         dev_kfree_skb_any(skb);
1541                 } else {
1542                         if (unicast_packet)
1543                                 priv->stats.rxbytesunicast += skb_len;
1544                 }
1545
1546                 skb = new_skb;
1547                 skb->dev = dev;
1548
1549                 priv->rx_buf[priv->rx_idx] = skb;
1550                 *((dma_addr_t *)skb->cb) = dma_map_single(&priv->pdev->dev,
1551                                                           skb_tail_pointer(skb),
1552                                                           priv->rxbuffersize, DMA_FROM_DEVICE);
1553                 if (dma_mapping_error(&priv->pdev->dev, *((dma_addr_t *)skb->cb))) {
1554                         dev_kfree_skb_any(skb);
1555                         return;
1556                 }
1557 done:
1558                 pdesc->BufferAddress = *((dma_addr_t *)skb->cb);
1559                 pdesc->OWN = 1;
1560                 pdesc->Length = priv->rxbuffersize;
1561                 if (priv->rx_idx == priv->rxringcount - 1)
1562                         pdesc->EOR = 1;
1563                 priv->rx_idx = (priv->rx_idx + 1) %
1564                                               priv->rxringcount;
1565         }
1566 }
1567
1568 static void _rtl92e_tx_resume(struct net_device *dev)
1569 {
1570         struct r8192_priv *priv = rtllib_priv(dev);
1571         struct rtllib_device *ieee = priv->rtllib;
1572         struct sk_buff *skb;
1573         int queue_index;
1574
1575         for (queue_index = BK_QUEUE;
1576              queue_index < MAX_QUEUE_SIZE; queue_index++) {
1577                 while ((!skb_queue_empty(&ieee->skb_waitq[queue_index])) &&
1578                 (priv->rtllib->check_nic_enough_desc(dev, queue_index) > 0)) {
1579                         skb = skb_dequeue(&ieee->skb_waitq[queue_index]);
1580                         ieee->softmac_data_hard_start_xmit(skb, dev, 0);
1581                 }
1582         }
1583 }
1584
1585 static void _rtl92e_irq_tx_tasklet(struct tasklet_struct *t)
1586 {
1587         struct r8192_priv *priv = from_tasklet(priv, t, irq_tx_tasklet);
1588
1589         _rtl92e_tx_resume(priv->rtllib->dev);
1590 }
1591
1592 static void _rtl92e_irq_rx_tasklet(struct tasklet_struct *t)
1593 {
1594         struct r8192_priv *priv = from_tasklet(priv, t, irq_rx_tasklet);
1595
1596         _rtl92e_rx_normal(priv->rtllib->dev);
1597
1598         rtl92e_writel(priv->rtllib->dev, INTA_MASK,
1599                       rtl92e_readl(priv->rtllib->dev, INTA_MASK) | IMR_RDU);
1600 }
1601
1602 /****************************************************************************
1603  * ---------------------------- NIC START/CLOSE STUFF---------------------------
1604  ****************************************************************************/
1605 static void _rtl92e_cancel_deferred_work(struct r8192_priv *priv)
1606 {
1607         cancel_delayed_work_sync(&priv->watch_dog_wq);
1608         cancel_delayed_work_sync(&priv->update_beacon_wq);
1609         cancel_delayed_work(&priv->rtllib->hw_sleep_wq);
1610         cancel_work_sync(&priv->reset_wq);
1611         cancel_work_sync(&priv->qos_activate);
1612 }
1613
1614 static int _rtl92e_up(struct net_device *dev)
1615 {
1616         if (_rtl92e_sta_up(dev) == -1)
1617                 return -1;
1618         return 0;
1619 }
1620
1621 static int _rtl92e_open(struct net_device *dev)
1622 {
1623         struct r8192_priv *priv = rtllib_priv(dev);
1624         int ret;
1625
1626         mutex_lock(&priv->wx_mutex);
1627         ret = _rtl92e_try_up(dev);
1628         mutex_unlock(&priv->wx_mutex);
1629         return ret;
1630 }
1631
1632 static int _rtl92e_try_up(struct net_device *dev)
1633 {
1634         struct r8192_priv *priv = rtllib_priv(dev);
1635
1636         if (priv->up == 1)
1637                 return -1;
1638         return _rtl92e_up(dev);
1639 }
1640
1641 static int _rtl92e_close(struct net_device *dev)
1642 {
1643         struct r8192_priv *priv = rtllib_priv(dev);
1644         int ret;
1645
1646         if ((rtllib_act_scanning(priv->rtllib, false)) &&
1647                 !(priv->rtllib->softmac_features & IEEE_SOFTMAC_SCAN)) {
1648                 rtllib_stop_scan(priv->rtllib);
1649         }
1650
1651         mutex_lock(&priv->wx_mutex);
1652
1653         ret = _rtl92e_down(dev, true);
1654
1655         mutex_unlock(&priv->wx_mutex);
1656
1657         return ret;
1658 }
1659
1660 static int _rtl92e_down(struct net_device *dev, bool shutdownrf)
1661 {
1662         if (_rtl92e_sta_down(dev, shutdownrf) == -1)
1663                 return -1;
1664
1665         return 0;
1666 }
1667
1668 void rtl92e_commit(struct net_device *dev)
1669 {
1670         struct r8192_priv *priv = rtllib_priv(dev);
1671
1672         if (priv->up == 0)
1673                 return;
1674         rtllib_softmac_stop_protocol(priv->rtllib);
1675         rtl92e_irq_disable(dev);
1676         rtl92e_stop_adapter(dev, true);
1677         _rtl92e_up(dev);
1678 }
1679
1680 static void _rtl92e_restart(void *data)
1681 {
1682         struct r8192_priv *priv = container_of(data, struct r8192_priv, reset_wq);
1683         struct net_device *dev = priv->rtllib->dev;
1684
1685         mutex_lock(&priv->wx_mutex);
1686
1687         rtl92e_commit(dev);
1688
1689         mutex_unlock(&priv->wx_mutex);
1690 }
1691
1692 static void _rtl92e_set_multicast(struct net_device *dev)
1693 {
1694         struct r8192_priv *priv = rtllib_priv(dev);
1695         short promisc;
1696
1697         promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
1698         priv->promisc = promisc;
1699 }
1700
1701 static int _rtl92e_set_mac_adr(struct net_device *dev, void *mac)
1702 {
1703         struct r8192_priv *priv = rtllib_priv(dev);
1704         struct sockaddr *addr = mac;
1705
1706         mutex_lock(&priv->wx_mutex);
1707
1708         eth_hw_addr_set(dev, addr->sa_data);
1709
1710         schedule_work(&priv->reset_wq);
1711         mutex_unlock(&priv->wx_mutex);
1712
1713         return 0;
1714 }
1715
1716 static irqreturn_t _rtl92e_irq(int irq, void *netdev)
1717 {
1718         struct net_device *dev = netdev;
1719         struct r8192_priv *priv = rtllib_priv(dev);
1720         unsigned long flags;
1721         u32 inta;
1722
1723         if (priv->irq_enabled == 0)
1724                 goto done;
1725
1726         spin_lock_irqsave(&priv->irq_th_lock, flags);
1727
1728         rtl92e_ack_irq(dev, &inta);
1729
1730         if (!inta) {
1731                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1732                 goto done;
1733         }
1734
1735         if (inta == 0xffff) {
1736                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1737                 goto done;
1738         }
1739
1740         if (!netif_running(dev)) {
1741                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1742                 goto done;
1743         }
1744
1745         if (inta  & IMR_MGNTDOK) {
1746                 _rtl92e_tx_isr(dev, MGNT_QUEUE);
1747                 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1748                 if (priv->rtllib->ack_tx_to_ieee) {
1749                         if (_rtl92e_is_tx_queue_empty(dev)) {
1750                                 priv->rtllib->ack_tx_to_ieee = 0;
1751                                 rtllib_ps_tx_ack(priv->rtllib, 1);
1752                         }
1753                 }
1754                 spin_lock_irqsave(&priv->irq_th_lock, flags);
1755         }
1756
1757         if (inta & IMR_COMDOK)
1758                 _rtl92e_tx_isr(dev, TXCMD_QUEUE);
1759
1760         if (inta & IMR_HIGHDOK)
1761                 _rtl92e_tx_isr(dev, HIGH_QUEUE);
1762
1763         if (inta & IMR_ROK)
1764                 tasklet_schedule(&priv->irq_rx_tasklet);
1765
1766         if (inta & IMR_RDU) {
1767                 rtl92e_writel(dev, INTA_MASK,
1768                               rtl92e_readl(dev, INTA_MASK) & ~IMR_RDU);
1769                 tasklet_schedule(&priv->irq_rx_tasklet);
1770         }
1771
1772         if (inta & IMR_RXFOVW)
1773                 tasklet_schedule(&priv->irq_rx_tasklet);
1774
1775         if (inta & IMR_BKDOK) {
1776                 priv->rtllib->link_detect_info.num_tx_ok_in_period++;
1777                 _rtl92e_tx_isr(dev, BK_QUEUE);
1778         }
1779
1780         if (inta & IMR_BEDOK) {
1781                 priv->rtllib->link_detect_info.num_tx_ok_in_period++;
1782                 _rtl92e_tx_isr(dev, BE_QUEUE);
1783         }
1784
1785         if (inta & IMR_VIDOK) {
1786                 priv->rtllib->link_detect_info.num_tx_ok_in_period++;
1787                 _rtl92e_tx_isr(dev, VI_QUEUE);
1788         }
1789
1790         if (inta & IMR_VODOK) {
1791                 priv->rtllib->link_detect_info.num_tx_ok_in_period++;
1792                 _rtl92e_tx_isr(dev, VO_QUEUE);
1793         }
1794
1795         spin_unlock_irqrestore(&priv->irq_th_lock, flags);
1796
1797 done:
1798
1799         return IRQ_HANDLED;
1800 }
1801
1802 /****************************************************************************
1803  * ---------------------------- PCI_STUFF---------------------------
1804  ****************************************************************************/
1805 static const struct net_device_ops rtl8192_netdev_ops = {
1806         .ndo_open = _rtl92e_open,
1807         .ndo_stop = _rtl92e_close,
1808         .ndo_tx_timeout = _rtl92e_tx_timeout,
1809         .ndo_set_rx_mode = _rtl92e_set_multicast,
1810         .ndo_set_mac_address = _rtl92e_set_mac_adr,
1811         .ndo_validate_addr = eth_validate_addr,
1812         .ndo_start_xmit = rtllib_xmit,
1813 };
1814
1815 static int _rtl92e_pci_probe(struct pci_dev *pdev,
1816                              const struct pci_device_id *id)
1817 {
1818         unsigned long ioaddr = 0;
1819         struct net_device *dev = NULL;
1820         struct r8192_priv *priv = NULL;
1821         unsigned long pmem_start, pmem_len, pmem_flags;
1822         int err = -ENOMEM;
1823
1824         if (pci_enable_device(pdev)) {
1825                 dev_err(&pdev->dev, "Failed to enable PCI device");
1826                 return -EIO;
1827         }
1828
1829         pci_set_master(pdev);
1830
1831         if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
1832                 if (dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32))) {
1833                         dev_info(&pdev->dev,
1834                                  "Unable to obtain 32bit DMA for consistent allocations\n");
1835                         goto err_pci_disable;
1836                 }
1837         }
1838         dev = alloc_rtllib(sizeof(struct r8192_priv));
1839         if (!dev)
1840                 goto err_pci_disable;
1841
1842         err = -ENODEV;
1843
1844         pci_set_drvdata(pdev, dev);
1845         SET_NETDEV_DEV(dev, &pdev->dev);
1846         priv = rtllib_priv(dev);
1847         priv->rtllib = (struct rtllib_device *)netdev_priv_rsl(dev);
1848         priv->pdev = pdev;
1849         priv->rtllib->pdev = pdev;
1850         if ((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK) &&
1851             (pdev->subsystem_device == 0x3304))
1852                 priv->rtllib->bSupportRemoteWakeUp = 1;
1853         else
1854                 priv->rtllib->bSupportRemoteWakeUp = 0;
1855
1856         pmem_start = pci_resource_start(pdev, 1);
1857         pmem_len = pci_resource_len(pdev, 1);
1858         pmem_flags = pci_resource_flags(pdev, 1);
1859
1860         if (!(pmem_flags & IORESOURCE_MEM)) {
1861                 netdev_err(dev, "region #1 not a MMIO resource, aborting");
1862                 goto err_rel_rtllib;
1863         }
1864
1865         dev_info(&pdev->dev, "Memory mapped space start: 0x%08lx\n",
1866                  pmem_start);
1867         if (!request_mem_region(pmem_start, pmem_len, DRV_NAME)) {
1868                 netdev_err(dev, "request_mem_region failed!");
1869                 goto err_rel_rtllib;
1870         }
1871
1872         ioaddr = (unsigned long)ioremap(pmem_start, pmem_len);
1873         if (ioaddr == (unsigned long)NULL) {
1874                 netdev_err(dev, "ioremap failed!");
1875                 goto err_rel_mem;
1876         }
1877
1878         dev->mem_start = ioaddr;
1879         dev->mem_end = ioaddr + pci_resource_len(pdev, 0);
1880
1881         if (!rtl92e_check_adapter(pdev, dev))
1882                 goto err_unmap;
1883
1884         dev->irq = pdev->irq;
1885         priv->irq = 0;
1886
1887         dev->netdev_ops = &rtl8192_netdev_ops;
1888
1889         dev->wireless_handlers = &r8192_wx_handlers_def;
1890         dev->ethtool_ops = &rtl819x_ethtool_ops;
1891
1892         dev->type = ARPHRD_ETHER;
1893         dev->watchdog_timeo = HZ * 3;
1894
1895         if (dev_alloc_name(dev, ifname) < 0)
1896                 dev_alloc_name(dev, ifname);
1897
1898         if (_rtl92e_init(dev) != 0) {
1899                 netdev_warn(dev, "Initialization failed");
1900                 goto err_free_irq;
1901         }
1902
1903         netif_carrier_off(dev);
1904         netif_stop_queue(dev);
1905
1906         if (register_netdev(dev))
1907                 goto err_free_irq;
1908
1909         if (priv->polling_timer_on == 0)
1910                 rtl92e_check_rfctrl_gpio_timer(&priv->gpio_polling_timer);
1911
1912         return 0;
1913
1914 err_free_irq:
1915         free_irq(dev->irq, dev);
1916         priv->irq = 0;
1917 err_unmap:
1918         iounmap((void __iomem *)ioaddr);
1919 err_rel_mem:
1920         release_mem_region(pmem_start, pmem_len);
1921 err_rel_rtllib:
1922         free_rtllib(dev);
1923 err_pci_disable:
1924         pci_disable_device(pdev);
1925         return err;
1926 }
1927
1928 static void _rtl92e_pci_disconnect(struct pci_dev *pdev)
1929 {
1930         struct net_device *dev = pci_get_drvdata(pdev);
1931         struct r8192_priv *priv;
1932         u32 i;
1933
1934         if (dev) {
1935                 unregister_netdev(dev);
1936
1937                 priv = rtllib_priv(dev);
1938
1939                 del_timer_sync(&priv->gpio_polling_timer);
1940                 cancel_delayed_work_sync(&priv->gpio_change_rf_wq);
1941                 priv->polling_timer_on = 0;
1942                 _rtl92e_down(dev, true);
1943                 rtl92e_dm_deinit(dev);
1944                 vfree(priv->fw_info);
1945                 priv->fw_info = NULL;
1946                 _rtl92e_free_rx_ring(dev);
1947                 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
1948                         _rtl92e_free_tx_ring(dev, i);
1949
1950                 if (priv->irq) {
1951                         dev_info(&pdev->dev, "Freeing irq %d\n", dev->irq);
1952                         free_irq(dev->irq, dev);
1953                         priv->irq = 0;
1954                 }
1955
1956                 if (dev->mem_start != 0) {
1957                         iounmap((void __iomem *)dev->mem_start);
1958                         release_mem_region(pci_resource_start(pdev, 1),
1959                                         pci_resource_len(pdev, 1));
1960                 }
1961
1962                 free_rtllib(dev);
1963         }
1964
1965         pci_disable_device(pdev);
1966 }
1967
1968 bool rtl92e_enable_nic(struct net_device *dev)
1969 {
1970         bool init_status = true;
1971         struct r8192_priv *priv = rtllib_priv(dev);
1972         struct rt_pwr_save_ctrl *psc = (struct rt_pwr_save_ctrl *)
1973                                         (&priv->rtllib->pwr_save_ctrl);
1974
1975         if (!priv->up) {
1976                 netdev_warn(dev, "%s(): Driver is already down!\n", __func__);
1977                 return false;
1978         }
1979
1980         init_status = rtl92e_start_adapter(dev);
1981         if (!init_status) {
1982                 netdev_warn(dev, "%s(): Initialization failed!\n", __func__);
1983                 return false;
1984         }
1985         RT_CLEAR_PS_LEVEL(psc, RT_RF_OFF_LEVL_HALT_NIC);
1986
1987         rtl92e_irq_enable(dev);
1988         return init_status;
1989 }
1990
1991 module_pci_driver(rtl8192_pci_driver);
1992
1993 void rtl92e_check_rfctrl_gpio_timer(struct timer_list *t)
1994 {
1995         struct r8192_priv *priv = from_timer(priv, t, gpio_polling_timer);
1996
1997         priv->polling_timer_on = 1;
1998
1999         schedule_delayed_work(&priv->gpio_change_rf_wq, 0);
2000
2001         mod_timer(&priv->gpio_polling_timer, jiffies +
2002                   msecs_to_jiffies(RTLLIB_WATCH_DOG_TIME));
2003 }
2004
2005 /***************************************************************************
2006  * ------------------- module init / exit stubs ----------------
2007  ***************************************************************************/
2008 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
2009 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
2010 MODULE_VERSION(DRV_VERSION);
2011 MODULE_LICENSE("GPL");
2012 MODULE_FIRMWARE(RTL8192E_BOOT_IMG_FW);
2013 MODULE_FIRMWARE(RTL8192E_MAIN_IMG_FW);
2014 MODULE_FIRMWARE(RTL8192E_DATA_IMG_FW);
2015
2016 module_param(ifname, charp, 0644);
2017 module_param(hwwep, int, 0644);
2018
2019 MODULE_PARM_DESC(ifname, " Net interface name, wlan%d=default");
2020 MODULE_PARM_DESC(hwwep, " Try to use hardware WEP support(default use hw. set 0 to use software security)");