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
10MODULE_LICENSE("GPL");
11MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
12MODULE_AUTHOR("Realtek Semiconductor Corp.");
13MODULE_VERSION(DRIVERVERSION);
14
15/* module param defaults */
16static int rtw_chip_version;
17static int rtw_rfintfs = HWPI;
18static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
19
20
21static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure;infra, ad-hoc, auto */
22/* struct ndis_802_11_ssid ssid; */
23static int rtw_channel = 1;/* ad-hoc support requirement */
24static int rtw_wireless_mode = WIRELESS_11BG_24N;
25static int rtw_vrtl_carrier_sense = AUTO_VCS;
26static int rtw_vcs_type = RTS_CTS;/* */
27static int rtw_rts_thresh = 2347;/* */
28static int rtw_frag_thresh = 2346;/* */
29static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
30static int rtw_scan_mode = 1;/* active, passive */
31static int rtw_adhoc_tx_pwr = 1;
32static int rtw_soft_ap;
33/* int smart_ps = 1; */
34static int rtw_power_mgnt = 1;
35static int rtw_ips_mode = IPS_NORMAL;
36module_param(rtw_ips_mode, int, 0644);
37MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
38
39static int rtw_smart_ps = 2;
40
41static int rtw_check_fw_ps = 1;
42
43static int rtw_usb_rxagg_mode = 2;/* USB_RX_AGG_DMA = 1, USB_RX_AGG_USB =2 */
44module_param(rtw_usb_rxagg_mode, int, 0644);
45
46static int rtw_radio_enable = 1;
47static int rtw_long_retry_lmt = 7;
48static int rtw_short_retry_lmt = 7;
49static int rtw_busy_thresh = 40;
50/* int qos_enable = 0; */
51static int rtw_ack_policy = NORMAL_ACK;
52
53static int rtw_software_encrypt;
54static int rtw_software_decrypt;
55
56static int rtw_acm_method;/* 0:By SW 1:By HW. */
57
58static int rtw_wmm_enable = 1;/* default is set to enable the wmm. */
59static int rtw_uapsd_enable;
60static int rtw_uapsd_max_sp = NO_LIMIT;
61static int rtw_uapsd_acbk_en;
62static int rtw_uapsd_acbe_en;
63static int rtw_uapsd_acvi_en;
64static int rtw_uapsd_acvo_en;
65
66int 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 */
72static int rtw_bw_mode = 0x01;
73static 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) */
74static int rtw_rx_stbc = 1;/* 0: disable, 1:enable 2.4g */
75static 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 */
81static 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 */
83static 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 */
85static int rtw_stbc_cap = 0x13;
86/* BIT0: Enable VHT Beamformer, BIT1: Enable VHT Beamformee, BIT4: Enable HT Beamformer, BIT5: Enable HT Beamformee */
87static int rtw_beamform_cap = 0x2;
88
89static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
90
91static int rtw_low_power;
92static int rtw_wifi_spec;
93static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
94
95static int rtw_ant_num = -1; /* <0: undefined, >0: Antenna number */
96module_param(rtw_ant_num, int, 0644);
97MODULE_PARM_DESC(rtw_ant_num, "Antenna number setting");
98
99static int rtw_antdiv_cfg = 1; /* 0:OFF , 1:ON, 2:decide by Efuse config */
100static 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
104static int rtw_hw_wps_pbc;
105
106int rtw_mc2u_disable;
107
108static int rtw_80211d;
109
110static int rtw_qos_opt_enable;/* 0: disable, 1:enable */
111module_param(rtw_qos_opt_enable, int, 0644);
112
113static char *ifname = "wlan%d";
114module_param(ifname, charp, 0644);
115MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
116
117char *rtw_initmac; /* temp mac address if users want to use instead of the mac address in Efuse */
118
119module_param(rtw_initmac, charp, 0644);
120module_param(rtw_channel_plan, int, 0644);
121module_param(rtw_chip_version, int, 0644);
122module_param(rtw_rfintfs, int, 0644);
123module_param(rtw_lbkmode, int, 0644);
124module_param(rtw_network_mode, int, 0644);
125module_param(rtw_channel, int, 0644);
126module_param(rtw_wmm_enable, int, 0644);
127module_param(rtw_vrtl_carrier_sense, int, 0644);
128module_param(rtw_vcs_type, int, 0644);
129module_param(rtw_busy_thresh, int, 0644);
130
131module_param(rtw_ht_enable, int, 0644);
132module_param(rtw_bw_mode, int, 0644);
133module_param(rtw_ampdu_enable, int, 0644);
134module_param(rtw_rx_stbc, int, 0644);
135module_param(rtw_ampdu_amsdu, int, 0644);
136
137module_param(rtw_lowrate_two_xmit, int, 0644);
138
139module_param(rtw_power_mgnt, int, 0644);
140module_param(rtw_smart_ps, int, 0644);
141module_param(rtw_low_power, int, 0644);
142module_param(rtw_wifi_spec, int, 0644);
143
144module_param(rtw_antdiv_cfg, int, 0644);
145module_param(rtw_antdiv_type, int, 0644);
146
147
148module_param(rtw_hw_wps_pbc, int, 0644);
149
150static uint rtw_max_roaming_times = 2;
151module_param(rtw_max_roaming_times, uint, 0644);
152MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
153
154module_param(rtw_mc2u_disable, int, 0644);
155
156module_param(rtw_80211d, int, 0644);
157MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
158
159static uint rtw_notch_filter;
160module_param(rtw_notch_filter, uint, 0644);
161MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
162
163#define CONFIG_RTW_HIQ_FILTER 1
164
165static uint rtw_hiq_filter = CONFIG_RTW_HIQ_FILTER;
166module_param(rtw_hiq_filter, uint, 0644);
167MODULE_PARM_DESC(rtw_hiq_filter, "0:allow all, 1:allow special, 2:deny all");
168
169static int rtw_tx_pwr_lmt_enable;
170static int rtw_tx_pwr_by_rate;
171
172module_param(rtw_tx_pwr_lmt_enable, int, 0644);
173MODULE_PARM_DESC(rtw_tx_pwr_lmt_enable, "0:Disable, 1:Enable, 2: Depend on efuse");
174
175module_param(rtw_tx_pwr_by_rate, int, 0644);
176MODULE_PARM_DESC(rtw_tx_pwr_by_rate, "0:Disable, 1:Enable, 2: Depend on efuse");
177
178static int netdev_close(struct net_device *pnetdev);
179
180static 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(buf: registry_par->ifname, size: 16, fmt: "%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
277static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
278{
279 struct adapter *padapter = rtw_netdev_priv(netdev: 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
292static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
293{
294 struct adapter *padapter = rtw_netdev_priv(netdev: 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 */
316static 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. */
319static 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
343static 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(netdev: 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(acm_mask: pmlmepriv->acm_mask, priority: skb->priority);
353
354 return rtw_1d_to_queue[skb->priority];
355}
356
357u16 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(&eth_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
384static int rtw_ndev_init(struct net_device *dev)
385{
386 struct adapter *adapter = rtw_netdev_priv(netdev: 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
394static void rtw_ndev_uninit(struct net_device *dev)
395{
396 struct adapter *adapter = rtw_netdev_priv(netdev: dev);
397
398 netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
399}
400
401static 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
412int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
413{
414 if (dev_alloc_name(dev: pnetdev, name: ifname) < 0) {
415 pr_err("dev_alloc_name, fail for %s\n", ifname);
416 return 1;
417 }
418 netif_carrier_off(dev: pnetdev);
419 /* rtw_netif_stop_queue(pnetdev); */
420
421 return 0;
422}
423
424struct 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_priv: sizeof(struct adapter), old_priv: (void *)old_padapter);
431 else
432 pnetdev = rtw_alloc_etherdev(sizeof_priv: sizeof(struct adapter));
433
434 pr_info("pnetdev = %p\n", pnetdev);
435 if (!pnetdev)
436 return NULL;
437
438 padapter = rtw_netdev_priv(netdev: 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
454void 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(dev: pnetdev); /* will call netdev_close() */
468 rtw_wdev_unregister(wdev: padapter->rtw_wdev);
469}
470
471u32 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(ptr: padapter->xmitThread))
477 _status = _FAIL;
478
479 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
480 if (IS_ERR(ptr: 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
489void rtw_stop_drv_threads(struct adapter *padapter)
490{
491 rtw_stop_cmd_thread(adapter: 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
500static 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(adapter: padapter);
544 rtw_update_registrypriv_dev_network(adapter: 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
562struct 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(v: &pdvobj->disable_func, i: 0);
582
583 spin_lock_init(&pdvobj->cam_ctl.lock);
584
585 return pdvobj;
586}
587
588void devobj_deinit(struct dvobj_priv *pdvobj)
589{
590 if (!pdvobj)
591 return;
592
593 mutex_destroy(lock: &pdvobj->hw_init_mutex);
594 mutex_destroy(lock: &pdvobj->h2c_fwcmd_mutex);
595 mutex_destroy(lock: &pdvobj->setch_mutex);
596 mutex_destroy(lock: &pdvobj->setbw_mutex);
597
598 kfree(objp: pdvobj);
599}
600
601void 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
634u8 rtw_init_drv_sw(struct adapter *padapter)
635{
636 rtw_init_default_value(padapter);
637
638 rtw_init_hal_com_default_value(Adapter: padapter);
639
640 if (rtw_init_cmd_priv(pcmdpriv: &padapter->cmdpriv))
641 return _FAIL;
642
643 padapter->cmdpriv.padapter = padapter;
644
645 if (rtw_init_evt_priv(pevtpriv: &padapter->evtpriv))
646 goto free_cmd_priv;
647
648 if (rtw_init_mlme_priv(adapter: padapter) == _FAIL)
649 goto free_evt_priv;
650
651 init_mlme_ext_priv(padapter);
652
653 if (_rtw_init_xmit_priv(pxmitpriv: &padapter->xmitpriv, padapter) == _FAIL)
654 goto free_mlme_ext;
655
656 if (_rtw_init_recv_priv(precvpriv: &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(pstapriv: &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(adapter: padapter);
673
674 rtw_hal_dm_init(padapter);
675
676 return _SUCCESS;
677
678free_recv_priv:
679 _rtw_free_recv_priv(precvpriv: &padapter->recvpriv);
680
681free_xmit_priv:
682 _rtw_free_xmit_priv(pxmitpriv: &padapter->xmitpriv);
683
684free_mlme_ext:
685 free_mlme_ext_priv(pmlmeext: &padapter->mlmeextpriv);
686
687 rtw_free_mlme_priv(pmlmepriv: &padapter->mlmepriv);
688
689free_evt_priv:
690 rtw_free_evt_priv(pevtpriv: &padapter->evtpriv);
691
692free_cmd_priv:
693 rtw_free_cmd_priv(pcmdpriv: &padapter->cmdpriv);
694
695 return _FAIL;
696}
697
698void rtw_cancel_all_timer(struct adapter *padapter)
699{
700 timer_delete_sync(timer: &padapter->mlmepriv.assoc_timer);
701
702 timer_delete_sync(timer: &padapter->mlmepriv.scan_to_timer);
703
704 timer_delete_sync(timer: &padapter->mlmepriv.dynamic_chk_timer);
705
706 timer_delete_sync(timer: &(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
707
708 timer_delete_sync(timer: &padapter->mlmepriv.set_scan_deny_timer);
709 rtw_clear_scan_deny(adapter: padapter);
710
711 timer_delete_sync(timer: &padapter->recvpriv.signal_stat_timer);
712
713 /* cancel dm timer */
714 rtw_hal_dm_deinit(padapter);
715}
716
717u8 rtw_free_drv_sw(struct adapter *padapter)
718{
719 free_mlme_ext_priv(pmlmeext: &padapter->mlmeextpriv);
720
721 rtw_free_cmd_priv(pcmdpriv: &padapter->cmdpriv);
722
723 rtw_free_evt_priv(pevtpriv: &padapter->evtpriv);
724
725 rtw_free_mlme_priv(pmlmepriv: &padapter->mlmepriv);
726
727 _rtw_free_xmit_priv(pxmitpriv: &padapter->xmitpriv);
728
729 _rtw_free_sta_priv(pstapriv: &padapter->stapriv); /* will free bcmc_stainfo here */
730
731 _rtw_free_recv_priv(precvpriv: &padapter->recvpriv);
732
733 rtw_free_pwrctrl_priv(adapter: 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(dev: 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
752static 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, ifname: name))
759 return _FAIL;
760
761 eth_hw_addr_set(dev: pnetdev, addr: padapter->eeprompriv.mac_addr);
762
763 /* Tell the network stack we exist */
764 if (register_netdev(dev: pnetdev) != 0) {
765 ret = _FAIL;
766 goto error_register_netdev;
767 }
768
769 return ret;
770
771error_register_netdev:
772
773 rtw_free_drv_sw(padapter);
774
775 rtw_free_netdev(netdev: pnetdev);
776
777 return ret;
778}
779
780int 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
789static int _netdev_open(struct net_device *pnetdev)
790{
791 uint status;
792 struct adapter *padapter = rtw_netdev_priv(netdev: 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(ptimer: &padapter->mlmepriv.dynamic_chk_timer, delay_time: 2000);
826
827 if (!rtw_netif_queue_stopped(pnetdev))
828 rtw_netif_start_queue(pnetdev);
829 else
830 rtw_netif_wake_queue(pnetdev);
831
832netdev_open_normal_process:
833
834 return 0;
835
836netdev_open_error:
837
838 padapter->bup = false;
839
840 netif_carrier_off(dev: pnetdev);
841 rtw_netif_stop_queue(pnetdev);
842
843 return (-1);
844}
845
846int netdev_open(struct net_device *pnetdev)
847{
848 int ret;
849 struct adapter *padapter = rtw_netdev_priv(netdev: 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(lock: &(adapter_to_dvobj(padapter)->hw_init_mutex));
860
861 return ret;
862}
863
864static 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(ptimer: &padapter->mlmepriv.dynamic_chk_timer, delay_time: 2000);
883
884 return _SUCCESS;
885
886netdev_open_error:
887
888 return _FAIL;
889}
890
891
892int rtw_ips_pwr_up(struct adapter *padapter)
893{
894 return ips_netdrv_open(padapter);
895}
896
897void 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
906void rtw_ips_dev_unload(struct adapter *padapter)
907{
908
909 if (!padapter->bSurpriseRemoved)
910 rtw_hal_deinit(padapter);
911}
912
913static int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
914{
915 int status = -1;
916
917 struct adapter *padapter = rtw_netdev_priv(netdev: 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(lock: &(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
931static int netdev_close(struct net_device *pnetdev)
932{
933 struct adapter *padapter = rtw_netdev_priv(netdev: 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(Adapter: padapter);
961 rtw_disassoc_cmd(padapter, deauth_timeout_ms: 500, enqueue: false);
962 /* s2-2. indicate disconnect to os */
963 rtw_indicate_disconnect(adapter: padapter);
964 /* s2-3. */
965 rtw_free_assoc_resources(adapter: padapter, lock_scanned_queue: 1);
966 /* s2-4. */
967 rtw_free_network_queue(adapter: padapter, isfreeall: true);
968 }
969
970 rtw_scan_abort(adapter: padapter);
971 adapter_wdev_data(padapter)->bandroid_scan = false;
972
973 return 0;
974}
975
976void rtw_ndev_destructor(struct net_device *ndev)
977{
978 kfree(objp: ndev->ieee80211_ptr);
979}
980
981void 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(pxmitpriv: &padapter->xmitpriv, status: 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(v: &pcmdpriv->cmdthd_running)) {
1002 if (cnt > 5) {
1003 break;
1004 } else {
1005 cnt++;
1006 msleep(msecs: 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(Adapter: 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, type: 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
1036static 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(adapter: padapter, to_roam: 1);
1044 }
1045 }
1046
1047 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) {
1048 rtw_disassoc_cmd(padapter, deauth_timeout_ms: 0, enqueue: false);
1049 /* s2-2. indicate disconnect to os */
1050 rtw_indicate_disconnect(adapter: 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(adapter: padapter, lock_scanned_queue: 1);
1057
1058 /* s2-4. */
1059 rtw_free_network_queue(adapter: padapter, isfreeall: true);
1060
1061 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1062 rtw_indicate_scan_done(padapter, aborted: 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(adapter: padapter);
1068 }
1069
1070 return _SUCCESS;
1071}
1072
1073static void rtw_suspend_normal(struct adapter *padapter)
1074{
1075 struct net_device *pnetdev = padapter->pnetdev;
1076
1077 if (pnetdev) {
1078 netif_carrier_off(dev: 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
1096void 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(msecs: 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, reason: PS_DENY_SUSPEND);
1118
1119 rtw_cancel_all_timer(padapter);
1120
1121 LeaveAllPowerSaveModeDirect(Adapter: padapter);
1122
1123 rtw_stop_cmd_thread(adapter: 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, state: 0);
1128 else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1129 hal_btcoex_SuspendNotify(padapter, state: 1);
1130
1131 rtw_ps_deny_cancel(padapter, reason: 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
1138exit:
1139
1140 return;
1141}
1142
1143static 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, bnormal: true) != 0) {
1180 ret = -1;
1181 pdbgpriv->dbg_resume_error_cnt++;
1182 goto exit;
1183 }
1184
1185 netif_device_attach(dev: pnetdev);
1186 netif_carrier_on(dev: 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(adapter: padapter, NULL);
1194 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1195 rtw_ap_restore_network(padapter);
1196 }
1197
1198exit:
1199 return ret;
1200}
1201
1202int 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, state: 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

Provided by KDAB

Privacy Policy
Improve your Profiling and Debugging skills
Find out more

source code of linux/drivers/staging/rtl8723bs/os_dep/os_intfs.c