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
rtl92e_readb(struct net_device * dev,int x)95 u8 rtl92e_readb(struct net_device *dev, int x)
96 {
97 return 0xff & readb((u8 __iomem *)dev->mem_start + x);
98 }
99
rtl92e_readl(struct net_device * dev,int x)100 u32 rtl92e_readl(struct net_device *dev, int x)
101 {
102 return readl((u8 __iomem *)dev->mem_start + x);
103 }
104
rtl92e_readw(struct net_device * dev,int x)105 u16 rtl92e_readw(struct net_device *dev, int x)
106 {
107 return readw((u8 __iomem *)dev->mem_start + x);
108 }
109
rtl92e_writeb(struct net_device * dev,int x,u8 y)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
rtl92e_writel(struct net_device * dev,int x,u32 y)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
rtl92e_writew(struct net_device * dev,int x,u16 y)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 ****************************************************************************/
rtl92e_set_rf_state(struct net_device * dev,enum rt_rf_power_state state_to_set,RT_RF_CHANGE_SOURCE change_source)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
_rtl92e_check_nic_enough_desc(struct net_device * dev,int prio)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
_rtl92e_tx_timeout(struct net_device * dev,unsigned int txqueue)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
rtl92e_irq_enable(struct net_device * dev)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
rtl92e_irq_disable(struct net_device * dev)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
_rtl92e_set_chan(struct net_device * dev,short ch)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
_rtl92e_update_cap(struct net_device * dev,u16 cap)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
_rtl92e_update_beacon(void * data)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
_rtl92e_qos_activate(void * data)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
_rtl92e_qos_handle_probe_response(struct r8192_priv * priv,int active_network,struct rtllib_network * network)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
_rtl92e_handle_beacon(struct net_device * dev,struct rtllib_beacon * beacon,struct rtllib_network * network)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
_rtl92e_qos_assoc_resp(struct r8192_priv * priv,struct rtllib_network * network)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
_rtl92e_handle_assoc_response(struct net_device * dev,struct rtllib_assoc_response_frame * resp,struct rtllib_network * network)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
_rtl92e_prepare_beacon(struct tasklet_struct * t)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
_rtl92e_stop_beacon(struct net_device * dev)507 static void _rtl92e_stop_beacon(struct net_device *dev)
508 {
509 }
510
rtl92e_config_rate(struct net_device * dev,u16 * rate_config)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
_rtl92e_refresh_support_rate(struct r8192_priv * priv)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
_rtl92e_get_supported_wireless_mode(struct net_device * dev)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
rtl92e_set_wireless_mode(struct net_device * dev,u8 wireless_mode)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
_rtl92e_sta_up(struct net_device * dev,bool is_silent_reset)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
_rtl92e_sta_down(struct net_device * dev,bool shutdownrf)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
_rtl92e_init_priv_handler(struct net_device * dev)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
_rtl92e_init_priv_constant(struct net_device * dev)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
_rtl92e_init_priv_variable(struct net_device * dev)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
_rtl92e_init_priv_lock(struct r8192_priv * priv)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
_rtl92e_init_priv_task(struct net_device * dev)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
_rtl92e_get_channel_map(struct net_device * dev)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
_rtl92e_init(struct net_device * dev)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 **************************************************************************/
_rtl92e_is_tx_queue_empty(struct net_device * dev)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
_rtl92e_tx_check_stuck(struct net_device * dev)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
_rtl92e_rx_check_stuck(struct net_device * dev)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
_rtl92e_if_check_reset(struct net_device * dev)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
_rtl92e_if_silent_reset(struct net_device * dev)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
_rtl92e_update_rxcounts(struct r8192_priv * priv,u32 * TotalRxBcnNum,u32 * TotalRxDataNum)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
_rtl92e_watchdog_wq_cb(void * data)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
_rtl92e_watchdog_timer_cb(struct timer_list * t)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 ****************************************************************************/
rtl92e_rx_enable(struct net_device * dev)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
rtl92e_tx_enable(struct net_device * dev)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
_rtl92e_free_rx_ring(struct net_device * dev)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
_rtl92e_free_tx_ring(struct net_device * dev,unsigned int prio)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
_rtl92e_hard_data_xmit(struct sk_buff * skb,struct net_device * dev,int rate)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
_rtl92e_hard_start_xmit(struct sk_buff * skb,struct net_device * dev)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
_rtl92e_tx_isr(struct net_device * dev,int prio)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
_rtl92e_tx_cmd(struct net_device * dev,struct sk_buff * skb)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
_rtl92e_tx(struct net_device * dev,struct sk_buff * skb)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
_rtl92e_alloc_rx_ring(struct net_device * dev)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
_rtl92e_alloc_tx_ring(struct net_device * dev,unsigned int prio,unsigned int entries)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
_rtl92e_pci_initdescring(struct net_device * dev)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
rtl92e_reset_desc_ring(struct net_device * dev)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
rtl92e_update_rx_pkt_timestamp(struct net_device * dev,struct rtllib_rx_stats * stats)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
rtl92e_translate_to_dbm(struct r8192_priv * priv,u8 signal_strength_index)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
rtl92e_update_rx_statistics(struct r8192_priv * priv,struct rtllib_rx_stats * pprevious_stats)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
rtl92e_rx_db_to_percent(s8 antpower)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
rtl92e_evm_db_to_percent(s8 value)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
rtl92e_copy_mpdu_stats(struct rtllib_rx_stats * psrc_stats,struct rtllib_rx_stats * ptarget_stats)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
_rtl92e_rx_normal(struct net_device * dev)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
_rtl92e_tx_resume(struct net_device * dev)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
_rtl92e_irq_tx_tasklet(struct tasklet_struct * t)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
_rtl92e_irq_rx_tasklet(struct tasklet_struct * t)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 ****************************************************************************/
_rtl92e_cancel_deferred_work(struct r8192_priv * priv)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
_rtl92e_up(struct net_device * dev,bool is_silent_reset)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
_rtl92e_open(struct net_device * dev)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
_rtl92e_try_up(struct net_device * dev)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
_rtl92e_close(struct net_device * dev)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
_rtl92e_down(struct net_device * dev,bool shutdownrf)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
rtl92e_commit(struct net_device * dev)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
_rtl92e_restart(void * data)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
_rtl92e_set_multicast(struct net_device * dev)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
_rtl92e_set_mac_adr(struct net_device * dev,void * mac)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
_rtl92e_irq(int irq,void * netdev)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
_rtl92e_pci_probe(struct pci_dev * pdev,const struct pci_device_id * id)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
_rtl92e_pci_disconnect(struct pci_dev * pdev)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
rtl92e_enable_nic(struct net_device * dev)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
rtl92e_disable_nic(struct net_device * dev)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
rtl92e_check_rfctrl_gpio_timer(struct timer_list * t)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
