1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
3 *
4 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 *
6 ******************************************************************************/
7 #include <drv_types.h>
8 #include <hal_data.h>
9
10 MODULE_LICENSE("GPL");
11 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
12 MODULE_AUTHOR("Realtek Semiconductor Corp.");
13 MODULE_VERSION(DRIVERVERSION);
14
15 /* module param defaults */
16 static int rtw_chip_version;
17 static int rtw_rfintfs = HWPI;
18 static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
19
20
21 static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure;infra, ad-hoc, auto */
22 /* struct ndis_802_11_ssid ssid; */
23 static int rtw_channel = 1;/* ad-hoc support requirement */
24 static int rtw_wireless_mode = WIRELESS_11BG_24N;
25 static int rtw_vrtl_carrier_sense = AUTO_VCS;
26 static int rtw_vcs_type = RTS_CTS;/* */
27 static int rtw_rts_thresh = 2347;/* */
28 static int rtw_frag_thresh = 2346;/* */
29 static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
30 static int rtw_scan_mode = 1;/* active, passive */
31 static int rtw_adhoc_tx_pwr = 1;
32 static int rtw_soft_ap;
33 /* int smart_ps = 1; */
34 static int rtw_power_mgnt = 1;
35 static int rtw_ips_mode = IPS_NORMAL;
36 module_param(rtw_ips_mode, int, 0644);
37 MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
38
39 static int rtw_smart_ps = 2;
40
41 static int rtw_check_fw_ps = 1;
42
43 static int rtw_usb_rxagg_mode = 2;/* USB_RX_AGG_DMA = 1, USB_RX_AGG_USB =2 */
44 module_param(rtw_usb_rxagg_mode, int, 0644);
45
46 static int rtw_radio_enable = 1;
47 static int rtw_long_retry_lmt = 7;
48 static int rtw_short_retry_lmt = 7;
49 static int rtw_busy_thresh = 40;
50 /* int qos_enable = 0; */
51 static int rtw_ack_policy = NORMAL_ACK;
52
53 static int rtw_software_encrypt;
54 static int rtw_software_decrypt;
55
56 static int rtw_acm_method;/* 0:By SW 1:By HW. */
57
58 static int rtw_wmm_enable = 1;/* default is set to enable the wmm. */
59 static int rtw_uapsd_enable;
60 static int rtw_uapsd_max_sp = NO_LIMIT;
61 static int rtw_uapsd_acbk_en;
62 static int rtw_uapsd_acbe_en;
63 static int rtw_uapsd_acvi_en;
64 static int rtw_uapsd_acvo_en;
65
66 int rtw_ht_enable = 1;
67 /*
68 * 0: 20 MHz, 1: 40 MHz
69 * 2.4G use bit 0 ~ 3
70 * 0x01 means enable 2.4G 40MHz
71 */
72 static int rtw_bw_mode = 0x01;
73 static int rtw_ampdu_enable = 1;/* for enable tx_ampdu ,0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */
74 static int rtw_rx_stbc = 1;/* 0: disable, 1:enable 2.4g */
75 static int rtw_ampdu_amsdu;/* 0: disabled, 1:enabled, 2:auto . There is an IOT issu with DLINK DIR-629 when the flag turn on */
76 /* Short GI support Bit Map */
77 /* BIT0 - 20MHz, 0: non-support, 1: support */
78 /* BIT1 - 40MHz, 0: non-support, 1: support */
79 /* BIT2 - 80MHz, 0: non-support, 1: support */
80 /* BIT3 - 160MHz, 0: non-support, 1: support */
81 static int rtw_short_gi = 0xf;
82 /* BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */
83 static int rtw_ldpc_cap = 0x33;
84 /* BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx */
85 static int rtw_stbc_cap = 0x13;
86 /* BIT0: Enable VHT Beamformer, BIT1: Enable VHT Beamformee, BIT4: Enable HT Beamformer, BIT5: Enable HT Beamformee */
87 static int rtw_beamform_cap = 0x2;
88
89 static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
90
91 static int rtw_low_power;
92 static int rtw_wifi_spec;
93 static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
94
95 static int rtw_ant_num = -1; /* <0: undefined, >0: Antenna number */
96 module_param(rtw_ant_num, int, 0644);
97 MODULE_PARM_DESC(rtw_ant_num, "Antenna number setting");
98
99 static int rtw_antdiv_cfg = 1; /* 0:OFF , 1:ON, 2:decide by Efuse config */
100 static int rtw_antdiv_type; /* 0:decide by efuse 1: for 88EE, 1Tx and 1RxCG are diversity.(2 Ant with SPDT), 2: for 88EE, 1Tx and 2Rx are diversity.(2 Ant, Tx and RxCG are both on aux port, RxCS is on main port), 3: for 88EE, 1Tx and 1RxCG are fixed.(1Ant, Tx and RxCG are both on aux port) */
101
102
103
104 static int rtw_hw_wps_pbc;
105
106 int rtw_mc2u_disable;
107
108 static int rtw_80211d;
109
110 static int rtw_qos_opt_enable;/* 0: disable, 1:enable */
111 module_param(rtw_qos_opt_enable, int, 0644);
112
113 static char *ifname = "wlan%d";
114 module_param(ifname, charp, 0644);
115 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
116
117 char *rtw_initmac; /* temp mac address if users want to use instead of the mac address in Efuse */
118
119 module_param(rtw_initmac, charp, 0644);
120 module_param(rtw_channel_plan, int, 0644);
121 module_param(rtw_chip_version, int, 0644);
122 module_param(rtw_rfintfs, int, 0644);
123 module_param(rtw_lbkmode, int, 0644);
124 module_param(rtw_network_mode, int, 0644);
125 module_param(rtw_channel, int, 0644);
126 module_param(rtw_wmm_enable, int, 0644);
127 module_param(rtw_vrtl_carrier_sense, int, 0644);
128 module_param(rtw_vcs_type, int, 0644);
129 module_param(rtw_busy_thresh, int, 0644);
130
131 module_param(rtw_ht_enable, int, 0644);
132 module_param(rtw_bw_mode, int, 0644);
133 module_param(rtw_ampdu_enable, int, 0644);
134 module_param(rtw_rx_stbc, int, 0644);
135 module_param(rtw_ampdu_amsdu, int, 0644);
136
137 module_param(rtw_lowrate_two_xmit, int, 0644);
138
139 module_param(rtw_power_mgnt, int, 0644);
140 module_param(rtw_smart_ps, int, 0644);
141 module_param(rtw_low_power, int, 0644);
142 module_param(rtw_wifi_spec, int, 0644);
143
144 module_param(rtw_antdiv_cfg, int, 0644);
145 module_param(rtw_antdiv_type, int, 0644);
146
147
148 module_param(rtw_hw_wps_pbc, int, 0644);
149
150 static uint rtw_max_roaming_times = 2;
151 module_param(rtw_max_roaming_times, uint, 0644);
152 MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
153
154 module_param(rtw_mc2u_disable, int, 0644);
155
156 module_param(rtw_80211d, int, 0644);
157 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
158
159 static uint rtw_notch_filter;
160 module_param(rtw_notch_filter, uint, 0644);
161 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
162
163 #define CONFIG_RTW_HIQ_FILTER 1
164
165 static uint rtw_hiq_filter = CONFIG_RTW_HIQ_FILTER;
166 module_param(rtw_hiq_filter, uint, 0644);
167 MODULE_PARM_DESC(rtw_hiq_filter, "0:allow all, 1:allow special, 2:deny all");
168
169 static int rtw_tx_pwr_lmt_enable;
170 static int rtw_tx_pwr_by_rate;
171
172 module_param(rtw_tx_pwr_lmt_enable, int, 0644);
173 MODULE_PARM_DESC(rtw_tx_pwr_lmt_enable, "0:Disable, 1:Enable, 2: Depend on efuse");
174
175 module_param(rtw_tx_pwr_by_rate, int, 0644);
176 MODULE_PARM_DESC(rtw_tx_pwr_by_rate, "0:Disable, 1:Enable, 2: Depend on efuse");
177
178 static int netdev_close(struct net_device *pnetdev);
179
loadparam(struct adapter * padapter,struct net_device * pnetdev)180 static void loadparam(struct adapter *padapter, struct net_device *pnetdev)
181 {
182 struct registry_priv *registry_par = &padapter->registrypriv;
183
184 registry_par->chip_version = (u8)rtw_chip_version;
185 registry_par->rfintfs = (u8)rtw_rfintfs;
186 registry_par->lbkmode = (u8)rtw_lbkmode;
187 /* registry_par->hci = (u8)hci; */
188 registry_par->network_mode = (u8)rtw_network_mode;
189
190 memcpy(registry_par->ssid.ssid, "ANY", 3);
191 registry_par->ssid.ssid_length = 3;
192
193 registry_par->channel = (u8)rtw_channel;
194 registry_par->wireless_mode = (u8)rtw_wireless_mode;
195
196 registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense;
197 registry_par->vcs_type = (u8)rtw_vcs_type;
198 registry_par->rts_thresh = (u16)rtw_rts_thresh;
199 registry_par->frag_thresh = (u16)rtw_frag_thresh;
200 registry_par->preamble = (u8)rtw_preamble;
201 registry_par->scan_mode = (u8)rtw_scan_mode;
202 registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
203 registry_par->soft_ap = (u8)rtw_soft_ap;
204 registry_par->smart_ps = (u8)rtw_smart_ps;
205 registry_par->check_fw_ps = (u8)rtw_check_fw_ps;
206 registry_par->power_mgnt = (u8)rtw_power_mgnt;
207 registry_par->ips_mode = (u8)rtw_ips_mode;
208 registry_par->radio_enable = (u8)rtw_radio_enable;
209 registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
210 registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
211 registry_par->busy_thresh = (u16)rtw_busy_thresh;
212 /* registry_par->qos_enable = (u8)rtw_qos_enable; */
213 registry_par->ack_policy = (u8)rtw_ack_policy;
214 registry_par->software_encrypt = (u8)rtw_software_encrypt;
215 registry_par->software_decrypt = (u8)rtw_software_decrypt;
216
217 registry_par->acm_method = (u8)rtw_acm_method;
218 registry_par->usb_rxagg_mode = (u8)rtw_usb_rxagg_mode;
219
220 /* UAPSD */
221 registry_par->wmm_enable = (u8)rtw_wmm_enable;
222 registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
223 registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
224 registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
225 registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
226 registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
227 registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
228
229 registry_par->ht_enable = (u8)rtw_ht_enable;
230 registry_par->bw_mode = (u8)rtw_bw_mode;
231 registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
232 registry_par->rx_stbc = (u8)rtw_rx_stbc;
233 registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
234 registry_par->short_gi = (u8)rtw_short_gi;
235 registry_par->ldpc_cap = (u8)rtw_ldpc_cap;
236 registry_par->stbc_cap = (u8)rtw_stbc_cap;
237 registry_par->beamform_cap = (u8)rtw_beamform_cap;
238
239 registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
240 registry_par->low_power = (u8)rtw_low_power;
241
242
243 registry_par->wifi_spec = (u8)rtw_wifi_spec;
244
245 registry_par->channel_plan = (u8)rtw_channel_plan;
246
247 registry_par->ant_num = (s8)rtw_ant_num;
248
249 registry_par->accept_addba_req = true;
250
251 registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
252 registry_par->antdiv_type = (u8)rtw_antdiv_type;
253
254 registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
255
256 registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
257
258 registry_par->enable80211d = (u8)rtw_80211d;
259
260 snprintf(registry_par->ifname, 16, "%s", ifname);
261
262 registry_par->notch_filter = (u8)rtw_notch_filter;
263
264 registry_par->RegEnableTxPowerLimit = (u8)rtw_tx_pwr_lmt_enable;
265 registry_par->RegEnableTxPowerByRate = (u8)rtw_tx_pwr_by_rate;
266
267 registry_par->RegPowerBase = 14;
268 registry_par->TxBBSwing_2G = 0xFF;
269 registry_par->bEn_RFE = 1;
270 registry_par->RFE_Type = 64;
271
272 registry_par->qos_opt_enable = (u8)rtw_qos_opt_enable;
273
274 registry_par->hiq_filter = (u8)rtw_hiq_filter;
275 }
276
rtw_net_set_mac_address(struct net_device * pnetdev,void * p)277 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
278 {
279 struct adapter *padapter = rtw_netdev_priv(pnetdev);
280 struct sockaddr *addr = p;
281
282 if (!padapter->bup) {
283 /* addr->sa_data[4], addr->sa_data[5]); */
284 memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
285 /* eth_hw_addr_set(pnetdev, addr->sa_data); */
286 /* padapter->bset_hwaddr = true; */
287 }
288
289 return 0;
290 }
291
rtw_net_get_stats(struct net_device * pnetdev)292 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
293 {
294 struct adapter *padapter = rtw_netdev_priv(pnetdev);
295 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
296 struct recv_priv *precvpriv = &(padapter->recvpriv);
297
298 padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
299 padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */
300 padapter->stats.tx_dropped = pxmitpriv->tx_drop;
301 padapter->stats.rx_dropped = precvpriv->rx_drop;
302 padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
303 padapter->stats.rx_bytes = precvpriv->rx_bytes;
304
305 return &padapter->stats;
306 }
307
308 /*
309 * AC to queue mapping
310 *
311 * AC_VO -> queue 0
312 * AC_VI -> queue 1
313 * AC_BE -> queue 2
314 * AC_BK -> queue 3
315 */
316 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
317
318 /* Given a data frame determine the 802.1p/1d tag to use. */
rtw_classify8021d(struct sk_buff * skb)319 static unsigned int rtw_classify8021d(struct sk_buff *skb)
320 {
321 unsigned int dscp;
322
323 /* skb->priority values from 256->263 are magic values to
324 * directly indicate a specific 802.1d priority. This is used
325 * to allow 802.1d priority to be passed directly in from VLAN
326 * tags, etc.
327 */
328 if (skb->priority >= 256 && skb->priority <= 263)
329 return skb->priority - 256;
330
331 switch (skb->protocol) {
332 case htons(ETH_P_IP):
333 dscp = ip_hdr(skb)->tos & 0xfc;
334 break;
335 default:
336 return 0;
337 }
338
339 return dscp >> 5;
340 }
341
342
rtw_select_queue(struct net_device * dev,struct sk_buff * skb,struct net_device * sb_dev)343 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb,
344 struct net_device *sb_dev)
345 {
346 struct adapter *padapter = rtw_netdev_priv(dev);
347 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
348
349 skb->priority = rtw_classify8021d(skb);
350
351 if (pmlmepriv->acm_mask != 0)
352 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
353
354 return rtw_1d_to_queue[skb->priority];
355 }
356
rtw_recv_select_queue(struct sk_buff * skb)357 u16 rtw_recv_select_queue(struct sk_buff *skb)
358 {
359 struct iphdr *piphdr;
360 unsigned int dscp;
361 __be16 eth_type;
362 u32 priority;
363 u8 *pdata = skb->data;
364
365 memcpy(ð_type, pdata + (ETH_ALEN << 1), 2);
366
367 switch (be16_to_cpu(eth_type)) {
368 case ETH_P_IP:
369
370 piphdr = (struct iphdr *)(pdata + ETH_HLEN);
371
372 dscp = piphdr->tos & 0xfc;
373
374 priority = dscp >> 5;
375
376 break;
377 default:
378 priority = 0;
379 }
380
381 return rtw_1d_to_queue[priority];
382 }
383
rtw_ndev_init(struct net_device * dev)384 static int rtw_ndev_init(struct net_device *dev)
385 {
386 struct adapter *adapter = rtw_netdev_priv(dev);
387
388 netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
389 strscpy(adapter->old_ifname, dev->name);
390
391 return 0;
392 }
393
rtw_ndev_uninit(struct net_device * dev)394 static void rtw_ndev_uninit(struct net_device *dev)
395 {
396 struct adapter *adapter = rtw_netdev_priv(dev);
397
398 netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
399 }
400
401 static const struct net_device_ops rtw_netdev_ops = {
402 .ndo_init = rtw_ndev_init,
403 .ndo_uninit = rtw_ndev_uninit,
404 .ndo_open = netdev_open,
405 .ndo_stop = netdev_close,
406 .ndo_start_xmit = rtw_xmit_entry,
407 .ndo_select_queue = rtw_select_queue,
408 .ndo_set_mac_address = rtw_net_set_mac_address,
409 .ndo_get_stats = rtw_net_get_stats,
410 };
411
rtw_init_netdev_name(struct net_device * pnetdev,const char * ifname)412 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
413 {
414 if (dev_alloc_name(pnetdev, ifname) < 0) {
415 pr_err("dev_alloc_name, fail for %s\n", ifname);
416 return 1;
417 }
418 netif_carrier_off(pnetdev);
419 /* rtw_netif_stop_queue(pnetdev); */
420
421 return 0;
422 }
423
rtw_init_netdev(struct adapter * old_padapter)424 struct net_device *rtw_init_netdev(struct adapter *old_padapter)
425 {
426 struct adapter *padapter;
427 struct net_device *pnetdev;
428
429 if (old_padapter)
430 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter);
431 else
432 pnetdev = rtw_alloc_etherdev(sizeof(struct adapter));
433
434 pr_info("pnetdev = %p\n", pnetdev);
435 if (!pnetdev)
436 return NULL;
437
438 padapter = rtw_netdev_priv(pnetdev);
439 padapter->pnetdev = pnetdev;
440
441 /* pnetdev->init = NULL; */
442
443 pnetdev->netdev_ops = &rtw_netdev_ops;
444
445 /* pnetdev->tx_timeout = NULL; */
446 pnetdev->watchdog_timeo = HZ * 3; /* 3 second timeout */
447
448 /* step 2. */
449 loadparam(padapter, pnetdev);
450
451 return pnetdev;
452 }
453
rtw_unregister_netdevs(struct dvobj_priv * dvobj)454 void rtw_unregister_netdevs(struct dvobj_priv *dvobj)
455 {
456 struct adapter *padapter = NULL;
457 struct net_device *pnetdev = NULL;
458
459 padapter = dvobj->padapters;
460
461 if (!padapter)
462 return;
463
464 pnetdev = padapter->pnetdev;
465
466 if ((padapter->DriverState != DRIVER_DISAPPEAR) && pnetdev)
467 unregister_netdev(pnetdev); /* will call netdev_close() */
468 rtw_wdev_unregister(padapter->rtw_wdev);
469 }
470
rtw_start_drv_threads(struct adapter * padapter)471 u32 rtw_start_drv_threads(struct adapter *padapter)
472 {
473 u32 _status = _SUCCESS;
474
475 padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
476 if (IS_ERR(padapter->xmitThread))
477 _status = _FAIL;
478
479 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
480 if (IS_ERR(padapter->cmdThread))
481 _status = _FAIL;
482 else
483 wait_for_completion(&padapter->cmdpriv.terminate_cmdthread_comp); /* wait for cmd_thread to run */
484
485 rtw_hal_start_thread(padapter);
486 return _status;
487 }
488
rtw_stop_drv_threads(struct adapter * padapter)489 void rtw_stop_drv_threads(struct adapter *padapter)
490 {
491 rtw_stop_cmd_thread(padapter);
492
493 /* Below is to termindate tx_thread... */
494 complete(&padapter->xmitpriv.xmit_comp);
495 wait_for_completion(&padapter->xmitpriv.terminate_xmitthread_comp);
496
497 rtw_hal_stop_thread(padapter);
498 }
499
rtw_init_default_value(struct adapter * padapter)500 static void rtw_init_default_value(struct adapter *padapter)
501 {
502 struct registry_priv *pregistrypriv = &padapter->registrypriv;
503 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
504 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
505 struct security_priv *psecuritypriv = &padapter->securitypriv;
506
507 /* xmit_priv */
508 pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
509 pxmitpriv->vcs = pregistrypriv->vcs_type;
510 pxmitpriv->vcs_type = pregistrypriv->vcs_type;
511 /* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
512 pxmitpriv->frag_len = pregistrypriv->frag_thresh;
513
514 /* recv_priv */
515
516 /* mlme_priv */
517 pmlmepriv->scan_mode = SCAN_ACTIVE;
518
519 /* qos_priv */
520 /* pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable; */
521
522 /* ht_priv */
523 pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
524
525 /* security_priv */
526 /* rtw_get_encrypt_decrypt_from_registrypriv(padapter); */
527 psecuritypriv->binstallGrpkey = _FAIL;
528 psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
529 psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
530
531 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
532 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
533
534 psecuritypriv->dot11PrivacyKeyIndex = 0;
535
536 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
537 psecuritypriv->dot118021XGrpKeyid = 1;
538
539 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
540 psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
541
542 /* registry_priv */
543 rtw_init_registrypriv_dev_network(padapter);
544 rtw_update_registrypriv_dev_network(padapter);
545
546 /* hal_priv */
547 rtw_hal_def_value_init(padapter);
548
549 /* misc. */
550 RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
551 RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
552 padapter->bLinkInfoDump = 0;
553 padapter->bNotifyChannelChange = 0;
554
555 /* for debug purpose */
556 padapter->fix_rate = 0xFF;
557 padapter->driver_ampdu_spacing = 0xFF;
558 padapter->driver_rx_ampdu_factor = 0xFF;
559
560 }
561
devobj_init(void)562 struct dvobj_priv *devobj_init(void)
563 {
564 struct dvobj_priv *pdvobj = NULL;
565
566 pdvobj = rtw_zmalloc(sizeof(*pdvobj));
567 if (!pdvobj)
568 return NULL;
569
570 mutex_init(&pdvobj->hw_init_mutex);
571 mutex_init(&pdvobj->h2c_fwcmd_mutex);
572 mutex_init(&pdvobj->setch_mutex);
573 mutex_init(&pdvobj->setbw_mutex);
574
575 spin_lock_init(&pdvobj->lock);
576
577 pdvobj->macid[1] = true; /* macid = 1 for bc/mc stainfo */
578
579 pdvobj->processing_dev_remove = false;
580
581 atomic_set(&pdvobj->disable_func, 0);
582
583 spin_lock_init(&pdvobj->cam_ctl.lock);
584
585 return pdvobj;
586 }
587
devobj_deinit(struct dvobj_priv * pdvobj)588 void devobj_deinit(struct dvobj_priv *pdvobj)
589 {
590 if (!pdvobj)
591 return;
592
593 mutex_destroy(&pdvobj->hw_init_mutex);
594 mutex_destroy(&pdvobj->h2c_fwcmd_mutex);
595 mutex_destroy(&pdvobj->setch_mutex);
596 mutex_destroy(&pdvobj->setbw_mutex);
597
598 kfree(pdvobj);
599 }
600
rtw_reset_drv_sw(struct adapter * padapter)601 void rtw_reset_drv_sw(struct adapter *padapter)
602 {
603 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
604 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
605
606 /* hal_priv */
607 rtw_hal_def_value_init(padapter);
608
609 RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
610 RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
611 padapter->bLinkInfoDump = 0;
612
613 padapter->xmitpriv.tx_pkts = 0;
614 padapter->recvpriv.rx_pkts = 0;
615
616 pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
617
618 /* pmlmepriv->LinkDetectInfo.TrafficBusyState = false; */
619 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
620 pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
621
622 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);
623
624 pwrctrlpriv->pwr_state_check_cnts = 0;
625
626 /* mlmeextpriv */
627 padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
628
629 rtw_set_signal_stat_timer(&padapter->recvpriv);
630
631 }
632
633
rtw_init_drv_sw(struct adapter * padapter)634 u8 rtw_init_drv_sw(struct adapter *padapter)
635 {
636 rtw_init_default_value(padapter);
637
638 rtw_init_hal_com_default_value(padapter);
639
640 if (rtw_init_cmd_priv(&padapter->cmdpriv))
641 return _FAIL;
642
643 padapter->cmdpriv.padapter = padapter;
644
645 if (rtw_init_evt_priv(&padapter->evtpriv))
646 goto free_cmd_priv;
647
648 if (rtw_init_mlme_priv(padapter) == _FAIL)
649 goto free_evt_priv;
650
651 init_mlme_ext_priv(padapter);
652
653 if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL)
654 goto free_mlme_ext;
655
656 if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL)
657 goto free_xmit_priv;
658 /* add for CONFIG_IEEE80211W, none 11w also can use */
659 spin_lock_init(&padapter->security_key_mutex);
660
661 /* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */
662 /* memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv)); */
663
664 if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL)
665 goto free_recv_priv;
666
667 padapter->stapriv.padapter = padapter;
668 padapter->setband = GHZ24_50;
669 padapter->fix_rate = 0xFF;
670 rtw_init_bcmc_stainfo(padapter);
671
672 rtw_init_pwrctrl_priv(padapter);
673
674 rtw_hal_dm_init(padapter);
675
676 return _SUCCESS;
677
678 free_recv_priv:
679 _rtw_free_recv_priv(&padapter->recvpriv);
680
681 free_xmit_priv:
682 _rtw_free_xmit_priv(&padapter->xmitpriv);
683
684 free_mlme_ext:
685 free_mlme_ext_priv(&padapter->mlmeextpriv);
686
687 rtw_free_mlme_priv(&padapter->mlmepriv);
688
689 free_evt_priv:
690 rtw_free_evt_priv(&padapter->evtpriv);
691
692 free_cmd_priv:
693 rtw_free_cmd_priv(&padapter->cmdpriv);
694
695 return _FAIL;
696 }
697
rtw_cancel_all_timer(struct adapter * padapter)698 void rtw_cancel_all_timer(struct adapter *padapter)
699 {
700 del_timer_sync(&padapter->mlmepriv.assoc_timer);
701
702 del_timer_sync(&padapter->mlmepriv.scan_to_timer);
703
704 del_timer_sync(&padapter->mlmepriv.dynamic_chk_timer);
705
706 del_timer_sync(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
707
708 del_timer_sync(&padapter->mlmepriv.set_scan_deny_timer);
709 rtw_clear_scan_deny(padapter);
710
711 del_timer_sync(&padapter->recvpriv.signal_stat_timer);
712
713 /* cancel dm timer */
714 rtw_hal_dm_deinit(padapter);
715 }
716
rtw_free_drv_sw(struct adapter * padapter)717 u8 rtw_free_drv_sw(struct adapter *padapter)
718 {
719 free_mlme_ext_priv(&padapter->mlmeextpriv);
720
721 rtw_free_cmd_priv(&padapter->cmdpriv);
722
723 rtw_free_evt_priv(&padapter->evtpriv);
724
725 rtw_free_mlme_priv(&padapter->mlmepriv);
726
727 /* free_io_queue(padapter); */
728
729 _rtw_free_xmit_priv(&padapter->xmitpriv);
730
731 _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
732
733 _rtw_free_recv_priv(&padapter->recvpriv);
734
735 rtw_free_pwrctrl_priv(padapter);
736
737 /* kfree((void *)padapter); */
738
739 rtw_hal_free_data(padapter);
740
741 /* free the old_pnetdev */
742 if (padapter->rereg_nd_name_priv.old_pnetdev) {
743 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
744 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
745 }
746
747 /* clear pbuddystruct adapter to avoid access wrong pointer. */
748 if (padapter->pbuddy_adapter)
749 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
750
751 return _SUCCESS;
752 }
753
_rtw_drv_register_netdev(struct adapter * padapter,char * name)754 static int _rtw_drv_register_netdev(struct adapter *padapter, char *name)
755 {
756 int ret = _SUCCESS;
757 struct net_device *pnetdev = padapter->pnetdev;
758
759 /* alloc netdev name */
760 if (rtw_init_netdev_name(pnetdev, name))
761 return _FAIL;
762
763 eth_hw_addr_set(pnetdev, padapter->eeprompriv.mac_addr);
764
765 /* Tell the network stack we exist */
766 if (register_netdev(pnetdev) != 0) {
767 ret = _FAIL;
768 goto error_register_netdev;
769 }
770
771 return ret;
772
773 error_register_netdev:
774
775 rtw_free_drv_sw(padapter);
776
777 rtw_free_netdev(pnetdev);
778
779 return ret;
780 }
781
rtw_drv_register_netdev(struct adapter * if1)782 int rtw_drv_register_netdev(struct adapter *if1)
783 {
784 struct dvobj_priv *dvobj = if1->dvobj;
785 struct adapter *padapter = dvobj->padapters;
786 char *name = if1->registrypriv.ifname;
787
788 return _rtw_drv_register_netdev(padapter, name);
789 }
790
_netdev_open(struct net_device * pnetdev)791 static int _netdev_open(struct net_device *pnetdev)
792 {
793 uint status;
794 struct adapter *padapter = rtw_netdev_priv(pnetdev);
795 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
796
797 padapter->netif_up = true;
798
799 if (pwrctrlpriv->ps_flag) {
800 padapter->net_closed = false;
801 goto netdev_open_normal_process;
802 }
803
804 if (!padapter->bup) {
805 padapter->bDriverStopped = false;
806 padapter->bSurpriseRemoved = false;
807 padapter->bCardDisableWOHSM = false;
808
809 status = rtw_hal_init(padapter);
810 if (status == _FAIL)
811 goto netdev_open_error;
812
813 status = rtw_start_drv_threads(padapter);
814 if (status == _FAIL)
815 goto netdev_open_error;
816
817 if (padapter->intf_start)
818 padapter->intf_start(padapter);
819
820 rtw_cfg80211_init_wiphy(padapter);
821
822 padapter->bup = true;
823 pwrctrlpriv->bips_processing = false;
824 }
825 padapter->net_closed = false;
826
827 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
828
829 if (!rtw_netif_queue_stopped(pnetdev))
830 rtw_netif_start_queue(pnetdev);
831 else
832 rtw_netif_wake_queue(pnetdev);
833
834 netdev_open_normal_process:
835
836 return 0;
837
838 netdev_open_error:
839
840 padapter->bup = false;
841
842 netif_carrier_off(pnetdev);
843 rtw_netif_stop_queue(pnetdev);
844
845 return (-1);
846 }
847
netdev_open(struct net_device * pnetdev)848 int netdev_open(struct net_device *pnetdev)
849 {
850 int ret;
851 struct adapter *padapter = rtw_netdev_priv(pnetdev);
852 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
853
854 if (pwrctrlpriv->bInSuspend)
855 return 0;
856
857 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)))
858 return -1;
859
860 ret = _netdev_open(pnetdev);
861 mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
862
863 return ret;
864 }
865
ips_netdrv_open(struct adapter * padapter)866 static int ips_netdrv_open(struct adapter *padapter)
867 {
868 int status = _SUCCESS;
869 /* struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); */
870
871 padapter->net_closed = false;
872
873 padapter->bDriverStopped = false;
874 padapter->bCardDisableWOHSM = false;
875 /* padapter->bup = true; */
876
877 status = rtw_hal_init(padapter);
878 if (status == _FAIL)
879 goto netdev_open_error;
880
881 if (padapter->intf_start)
882 padapter->intf_start(padapter);
883
884 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
885
886 return _SUCCESS;
887
888 netdev_open_error:
889
890 return _FAIL;
891 }
892
893
rtw_ips_pwr_up(struct adapter * padapter)894 int rtw_ips_pwr_up(struct adapter *padapter)
895 {
896 return ips_netdrv_open(padapter);
897 }
898
rtw_ips_pwr_down(struct adapter * padapter)899 void rtw_ips_pwr_down(struct adapter *padapter)
900 {
901 padapter->bCardDisableWOHSM = true;
902 padapter->net_closed = true;
903
904 rtw_ips_dev_unload(padapter);
905 padapter->bCardDisableWOHSM = false;
906 }
907
rtw_ips_dev_unload(struct adapter * padapter)908 void rtw_ips_dev_unload(struct adapter *padapter)
909 {
910
911 if (!padapter->bSurpriseRemoved)
912 rtw_hal_deinit(padapter);
913 }
914
pm_netdev_open(struct net_device * pnetdev,u8 bnormal)915 static int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
916 {
917 int status = -1;
918
919 struct adapter *padapter = rtw_netdev_priv(pnetdev);
920
921 if (bnormal) {
922 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)) == 0) {
923 status = _netdev_open(pnetdev);
924 mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
925 }
926 } else {
927 status = (_SUCCESS == ips_netdrv_open(padapter)) ? (0) : (-1);
928 }
929
930 return status;
931 }
932
netdev_close(struct net_device * pnetdev)933 static int netdev_close(struct net_device *pnetdev)
934 {
935 struct adapter *padapter = rtw_netdev_priv(pnetdev);
936 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
937
938 if (pwrctl->bInternalAutoSuspend) {
939 /* rtw_pwr_wakeup(padapter); */
940 if (pwrctl->rf_pwrstate == rf_off)
941 pwrctl->ps_flag = true;
942 }
943 padapter->net_closed = true;
944 padapter->netif_up = false;
945
946 /*if (!padapter->hw_init_completed)
947 {
948
949 padapter->bDriverStopped = true;
950
951 rtw_dev_unload(padapter);
952 }
953 else*/
954 if (pwrctl->rf_pwrstate == rf_on) {
955 /* s1. */
956 if (pnetdev) {
957 if (!rtw_netif_queue_stopped(pnetdev))
958 rtw_netif_stop_queue(pnetdev);
959 }
960
961 /* s2. */
962 LeaveAllPowerSaveMode(padapter);
963 rtw_disassoc_cmd(padapter, 500, false);
964 /* s2-2. indicate disconnect to os */
965 rtw_indicate_disconnect(padapter);
966 /* s2-3. */
967 rtw_free_assoc_resources(padapter, 1);
968 /* s2-4. */
969 rtw_free_network_queue(padapter, true);
970 }
971
972 rtw_scan_abort(padapter);
973 adapter_wdev_data(padapter)->bandroid_scan = false;
974
975 return 0;
976 }
977
rtw_ndev_destructor(struct net_device * ndev)978 void rtw_ndev_destructor(struct net_device *ndev)
979 {
980 kfree(ndev->ieee80211_ptr);
981 }
982
rtw_dev_unload(struct adapter * padapter)983 void rtw_dev_unload(struct adapter *padapter)
984 {
985 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
986 struct dvobj_priv *pobjpriv = padapter->dvobj;
987 struct debug_priv *pdbgpriv = &pobjpriv->drv_dbg;
988 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
989 u8 cnt = 0;
990
991 if (padapter->bup) {
992
993 padapter->bDriverStopped = true;
994 if (padapter->xmitpriv.ack_tx)
995 rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
996
997 if (padapter->intf_stop)
998 padapter->intf_stop(padapter);
999
1000 if (!pwrctl->bInternalAutoSuspend)
1001 rtw_stop_drv_threads(padapter);
1002
1003 while (atomic_read(&pcmdpriv->cmdthd_running)) {
1004 if (cnt > 5) {
1005 break;
1006 } else {
1007 cnt++;
1008 msleep(10);
1009 }
1010 }
1011
1012 /* check the status of IPS */
1013 if (rtw_hal_check_ips_status(padapter) || pwrctl->rf_pwrstate == rf_off) {
1014 /* check HW status and SW state */
1015 netdev_dbg(padapter->pnetdev,
1016 "%s: driver in IPS-FWLPS\n", __func__);
1017 pdbgpriv->dbg_dev_unload_inIPS_cnt++;
1018 LeaveAllPowerSaveMode(padapter);
1019 } else {
1020 netdev_dbg(padapter->pnetdev,
1021 "%s: driver not in IPS\n", __func__);
1022 }
1023
1024 if (!padapter->bSurpriseRemoved) {
1025 hal_btcoex_IpsNotify(padapter, pwrctl->ips_mode_req);
1026
1027 /* amy modify 20120221 for power seq is different between driver open and ips */
1028 rtw_hal_deinit(padapter);
1029
1030 padapter->bSurpriseRemoved = true;
1031 }
1032
1033 padapter->bup = false;
1034
1035 }
1036 }
1037
rtw_suspend_free_assoc_resource(struct adapter * padapter)1038 static int rtw_suspend_free_assoc_resource(struct adapter *padapter)
1039 {
1040 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1041
1042 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
1043 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
1044 && check_fwstate(pmlmepriv, _FW_LINKED)) {
1045 rtw_set_to_roam(padapter, 1);
1046 }
1047 }
1048
1049 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) {
1050 rtw_disassoc_cmd(padapter, 0, false);
1051 /* s2-2. indicate disconnect to os */
1052 rtw_indicate_disconnect(padapter);
1053 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1054 rtw_sta_flush(padapter);
1055 }
1056
1057 /* s2-3. */
1058 rtw_free_assoc_resources(padapter, 1);
1059
1060 /* s2-4. */
1061 rtw_free_network_queue(padapter, true);
1062
1063 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1064 rtw_indicate_scan_done(padapter, 1);
1065
1066 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1067 netdev_dbg(padapter->pnetdev, "%s: fw_under_linking\n",
1068 __func__);
1069 rtw_indicate_disconnect(padapter);
1070 }
1071
1072 return _SUCCESS;
1073 }
1074
rtw_suspend_normal(struct adapter * padapter)1075 static void rtw_suspend_normal(struct adapter *padapter)
1076 {
1077 struct net_device *pnetdev = padapter->pnetdev;
1078
1079 if (pnetdev) {
1080 netif_carrier_off(pnetdev);
1081 rtw_netif_stop_queue(pnetdev);
1082 }
1083
1084 rtw_suspend_free_assoc_resource(padapter);
1085
1086 if ((rtw_hal_check_ips_status(padapter)) || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off))
1087 netdev_dbg(padapter->pnetdev,
1088 "%s: ### ERROR #### driver in IPS ####ERROR###!!!\n",
1089 __func__);
1090
1091 rtw_dev_unload(padapter);
1092
1093 /* sdio_deinit(adapter_to_dvobj(padapter)); */
1094 if (padapter->intf_deinit)
1095 padapter->intf_deinit(adapter_to_dvobj(padapter));
1096 }
1097
rtw_suspend_common(struct adapter * padapter)1098 void rtw_suspend_common(struct adapter *padapter)
1099 {
1100 struct dvobj_priv *psdpriv = padapter->dvobj;
1101 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1102 struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
1103 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1104
1105 unsigned long start_time = jiffies;
1106
1107 netdev_dbg(padapter->pnetdev, " suspend start\n");
1108 pdbgpriv->dbg_suspend_cnt++;
1109
1110 pwrpriv->bInSuspend = true;
1111
1112 while (pwrpriv->bips_processing)
1113 msleep(1);
1114
1115 if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) {
1116 pdbgpriv->dbg_suspend_error_cnt++;
1117 goto exit;
1118 }
1119 rtw_ps_deny(padapter, PS_DENY_SUSPEND);
1120
1121 rtw_cancel_all_timer(padapter);
1122
1123 LeaveAllPowerSaveModeDirect(padapter);
1124
1125 rtw_stop_cmd_thread(padapter);
1126
1127 /* wait for the latest FW to remove this condition. */
1128 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
1129 hal_btcoex_SuspendNotify(padapter, 0);
1130 else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1131 hal_btcoex_SuspendNotify(padapter, 1);
1132
1133 rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
1134
1135 rtw_suspend_normal(padapter);
1136
1137 netdev_dbg(padapter->pnetdev, "rtw suspend success in %d ms\n",
1138 jiffies_to_msecs(jiffies - start_time));
1139
1140 exit:
1141
1142 return;
1143 }
1144
rtw_resume_process_normal(struct adapter * padapter)1145 static int rtw_resume_process_normal(struct adapter *padapter)
1146 {
1147 struct net_device *pnetdev;
1148 struct pwrctrl_priv *pwrpriv;
1149 struct mlme_priv *pmlmepriv;
1150 struct dvobj_priv *psdpriv;
1151 struct debug_priv *pdbgpriv;
1152
1153 int ret = _SUCCESS;
1154
1155 if (!padapter) {
1156 ret = -1;
1157 goto exit;
1158 }
1159
1160 pnetdev = padapter->pnetdev;
1161 pwrpriv = adapter_to_pwrctl(padapter);
1162 pmlmepriv = &padapter->mlmepriv;
1163 psdpriv = padapter->dvobj;
1164 pdbgpriv = &psdpriv->drv_dbg;
1165 /* interface init */
1166 /* if (sdio_init(adapter_to_dvobj(padapter)) != _SUCCESS) */
1167 if ((padapter->intf_init) && (padapter->intf_init(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1168 ret = -1;
1169 goto exit;
1170 }
1171 rtw_hal_disable_interrupt(padapter);
1172 /* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) */
1173 if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1174 ret = -1;
1175 goto exit;
1176 }
1177
1178 rtw_reset_drv_sw(padapter);
1179 pwrpriv->bkeepfwalive = false;
1180
1181 if (pm_netdev_open(pnetdev, true) != 0) {
1182 ret = -1;
1183 pdbgpriv->dbg_resume_error_cnt++;
1184 goto exit;
1185 }
1186
1187 netif_device_attach(pnetdev);
1188 netif_carrier_on(pnetdev);
1189
1190 if (padapter->pid[1] != 0)
1191 rtw_signal_process(padapter->pid[1], SIGUSR2);
1192
1193 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1194 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME))
1195 rtw_roaming(padapter, NULL);
1196 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1197 rtw_ap_restore_network(padapter);
1198 }
1199
1200 exit:
1201 return ret;
1202 }
1203
rtw_resume_common(struct adapter * padapter)1204 int rtw_resume_common(struct adapter *padapter)
1205 {
1206 int ret = 0;
1207 unsigned long start_time = jiffies;
1208 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1209
1210 netdev_dbg(padapter->pnetdev, "resume start\n");
1211
1212 rtw_resume_process_normal(padapter);
1213
1214 hal_btcoex_SuspendNotify(padapter, 0);
1215
1216 if (pwrpriv) {
1217 pwrpriv->bInSuspend = false;
1218 }
1219 netdev_dbg(padapter->pnetdev, "%s:%d in %d ms\n", __func__, ret,
1220 jiffies_to_msecs(jiffies - start_time));
1221
1222 return ret;
1223 }
1224