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 timer_delete_sync(&padapter->mlmepriv.assoc_timer);
701
702 timer_delete_sync(&padapter->mlmepriv.scan_to_timer);
703
704 timer_delete_sync(&padapter->mlmepriv.dynamic_chk_timer);
705
706 timer_delete_sync(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
707
708 timer_delete_sync(&padapter->mlmepriv.set_scan_deny_timer);
709 rtw_clear_scan_deny(padapter);
710
711 timer_delete_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 _rtw_free_xmit_priv(&padapter->xmitpriv);
728
729 _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
730
731 _rtw_free_recv_priv(&padapter->recvpriv);
732
733 rtw_free_pwrctrl_priv(padapter);
734
735 /* kfree((void *)padapter); */
736
737 rtw_hal_free_data(padapter);
738
739 /* free the old_pnetdev */
740 if (padapter->rereg_nd_name_priv.old_pnetdev) {
741 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
742 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
743 }
744
745 /* clear pbuddystruct adapter to avoid access wrong pointer. */
746 if (padapter->pbuddy_adapter)
747 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
748
749 return _SUCCESS;
750 }
751
_rtw_drv_register_netdev(struct adapter * padapter,char * name)752 static int _rtw_drv_register_netdev(struct adapter *padapter, char *name)
753 {
754 int ret = _SUCCESS;
755 struct net_device *pnetdev = padapter->pnetdev;
756
757 /* alloc netdev name */
758 if (rtw_init_netdev_name(pnetdev, name))
759 return _FAIL;
760
761 eth_hw_addr_set(pnetdev, padapter->eeprompriv.mac_addr);
762
763 /* Tell the network stack we exist */
764 if (register_netdev(pnetdev) != 0) {
765 ret = _FAIL;
766 goto error_register_netdev;
767 }
768
769 return ret;
770
771 error_register_netdev:
772
773 rtw_free_drv_sw(padapter);
774
775 rtw_free_netdev(pnetdev);
776
777 return ret;
778 }
779
rtw_drv_register_netdev(struct adapter * if1)780 int rtw_drv_register_netdev(struct adapter *if1)
781 {
782 struct dvobj_priv *dvobj = if1->dvobj;
783 struct adapter *padapter = dvobj->padapters;
784 char *name = if1->registrypriv.ifname;
785
786 return _rtw_drv_register_netdev(padapter, name);
787 }
788
_netdev_open(struct net_device * pnetdev)789 static int _netdev_open(struct net_device *pnetdev)
790 {
791 uint status;
792 struct adapter *padapter = rtw_netdev_priv(pnetdev);
793 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
794
795 padapter->netif_up = true;
796
797 if (pwrctrlpriv->ps_flag) {
798 padapter->net_closed = false;
799 goto netdev_open_normal_process;
800 }
801
802 if (!padapter->bup) {
803 padapter->bDriverStopped = false;
804 padapter->bSurpriseRemoved = false;
805 padapter->bCardDisableWOHSM = false;
806
807 status = rtw_hal_init(padapter);
808 if (status == _FAIL)
809 goto netdev_open_error;
810
811 status = rtw_start_drv_threads(padapter);
812 if (status == _FAIL)
813 goto netdev_open_error;
814
815 if (padapter->intf_start)
816 padapter->intf_start(padapter);
817
818 rtw_cfg80211_init_wiphy(padapter);
819
820 padapter->bup = true;
821 pwrctrlpriv->bips_processing = false;
822 }
823 padapter->net_closed = false;
824
825 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
826
827 if (!rtw_netif_queue_stopped(pnetdev))
828 rtw_netif_start_queue(pnetdev);
829 else
830 rtw_netif_wake_queue(pnetdev);
831
832 netdev_open_normal_process:
833
834 return 0;
835
836 netdev_open_error:
837
838 padapter->bup = false;
839
840 netif_carrier_off(pnetdev);
841 rtw_netif_stop_queue(pnetdev);
842
843 return (-1);
844 }
845
netdev_open(struct net_device * pnetdev)846 int netdev_open(struct net_device *pnetdev)
847 {
848 int ret;
849 struct adapter *padapter = rtw_netdev_priv(pnetdev);
850 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
851
852 if (pwrctrlpriv->bInSuspend)
853 return 0;
854
855 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)))
856 return -1;
857
858 ret = _netdev_open(pnetdev);
859 mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
860
861 return ret;
862 }
863
ips_netdrv_open(struct adapter * padapter)864 static int ips_netdrv_open(struct adapter *padapter)
865 {
866 int status = _SUCCESS;
867 /* struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); */
868
869 padapter->net_closed = false;
870
871 padapter->bDriverStopped = false;
872 padapter->bCardDisableWOHSM = false;
873 /* padapter->bup = true; */
874
875 status = rtw_hal_init(padapter);
876 if (status == _FAIL)
877 goto netdev_open_error;
878
879 if (padapter->intf_start)
880 padapter->intf_start(padapter);
881
882 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
883
884 return _SUCCESS;
885
886 netdev_open_error:
887
888 return _FAIL;
889 }
890
891
rtw_ips_pwr_up(struct adapter * padapter)892 int rtw_ips_pwr_up(struct adapter *padapter)
893 {
894 return ips_netdrv_open(padapter);
895 }
896
rtw_ips_pwr_down(struct adapter * padapter)897 void rtw_ips_pwr_down(struct adapter *padapter)
898 {
899 padapter->bCardDisableWOHSM = true;
900 padapter->net_closed = true;
901
902 rtw_ips_dev_unload(padapter);
903 padapter->bCardDisableWOHSM = false;
904 }
905
rtw_ips_dev_unload(struct adapter * padapter)906 void rtw_ips_dev_unload(struct adapter *padapter)
907 {
908
909 if (!padapter->bSurpriseRemoved)
910 rtw_hal_deinit(padapter);
911 }
912
pm_netdev_open(struct net_device * pnetdev,u8 bnormal)913 static int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
914 {
915 int status = -1;
916
917 struct adapter *padapter = rtw_netdev_priv(pnetdev);
918
919 if (bnormal) {
920 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)) == 0) {
921 status = _netdev_open(pnetdev);
922 mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
923 }
924 } else {
925 status = (_SUCCESS == ips_netdrv_open(padapter)) ? (0) : (-1);
926 }
927
928 return status;
929 }
930
netdev_close(struct net_device * pnetdev)931 static int netdev_close(struct net_device *pnetdev)
932 {
933 struct adapter *padapter = rtw_netdev_priv(pnetdev);
934 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
935
936 if (pwrctl->bInternalAutoSuspend) {
937 /* rtw_pwr_wakeup(padapter); */
938 if (pwrctl->rf_pwrstate == rf_off)
939 pwrctl->ps_flag = true;
940 }
941 padapter->net_closed = true;
942 padapter->netif_up = false;
943
944 /*if (!padapter->hw_init_completed)
945 {
946
947 padapter->bDriverStopped = true;
948
949 rtw_dev_unload(padapter);
950 }
951 else*/
952 if (pwrctl->rf_pwrstate == rf_on) {
953 /* s1. */
954 if (pnetdev) {
955 if (!rtw_netif_queue_stopped(pnetdev))
956 rtw_netif_stop_queue(pnetdev);
957 }
958
959 /* s2. */
960 LeaveAllPowerSaveMode(padapter);
961 rtw_disassoc_cmd(padapter, 500, false);
962 /* s2-2. indicate disconnect to os */
963 rtw_indicate_disconnect(padapter);
964 /* s2-3. */
965 rtw_free_assoc_resources(padapter, 1);
966 /* s2-4. */
967 rtw_free_network_queue(padapter, true);
968 }
969
970 rtw_scan_abort(padapter);
971 adapter_wdev_data(padapter)->bandroid_scan = false;
972
973 return 0;
974 }
975
rtw_ndev_destructor(struct net_device * ndev)976 void rtw_ndev_destructor(struct net_device *ndev)
977 {
978 kfree(ndev->ieee80211_ptr);
979 }
980
rtw_dev_unload(struct adapter * padapter)981 void rtw_dev_unload(struct adapter *padapter)
982 {
983 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
984 struct dvobj_priv *pobjpriv = padapter->dvobj;
985 struct debug_priv *pdbgpriv = &pobjpriv->drv_dbg;
986 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
987 u8 cnt = 0;
988
989 if (padapter->bup) {
990
991 padapter->bDriverStopped = true;
992 if (padapter->xmitpriv.ack_tx)
993 rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
994
995 if (padapter->intf_stop)
996 padapter->intf_stop(padapter);
997
998 if (!pwrctl->bInternalAutoSuspend)
999 rtw_stop_drv_threads(padapter);
1000
1001 while (atomic_read(&pcmdpriv->cmdthd_running)) {
1002 if (cnt > 5) {
1003 break;
1004 } else {
1005 cnt++;
1006 msleep(10);
1007 }
1008 }
1009
1010 /* check the status of IPS */
1011 if (rtw_hal_check_ips_status(padapter) || pwrctl->rf_pwrstate == rf_off) {
1012 /* check HW status and SW state */
1013 netdev_dbg(padapter->pnetdev,
1014 "%s: driver in IPS-FWLPS\n", __func__);
1015 pdbgpriv->dbg_dev_unload_inIPS_cnt++;
1016 LeaveAllPowerSaveMode(padapter);
1017 } else {
1018 netdev_dbg(padapter->pnetdev,
1019 "%s: driver not in IPS\n", __func__);
1020 }
1021
1022 if (!padapter->bSurpriseRemoved) {
1023 hal_btcoex_IpsNotify(padapter, pwrctl->ips_mode_req);
1024
1025 /* amy modify 20120221 for power seq is different between driver open and ips */
1026 rtw_hal_deinit(padapter);
1027
1028 padapter->bSurpriseRemoved = true;
1029 }
1030
1031 padapter->bup = false;
1032
1033 }
1034 }
1035
rtw_suspend_free_assoc_resource(struct adapter * padapter)1036 static int rtw_suspend_free_assoc_resource(struct adapter *padapter)
1037 {
1038 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1039
1040 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
1041 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
1042 && check_fwstate(pmlmepriv, _FW_LINKED)) {
1043 rtw_set_to_roam(padapter, 1);
1044 }
1045 }
1046
1047 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) {
1048 rtw_disassoc_cmd(padapter, 0, false);
1049 /* s2-2. indicate disconnect to os */
1050 rtw_indicate_disconnect(padapter);
1051 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1052 rtw_sta_flush(padapter);
1053 }
1054
1055 /* s2-3. */
1056 rtw_free_assoc_resources(padapter, 1);
1057
1058 /* s2-4. */
1059 rtw_free_network_queue(padapter, true);
1060
1061 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1062 rtw_indicate_scan_done(padapter, 1);
1063
1064 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1065 netdev_dbg(padapter->pnetdev, "%s: fw_under_linking\n",
1066 __func__);
1067 rtw_indicate_disconnect(padapter);
1068 }
1069
1070 return _SUCCESS;
1071 }
1072
rtw_suspend_normal(struct adapter * padapter)1073 static void rtw_suspend_normal(struct adapter *padapter)
1074 {
1075 struct net_device *pnetdev = padapter->pnetdev;
1076
1077 if (pnetdev) {
1078 netif_carrier_off(pnetdev);
1079 rtw_netif_stop_queue(pnetdev);
1080 }
1081
1082 rtw_suspend_free_assoc_resource(padapter);
1083
1084 if ((rtw_hal_check_ips_status(padapter)) || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off))
1085 netdev_dbg(padapter->pnetdev,
1086 "%s: ### ERROR #### driver in IPS ####ERROR###!!!\n",
1087 __func__);
1088
1089 rtw_dev_unload(padapter);
1090
1091 /* sdio_deinit(adapter_to_dvobj(padapter)); */
1092 if (padapter->intf_deinit)
1093 padapter->intf_deinit(adapter_to_dvobj(padapter));
1094 }
1095
rtw_suspend_common(struct adapter * padapter)1096 void rtw_suspend_common(struct adapter *padapter)
1097 {
1098 struct dvobj_priv *psdpriv = padapter->dvobj;
1099 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1100 struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
1101 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1102
1103 unsigned long start_time = jiffies;
1104
1105 netdev_dbg(padapter->pnetdev, " suspend start\n");
1106 pdbgpriv->dbg_suspend_cnt++;
1107
1108 pwrpriv->bInSuspend = true;
1109
1110 while (pwrpriv->bips_processing)
1111 msleep(1);
1112
1113 if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) {
1114 pdbgpriv->dbg_suspend_error_cnt++;
1115 goto exit;
1116 }
1117 rtw_ps_deny(padapter, PS_DENY_SUSPEND);
1118
1119 rtw_cancel_all_timer(padapter);
1120
1121 LeaveAllPowerSaveModeDirect(padapter);
1122
1123 rtw_stop_cmd_thread(padapter);
1124
1125 /* wait for the latest FW to remove this condition. */
1126 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
1127 hal_btcoex_SuspendNotify(padapter, 0);
1128 else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1129 hal_btcoex_SuspendNotify(padapter, 1);
1130
1131 rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
1132
1133 rtw_suspend_normal(padapter);
1134
1135 netdev_dbg(padapter->pnetdev, "rtw suspend success in %d ms\n",
1136 jiffies_to_msecs(jiffies - start_time));
1137
1138 exit:
1139
1140 return;
1141 }
1142
rtw_resume_process_normal(struct adapter * padapter)1143 static int rtw_resume_process_normal(struct adapter *padapter)
1144 {
1145 struct net_device *pnetdev;
1146 struct pwrctrl_priv *pwrpriv;
1147 struct mlme_priv *pmlmepriv;
1148 struct dvobj_priv *psdpriv;
1149 struct debug_priv *pdbgpriv;
1150
1151 int ret = _SUCCESS;
1152
1153 if (!padapter) {
1154 ret = -1;
1155 goto exit;
1156 }
1157
1158 pnetdev = padapter->pnetdev;
1159 pwrpriv = adapter_to_pwrctl(padapter);
1160 pmlmepriv = &padapter->mlmepriv;
1161 psdpriv = padapter->dvobj;
1162 pdbgpriv = &psdpriv->drv_dbg;
1163 /* interface init */
1164 /* if (sdio_init(adapter_to_dvobj(padapter)) != _SUCCESS) */
1165 if ((padapter->intf_init) && (padapter->intf_init(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1166 ret = -1;
1167 goto exit;
1168 }
1169 rtw_hal_disable_interrupt(padapter);
1170 /* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) */
1171 if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1172 ret = -1;
1173 goto exit;
1174 }
1175
1176 rtw_reset_drv_sw(padapter);
1177 pwrpriv->bkeepfwalive = false;
1178
1179 if (pm_netdev_open(pnetdev, true) != 0) {
1180 ret = -1;
1181 pdbgpriv->dbg_resume_error_cnt++;
1182 goto exit;
1183 }
1184
1185 netif_device_attach(pnetdev);
1186 netif_carrier_on(pnetdev);
1187
1188 if (padapter->pid[1] != 0)
1189 rtw_signal_process(padapter->pid[1], SIGUSR2);
1190
1191 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1192 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME))
1193 rtw_roaming(padapter, NULL);
1194 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1195 rtw_ap_restore_network(padapter);
1196 }
1197
1198 exit:
1199 return ret;
1200 }
1201
rtw_resume_common(struct adapter * padapter)1202 int rtw_resume_common(struct adapter *padapter)
1203 {
1204 int ret = 0;
1205 unsigned long start_time = jiffies;
1206 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1207
1208 netdev_dbg(padapter->pnetdev, "resume start\n");
1209
1210 rtw_resume_process_normal(padapter);
1211
1212 hal_btcoex_SuspendNotify(padapter, 0);
1213
1214 if (pwrpriv) {
1215 pwrpriv->bInSuspend = false;
1216 }
1217 netdev_dbg(padapter->pnetdev, "%s:%d in %d ms\n", __func__, ret,
1218 jiffies_to_msecs(jiffies - start_time));
1219
1220 return ret;
1221 }
1222