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