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