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