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