1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 *
19 ******************************************************************************/
20 #define _OS_INTFS_C_
21
22 #include <osdep_service.h>
23 #include <osdep_intf.h>
24 #include <drv_types.h>
25 #include <xmit_osdep.h>
26 #include <recv_osdep.h>
27 #include <hal_intf.h>
28 #include <rtw_ioctl.h>
29 #include <rtl8188e_hal.h>
30
31 #include <usb_hal.h>
32
33 MODULE_LICENSE("GPL");
34 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
35 MODULE_AUTHOR("Realtek Semiconductor Corp.");
36 MODULE_VERSION(DRIVERVERSION);
37
38 #define RTW_NOTCH_FILTER 0 /* 0:Disable, 1:Enable, */
39
40 /* module param defaults */
41 static int rtw_chip_version;
42 static int rtw_rfintfs = HWPI;
43 static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
44 static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure; infra, ad-hoc, auto */
45 static int rtw_channel = 1;/* ad-hoc support requirement */
46 static int rtw_wireless_mode = WIRELESS_11BG_24N;
47 static int rtw_vrtl_carrier_sense = AUTO_VCS;
48 static int rtw_vcs_type = RTS_CTS;/* */
49 static int rtw_rts_thresh = 2347;/* */
50 static int rtw_frag_thresh = 2346;/* */
51 static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
52 static int rtw_scan_mode = 1;/* active, passive */
53 static int rtw_adhoc_tx_pwr = 1;
54 static int rtw_soft_ap;
55 static int rtw_power_mgnt = 1;
56 static int rtw_ips_mode = IPS_NORMAL;
57
58 static int rtw_smart_ps = 2;
59
60 module_param(rtw_ips_mode, int, 0644);
61 MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
62
63 static int rtw_debug = 1;
64 static int rtw_radio_enable = 1;
65 static int rtw_long_retry_lmt = 7;
66 static int rtw_short_retry_lmt = 7;
67 static int rtw_busy_thresh = 40;
68 static int rtw_ack_policy = NORMAL_ACK;
69
70 static int rtw_software_encrypt;
71 static int rtw_software_decrypt;
72
73 static int rtw_acm_method;/* 0:By SW 1:By HW. */
74
75 static int rtw_wmm_enable = 1;/* default is set to enable the wmm. */
76 static int rtw_uapsd_enable;
77 static int rtw_uapsd_max_sp = NO_LIMIT;
78 static int rtw_uapsd_acbk_en;
79 static int rtw_uapsd_acbe_en;
80 static int rtw_uapsd_acvi_en;
81 static int rtw_uapsd_acvo_en;
82
83 static int rtw_ht_enable = 1;
84 static int rtw_cbw40_enable = 3; /* 0 :disable, bit(0): enable 2.4g, bit(1): enable 5g */
85 static int rtw_ampdu_enable = 1;/* for enable tx_ampdu */
86 static int rtw_rx_stbc = 1;/* 0: disable, bit(0):enable 2.4g, bit(1):enable 5g, default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ */
87 static int rtw_ampdu_amsdu;/* 0: disabled, 1:enabled, 2:auto */
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_rf_config = RF_819X_MAX_TYPE; /* auto */
92 static int rtw_low_power;
93 static int rtw_wifi_spec;
94 static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
95 static int rtw_AcceptAddbaReq = true;/* 0:Reject AP's Add BA req, 1:Accept AP's Add BA req. */
96
97 static int rtw_antdiv_cfg = 2; /* 0:OFF , 1:ON, 2:decide by Efuse config */
98 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) */
99
100 static int rtw_enusbss;/* 0:disable, 1:enable */
101
102 static int rtw_hwpdn_mode = 2;/* 0:disable, 1:enable, 2: by EFUSE config */
103
104 static int rtw_hwpwrp_detect; /* HW power ping detect 0:disable , 1:enable */
105
106 static int rtw_hw_wps_pbc = 1;
107
108 int rtw_mc2u_disable;
109
110 static int rtw_80211d;
111
112 static char *ifname = "wlan%d";
113 module_param(ifname, charp, 0644);
114 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
115
116 static char *if2name = "wlan%d";
117 module_param(if2name, charp, 0644);
118 MODULE_PARM_DESC(if2name, "The default name to allocate for second interface");
119
120 char *rtw_initmac; /* temp mac address if users want to use instead of the mac address in Efuse */
121
122 module_param(rtw_initmac, charp, 0644);
123 module_param(rtw_channel_plan, int, 0644);
124 module_param(rtw_chip_version, int, 0644);
125 module_param(rtw_rfintfs, int, 0644);
126 module_param(rtw_lbkmode, int, 0644);
127 module_param(rtw_network_mode, int, 0644);
128 module_param(rtw_channel, int, 0644);
129 module_param(rtw_wmm_enable, int, 0644);
130 module_param(rtw_vrtl_carrier_sense, int, 0644);
131 module_param(rtw_vcs_type, int, 0644);
132 module_param(rtw_busy_thresh, int, 0644);
133 module_param(rtw_ht_enable, int, 0644);
134 module_param(rtw_cbw40_enable, int, 0644);
135 module_param(rtw_ampdu_enable, int, 0644);
136 module_param(rtw_rx_stbc, int, 0644);
137 module_param(rtw_ampdu_amsdu, int, 0644);
138 module_param(rtw_lowrate_two_xmit, int, 0644);
139 module_param(rtw_rf_config, int, 0644);
140 module_param(rtw_power_mgnt, int, 0644);
141 module_param(rtw_smart_ps, int, 0644);
142 module_param(rtw_low_power, int, 0644);
143 module_param(rtw_wifi_spec, int, 0644);
144 module_param(rtw_antdiv_cfg, int, 0644);
145 module_param(rtw_antdiv_type, int, 0644);
146 module_param(rtw_enusbss, int, 0644);
147 module_param(rtw_hwpdn_mode, int, 0644);
148 module_param(rtw_hwpwrp_detect, int, 0644);
149 module_param(rtw_hw_wps_pbc, int, 0644);
150
151 static uint rtw_max_roaming_times = 2;
152 module_param(rtw_max_roaming_times, uint, 0644);
153 MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
154
155 static int rtw_fw_iol = 1;/* 0:Disable, 1:enable, 2:by usb speed */
156 module_param(rtw_fw_iol, int, 0644);
157 MODULE_PARM_DESC(rtw_fw_iol, "FW IOL");
158
159 module_param(rtw_mc2u_disable, int, 0644);
160
161 module_param(rtw_80211d, int, 0644);
162 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
163
164 static uint rtw_notch_filter = RTW_NOTCH_FILTER;
165 module_param(rtw_notch_filter, uint, 0644);
166 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
167 module_param_named(debug, rtw_debug, int, 0444);
168 MODULE_PARM_DESC(debug, "Set debug level (1-9) (default 1)");
169
170 /* dummy routines */
rtw_proc_remove_one(struct net_device * dev)171 void rtw_proc_remove_one(struct net_device *dev)
172 {
173 }
174
rtw_proc_init_one(struct net_device * dev)175 void rtw_proc_init_one(struct net_device *dev)
176 {
177 }
178
179 #if 0 /* TODO: Convert these to /sys */
180 void rtw_proc_init_one(struct net_device *dev)
181 {
182 struct proc_dir_entry *dir_dev = NULL;
183 struct proc_dir_entry *entry = NULL;
184 struct adapter *padapter = rtw_netdev_priv(dev);
185 u8 rf_type;
186
187 if (rtw_proc == NULL) {
188 memcpy(rtw_proc_name, DRV_NAME, sizeof(DRV_NAME));
189
190 rtw_proc = create_proc_entry(rtw_proc_name, S_IFDIR, init_net.proc_net);
191 if (rtw_proc == NULL) {
192 DBG_88E(KERN_ERR "Unable to create rtw_proc directory\n");
193 return;
194 }
195
196 entry = create_proc_read_entry("ver_info", S_IFREG | S_IRUGO, rtw_proc, proc_get_drv_version, dev);
197 if (!entry) {
198 pr_info("Unable to create_proc_read_entry!\n");
199 return;
200 }
201 }
202
203 if (padapter->dir_dev == NULL) {
204 padapter->dir_dev = create_proc_entry(dev->name,
205 S_IFDIR | S_IRUGO | S_IXUGO,
206 rtw_proc);
207 dir_dev = padapter->dir_dev;
208 if (dir_dev == NULL) {
209 if (rtw_proc_cnt == 0) {
210 if (rtw_proc) {
211 remove_proc_entry(rtw_proc_name, init_net.proc_net);
212 rtw_proc = NULL;
213 }
214 }
215
216 pr_info("Unable to create dir_dev directory\n");
217 return;
218 }
219 } else {
220 return;
221 }
222
223 rtw_proc_cnt++;
224
225 entry = create_proc_read_entry("write_reg", S_IFREG | S_IRUGO,
226 dir_dev, proc_get_write_reg, dev);
227 if (!entry) {
228 pr_info("Unable to create_proc_read_entry!\n");
229 return;
230 }
231 entry->write_proc = proc_set_write_reg;
232
233 entry = create_proc_read_entry("read_reg", S_IFREG | S_IRUGO,
234 dir_dev, proc_get_read_reg, dev);
235 if (!entry) {
236 pr_info("Unable to create_proc_read_entry!\n");
237 return;
238 }
239 entry->write_proc = proc_set_read_reg;
240
241
242 entry = create_proc_read_entry("fwstate", S_IFREG | S_IRUGO,
243 dir_dev, proc_get_fwstate, dev);
244 if (!entry) {
245 pr_info("Unable to create_proc_read_entry!\n");
246 return;
247 }
248
249 entry = create_proc_read_entry("sec_info", S_IFREG | S_IRUGO,
250 dir_dev, proc_get_sec_info, dev);
251 if (!entry) {
252 pr_info("Unable to create_proc_read_entry!\n");
253 return;
254 }
255
256 entry = create_proc_read_entry("mlmext_state", S_IFREG | S_IRUGO,
257 dir_dev, proc_get_mlmext_state, dev);
258 if (!entry) {
259 pr_info("Unable to create_proc_read_entry!\n");
260 return;
261 }
262
263 entry = create_proc_read_entry("qos_option", S_IFREG | S_IRUGO,
264 dir_dev, proc_get_qos_option, dev);
265 if (!entry) {
266 pr_info("Unable to create_proc_read_entry!\n");
267 return;
268 }
269
270 entry = create_proc_read_entry("ht_option", S_IFREG | S_IRUGO,
271 dir_dev, proc_get_ht_option, dev);
272 if (!entry) {
273 pr_info("Unable to create_proc_read_entry!\n");
274 return;
275 }
276
277 entry = create_proc_read_entry("rf_info", S_IFREG | S_IRUGO,
278 dir_dev, proc_get_rf_info, dev);
279 if (!entry) {
280 pr_info("Unable to create_proc_read_entry!\n");
281 return;
282 }
283
284 entry = create_proc_read_entry("ap_info", S_IFREG | S_IRUGO,
285 dir_dev, proc_get_ap_info, dev);
286 if (!entry) {
287 pr_info("Unable to create_proc_read_entry!\n");
288 return;
289 }
290
291 entry = create_proc_read_entry("adapter_state", S_IFREG | S_IRUGO,
292 dir_dev, proc_getstruct adapter_state, dev);
293 if (!entry) {
294 pr_info("Unable to create_proc_read_entry!\n");
295 return;
296 }
297
298 entry = create_proc_read_entry("trx_info", S_IFREG | S_IRUGO,
299 dir_dev, proc_get_trx_info, dev);
300 if (!entry) {
301 pr_info("Unable to create_proc_read_entry!\n");
302 return;
303 }
304
305 entry = create_proc_read_entry("mac_reg_dump1", S_IFREG | S_IRUGO,
306 dir_dev, proc_get_mac_reg_dump1, dev);
307 if (!entry) {
308 pr_info("Unable to create_proc_read_entry!\n");
309 return;
310 }
311
312 entry = create_proc_read_entry("mac_reg_dump2", S_IFREG | S_IRUGO,
313 dir_dev, proc_get_mac_reg_dump2, dev);
314 if (!entry) {
315 pr_info("Unable to create_proc_read_entry!\n");
316 return;
317 }
318
319 entry = create_proc_read_entry("mac_reg_dump3", S_IFREG | S_IRUGO,
320 dir_dev, proc_get_mac_reg_dump3, dev);
321 if (!entry) {
322 pr_info("Unable to create_proc_read_entry!\n");
323 return;
324 }
325
326 entry = create_proc_read_entry("bb_reg_dump1", S_IFREG | S_IRUGO,
327 dir_dev, proc_get_bb_reg_dump1, dev);
328 if (!entry) {
329 pr_info("Unable to create_proc_read_entry!\n");
330 return;
331 }
332
333 entry = create_proc_read_entry("bb_reg_dump2", S_IFREG | S_IRUGO,
334 dir_dev, proc_get_bb_reg_dump2, dev);
335 if (!entry) {
336 pr_info("Unable to create_proc_read_entry!\n");
337 return;
338 }
339
340 entry = create_proc_read_entry("bb_reg_dump3", S_IFREG | S_IRUGO,
341 dir_dev, proc_get_bb_reg_dump3, dev);
342 if (!entry) {
343 pr_info("Unable to create_proc_read_entry!\n");
344 return;
345 }
346
347 entry = create_proc_read_entry("rf_reg_dump1", S_IFREG | S_IRUGO,
348 dir_dev, proc_get_rf_reg_dump1, dev);
349 if (!entry) {
350 pr_info("Unable to create_proc_read_entry!\n");
351 return;
352 }
353
354 entry = create_proc_read_entry("rf_reg_dump2", S_IFREG | S_IRUGO,
355 dir_dev, proc_get_rf_reg_dump2, dev);
356 if (!entry) {
357 pr_info("Unable to create_proc_read_entry!\n");
358 return;
359 }
360
361 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
362 if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) {
363 entry = create_proc_read_entry("rf_reg_dump3", S_IFREG | S_IRUGO,
364 dir_dev, proc_get_rf_reg_dump3, dev);
365 if (!entry) {
366 pr_info("Unable to create_proc_read_entry!\n");
367 return;
368 }
369
370 entry = create_proc_read_entry("rf_reg_dump4", S_IFREG | S_IRUGO,
371 dir_dev, proc_get_rf_reg_dump4, dev);
372 if (!entry) {
373 pr_info("Unable to create_proc_read_entry!\n");
374 return;
375 }
376 }
377
378 #ifdef CONFIG_88EU_AP_MODE
379
380 entry = create_proc_read_entry("all_sta_info", S_IFREG | S_IRUGO,
381 dir_dev, proc_get_all_sta_info, dev);
382 if (!entry) {
383 pr_info("Unable to create_proc_read_entry!\n");
384 return;
385 }
386 #endif
387
388 entry = create_proc_read_entry("best_channel", S_IFREG | S_IRUGO,
389 dir_dev, proc_get_best_channel, dev);
390 if (!entry) {
391 pr_info("Unable to create_proc_read_entry!\n");
392 return;
393 }
394
395 entry = create_proc_read_entry("rx_signal", S_IFREG | S_IRUGO,
396 dir_dev, proc_get_rx_signal, dev);
397 if (!entry) {
398 pr_info("Unable to create_proc_read_entry!\n");
399 return;
400 }
401 entry->write_proc = proc_set_rx_signal;
402 entry = create_proc_read_entry("ht_enable", S_IFREG | S_IRUGO,
403 dir_dev, proc_get_ht_enable, dev);
404 if (!entry) {
405 pr_info("Unable to create_proc_read_entry!\n");
406 return;
407 }
408 entry->write_proc = proc_set_ht_enable;
409
410 entry = create_proc_read_entry("cbw40_enable", S_IFREG | S_IRUGO,
411 dir_dev, proc_get_cbw40_enable, dev);
412 if (!entry) {
413 pr_info("Unable to create_proc_read_entry!\n");
414 return;
415 }
416 entry->write_proc = proc_set_cbw40_enable;
417
418 entry = create_proc_read_entry("ampdu_enable", S_IFREG | S_IRUGO,
419 dir_dev, proc_get_ampdu_enable, dev);
420 if (!entry) {
421 pr_info("Unable to create_proc_read_entry!\n");
422 return;
423 }
424 entry->write_proc = proc_set_ampdu_enable;
425
426 entry = create_proc_read_entry("rx_stbc", S_IFREG | S_IRUGO,
427 dir_dev, proc_get_rx_stbc, dev);
428 if (!entry) {
429 pr_info("Unable to create_proc_read_entry!\n");
430 return;
431 }
432 entry->write_proc = proc_set_rx_stbc;
433
434 entry = create_proc_read_entry("path_rssi", S_IFREG | S_IRUGO,
435 dir_dev, proc_get_two_path_rssi, dev);
436 if (!entry) {
437 pr_info("Unable to create_proc_read_entry!\n");
438 return;
439 }
440 entry = create_proc_read_entry("rssi_disp", S_IFREG | S_IRUGO,
441 dir_dev, proc_get_rssi_disp, dev);
442 if (!entry) {
443 pr_info("Unable to create_proc_read_entry!\n");
444 return;
445 }
446 entry->write_proc = proc_set_rssi_disp;
447 }
448
449 void rtw_proc_remove_one(struct net_device *dev)
450 {
451 struct proc_dir_entry *dir_dev = NULL;
452 struct adapter *padapter = rtw_netdev_priv(dev);
453 u8 rf_type;
454
455 dir_dev = padapter->dir_dev;
456 padapter->dir_dev = NULL;
457
458 if (dir_dev) {
459 remove_proc_entry("write_reg", dir_dev);
460 remove_proc_entry("read_reg", dir_dev);
461 remove_proc_entry("fwstate", dir_dev);
462 remove_proc_entry("sec_info", dir_dev);
463 remove_proc_entry("mlmext_state", dir_dev);
464 remove_proc_entry("qos_option", dir_dev);
465 remove_proc_entry("ht_option", dir_dev);
466 remove_proc_entry("rf_info", dir_dev);
467 remove_proc_entry("ap_info", dir_dev);
468 remove_proc_entry("adapter_state", dir_dev);
469 remove_proc_entry("trx_info", dir_dev);
470 remove_proc_entry("mac_reg_dump1", dir_dev);
471 remove_proc_entry("mac_reg_dump2", dir_dev);
472 remove_proc_entry("mac_reg_dump3", dir_dev);
473 remove_proc_entry("bb_reg_dump1", dir_dev);
474 remove_proc_entry("bb_reg_dump2", dir_dev);
475 remove_proc_entry("bb_reg_dump3", dir_dev);
476 remove_proc_entry("rf_reg_dump1", dir_dev);
477 remove_proc_entry("rf_reg_dump2", dir_dev);
478 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
479 if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) {
480 remove_proc_entry("rf_reg_dump3", dir_dev);
481 remove_proc_entry("rf_reg_dump4", dir_dev);
482 }
483 #ifdef CONFIG_88EU_AP_MODE
484 remove_proc_entry("all_sta_info", dir_dev);
485 #endif
486
487 remove_proc_entry("best_channel", dir_dev);
488 remove_proc_entry("rx_signal", dir_dev);
489 remove_proc_entry("cbw40_enable", dir_dev);
490 remove_proc_entry("ht_enable", dir_dev);
491 remove_proc_entry("ampdu_enable", dir_dev);
492 remove_proc_entry("rx_stbc", dir_dev);
493 remove_proc_entry("path_rssi", dir_dev);
494 remove_proc_entry("rssi_disp", dir_dev);
495 remove_proc_entry(dev->name, rtw_proc);
496 dir_dev = NULL;
497 } else {
498 return;
499 }
500 rtw_proc_cnt--;
501
502 if (rtw_proc_cnt == 0) {
503 if (rtw_proc) {
504 remove_proc_entry("ver_info", rtw_proc);
505
506 remove_proc_entry(rtw_proc_name, init_net.proc_net);
507 rtw_proc = NULL;
508 }
509 }
510 }
511 #endif
512
loadparam(struct adapter * padapter,struct net_device * pnetdev)513 static uint loadparam(struct adapter *padapter, struct net_device *pnetdev)
514 {
515 struct registry_priv *registry_par = &padapter->registrypriv;
516
517
518 GlobalDebugLevel = rtw_debug;
519 registry_par->chip_version = (u8)rtw_chip_version;
520 registry_par->rfintfs = (u8)rtw_rfintfs;
521 registry_par->lbkmode = (u8)rtw_lbkmode;
522 registry_par->network_mode = (u8)rtw_network_mode;
523
524 memcpy(registry_par->ssid.Ssid, "ANY", 3);
525 registry_par->ssid.SsidLength = 3;
526
527 registry_par->channel = (u8)rtw_channel;
528 registry_par->wireless_mode = (u8)rtw_wireless_mode;
529 registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense;
530 registry_par->vcs_type = (u8)rtw_vcs_type;
531 registry_par->rts_thresh = (u16)rtw_rts_thresh;
532 registry_par->frag_thresh = (u16)rtw_frag_thresh;
533 registry_par->preamble = (u8)rtw_preamble;
534 registry_par->scan_mode = (u8)rtw_scan_mode;
535 registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
536 registry_par->soft_ap = (u8)rtw_soft_ap;
537 registry_par->smart_ps = (u8)rtw_smart_ps;
538 registry_par->power_mgnt = (u8)rtw_power_mgnt;
539 registry_par->ips_mode = (u8)rtw_ips_mode;
540 registry_par->radio_enable = (u8)rtw_radio_enable;
541 registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
542 registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
543 registry_par->busy_thresh = (u16)rtw_busy_thresh;
544 registry_par->ack_policy = (u8)rtw_ack_policy;
545 registry_par->mp_mode = 0;
546 registry_par->software_encrypt = (u8)rtw_software_encrypt;
547 registry_par->software_decrypt = (u8)rtw_software_decrypt;
548 registry_par->acm_method = (u8)rtw_acm_method;
549
550 /* UAPSD */
551 registry_par->wmm_enable = (u8)rtw_wmm_enable;
552 registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
553 registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
554 registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
555 registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
556 registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
557 registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
558
559 registry_par->ht_enable = (u8)rtw_ht_enable;
560 registry_par->cbw40_enable = (u8)rtw_cbw40_enable;
561 registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
562 registry_par->rx_stbc = (u8)rtw_rx_stbc;
563 registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
564 registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
565 registry_par->rf_config = (u8)rtw_rf_config;
566 registry_par->low_power = (u8)rtw_low_power;
567 registry_par->wifi_spec = (u8)rtw_wifi_spec;
568 registry_par->channel_plan = (u8)rtw_channel_plan;
569 registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq;
570 registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
571 registry_par->antdiv_type = (u8)rtw_antdiv_type;
572 registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;/* 0:disable, 1:enable, 2:by EFUSE config */
573 registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;/* 0:disable, 1:enable */
574 registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
575
576 registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
577
578 registry_par->fw_iol = rtw_fw_iol;
579
580 registry_par->enable80211d = (u8)rtw_80211d;
581 snprintf(registry_par->ifname, 16, "%s", ifname);
582 snprintf(registry_par->if2name, 16, "%s", if2name);
583 registry_par->notch_filter = (u8)rtw_notch_filter;
584 return _SUCCESS;
585 }
586
rtw_net_set_mac_address(struct net_device * pnetdev,void * p)587 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
588 {
589 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
590 struct sockaddr *addr = p;
591
592 if (!padapter->bup)
593 memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
594
595 return 0;
596 }
597
rtw_net_get_stats(struct net_device * pnetdev)598 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
599 {
600 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
601 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
602 struct recv_priv *precvpriv = &(padapter->recvpriv);
603
604 padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
605 padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */
606 padapter->stats.tx_dropped = pxmitpriv->tx_drop;
607 padapter->stats.rx_dropped = precvpriv->rx_drop;
608 padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
609 padapter->stats.rx_bytes = precvpriv->rx_bytes;
610 return &padapter->stats;
611 }
612
613 /*
614 * AC to queue mapping
615 *
616 * AC_VO -> queue 0
617 * AC_VI -> queue 1
618 * AC_BE -> queue 2
619 * AC_BK -> queue 3
620 */
621 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
622
623 /* Given a data frame determine the 802.1p/1d tag to use. */
rtw_classify8021d(struct sk_buff * skb)624 static unsigned int rtw_classify8021d(struct sk_buff *skb)
625 {
626 unsigned int dscp;
627
628 /* skb->priority values from 256->263 are magic values to
629 * directly indicate a specific 802.1d priority. This is used
630 * to allow 802.1d priority to be passed directly in from VLAN
631 * tags, etc.
632 */
633 if (skb->priority >= 256 && skb->priority <= 263)
634 return skb->priority - 256;
635
636 switch (skb->protocol) {
637 case htons(ETH_P_IP):
638 dscp = ip_hdr(skb)->tos & 0xfc;
639 break;
640 default:
641 return 0;
642 }
643
644 return dscp >> 5;
645 }
646
rtw_select_queue(struct net_device * dev,struct sk_buff * skb,void * accel_priv,select_queue_fallback_t fallback)647 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb,
648 void *accel_priv, select_queue_fallback_t fallback)
649 {
650 struct adapter *padapter = rtw_netdev_priv(dev);
651 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
652
653 skb->priority = rtw_classify8021d(skb);
654
655 if (pmlmepriv->acm_mask != 0)
656 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
657
658 return rtw_1d_to_queue[skb->priority];
659 }
660
rtw_recv_select_queue(struct sk_buff * skb)661 u16 rtw_recv_select_queue(struct sk_buff *skb)
662 {
663 struct iphdr *piphdr;
664 unsigned int dscp;
665 __be16 eth_type;
666 u32 priority;
667 u8 *pdata = skb->data;
668
669 memcpy(ð_type, pdata+(ETH_ALEN<<1), 2);
670
671 switch (eth_type) {
672 case htons(ETH_P_IP):
673 piphdr = (struct iphdr *)(pdata+ETH_HLEN);
674 dscp = piphdr->tos & 0xfc;
675 priority = dscp >> 5;
676 break;
677 default:
678 priority = 0;
679 }
680
681 return rtw_1d_to_queue[priority];
682 }
683
684 static const struct net_device_ops rtw_netdev_ops = {
685 .ndo_open = netdev_open,
686 .ndo_stop = netdev_close,
687 .ndo_start_xmit = rtw_xmit_entry,
688 .ndo_select_queue = rtw_select_queue,
689 .ndo_set_mac_address = rtw_net_set_mac_address,
690 .ndo_get_stats = rtw_net_get_stats,
691 .ndo_do_ioctl = rtw_ioctl,
692 };
693
rtw_init_netdev_name(struct net_device * pnetdev,const char * ifname)694 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
695 {
696 if (dev_alloc_name(pnetdev, ifname) < 0)
697 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("dev_alloc_name, fail!\n"));
698
699 netif_carrier_off(pnetdev);
700 return 0;
701 }
702
703 static const struct device_type wlan_type = {
704 .name = "wlan",
705 };
706
rtw_init_netdev(struct adapter * old_padapter)707 struct net_device *rtw_init_netdev(struct adapter *old_padapter)
708 {
709 struct adapter *padapter;
710 struct net_device *pnetdev = NULL;
711
712 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+init_net_dev\n"));
713
714 if (old_padapter != NULL)
715 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter);
716
717 if (!pnetdev)
718 return NULL;
719
720 pnetdev->dev.type = &wlan_type;
721 padapter = rtw_netdev_priv(pnetdev);
722 padapter->pnetdev = pnetdev;
723 DBG_88E("register rtw_netdev_ops to netdev_ops\n");
724 pnetdev->netdev_ops = &rtw_netdev_ops;
725 pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */
726 pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
727
728 /* step 2. */
729 loadparam(padapter, pnetdev);
730
731 return pnetdev;
732 }
733
rtw_start_drv_threads(struct adapter * padapter)734 u32 rtw_start_drv_threads(struct adapter *padapter)
735 {
736 u32 _status = _SUCCESS;
737
738 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_start_drv_threads\n"));
739
740 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
741 if (IS_ERR(padapter->cmdThread))
742 _status = _FAIL;
743 else
744 _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); /* wait for cmd_thread to run */
745
746 return _status;
747 }
748
rtw_stop_drv_threads(struct adapter * padapter)749 void rtw_stop_drv_threads(struct adapter *padapter)
750 {
751 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_stop_drv_threads\n"));
752
753 /* Below is to termindate rtw_cmd_thread & event_thread... */
754 up(&padapter->cmdpriv.cmd_queue_sema);
755 if (padapter->cmdThread)
756 _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema);
757
758 }
759
rtw_init_default_value(struct adapter * padapter)760 static u8 rtw_init_default_value(struct adapter *padapter)
761 {
762 struct registry_priv *pregistrypriv = &padapter->registrypriv;
763 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
764 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
765 struct security_priv *psecuritypriv = &padapter->securitypriv;
766
767 /* xmit_priv */
768 pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
769 pxmitpriv->vcs = pregistrypriv->vcs_type;
770 pxmitpriv->vcs_type = pregistrypriv->vcs_type;
771 pxmitpriv->frag_len = pregistrypriv->frag_thresh;
772
773 /* mlme_priv */
774 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */
775 pmlmepriv->scan_mode = SCAN_ACTIVE;
776
777 /* ht_priv */
778 pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
779
780 /* security_priv */
781 psecuritypriv->binstallGrpkey = _FAIL;
782 psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
783 psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
784 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
785 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
786 psecuritypriv->dot11PrivacyKeyIndex = 0;
787 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
788 psecuritypriv->dot118021XGrpKeyid = 1;
789 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
790 psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
791
792 /* registry_priv */
793 rtw_init_registrypriv_dev_network(padapter);
794 rtw_update_registrypriv_dev_network(padapter);
795
796 /* hal_priv */
797 rtw_hal_def_value_init(padapter);
798
799 /* misc. */
800 padapter->bReadPortCancel = false;
801 padapter->bWritePortCancel = false;
802 padapter->bRxRSSIDisplay = 0;
803 padapter->bNotifyChannelChange = 0;
804 return _SUCCESS;
805 }
806
rtw_reset_drv_sw(struct adapter * padapter)807 u8 rtw_reset_drv_sw(struct adapter *padapter)
808 {
809 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
810 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
811
812 /* hal_priv */
813 rtw_hal_def_value_init(padapter);
814 padapter->bReadPortCancel = false;
815 padapter->bWritePortCancel = false;
816 padapter->bRxRSSIDisplay = 0;
817 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */
818
819 padapter->xmitpriv.tx_pkts = 0;
820 padapter->recvpriv.rx_pkts = 0;
821
822 pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
823
824 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);
825 rtw_hal_sreset_init(padapter);
826 pwrctrlpriv->pwr_state_check_cnts = 0;
827
828 /* mlmeextpriv */
829 padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
830
831 rtw_set_signal_stat_timer(&padapter->recvpriv);
832
833 return _SUCCESS;
834 }
835
rtw_init_drv_sw(struct adapter * padapter)836 u8 rtw_init_drv_sw(struct adapter *padapter)
837 {
838 u8 ret8 = _SUCCESS;
839
840
841 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_init_drv_sw\n"));
842
843 if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL) {
844 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init cmd_priv\n"));
845 ret8 = _FAIL;
846 goto exit;
847 }
848
849 padapter->cmdpriv.padapter = padapter;
850
851 if (rtw_init_mlme_priv(padapter) == _FAIL) {
852 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_priv\n"));
853 ret8 = _FAIL;
854 goto exit;
855 }
856
857 if (init_mlme_ext_priv(padapter) == _FAIL) {
858 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_ext_priv\n"));
859 ret8 = _FAIL;
860 goto exit;
861 }
862
863 if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) {
864 DBG_88E("Can't _rtw_init_xmit_priv\n");
865 ret8 = _FAIL;
866 goto exit;
867 }
868
869 if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL) {
870 DBG_88E("Can't _rtw_init_recv_priv\n");
871 ret8 = _FAIL;
872 goto exit;
873 }
874
875 if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) {
876 DBG_88E("Can't _rtw_init_sta_priv\n");
877 ret8 = _FAIL;
878 goto exit;
879 }
880
881 padapter->stapriv.padapter = padapter;
882
883 rtw_init_bcmc_stainfo(padapter);
884
885 rtw_init_pwrctrl_priv(padapter);
886
887 ret8 = rtw_init_default_value(padapter);
888
889 rtw_hal_dm_init(padapter);
890 rtw_hal_sw_led_init(padapter);
891
892 rtw_hal_sreset_init(padapter);
893
894 spin_lock_init(&padapter->br_ext_lock);
895
896 exit:
897 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_init_drv_sw\n"));
898
899
900 return ret8;
901 }
902
rtw_cancel_all_timer(struct adapter * padapter)903 void rtw_cancel_all_timer(struct adapter *padapter)
904 {
905 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_cancel_all_timer\n"));
906
907 del_timer_sync(&padapter->mlmepriv.assoc_timer);
908 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel association timer complete!\n"));
909
910 del_timer_sync(&padapter->mlmepriv.scan_to_timer);
911 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel scan_to_timer!\n"));
912
913 del_timer_sync(&padapter->mlmepriv.dynamic_chk_timer);
914 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel dynamic_chk_timer!\n"));
915
916 /* cancel sw led timer */
917 rtw_hal_sw_led_deinit(padapter);
918 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel DeInitSwLeds!\n"));
919
920 del_timer_sync(&padapter->pwrctrlpriv.pwr_state_check_timer);
921
922 del_timer_sync(&padapter->recvpriv.signal_stat_timer);
923 }
924
rtw_free_drv_sw(struct adapter * padapter)925 u8 rtw_free_drv_sw(struct adapter *padapter)
926 {
927 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("==>rtw_free_drv_sw"));
928
929 free_mlme_ext_priv(&padapter->mlmeextpriv);
930
931 rtw_free_mlme_priv(&padapter->mlmepriv);
932 _rtw_free_xmit_priv(&padapter->xmitpriv);
933
934 _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
935
936 _rtw_free_recv_priv(&padapter->recvpriv);
937
938 rtw_hal_free_data(padapter);
939
940 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("<== rtw_free_drv_sw\n"));
941
942 /* free the old_pnetdev */
943 if (padapter->rereg_nd_name_priv.old_pnetdev) {
944 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
945 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
946 }
947
948 mutex_destroy(&padapter->hw_init_mutex);
949
950 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_free_drv_sw\n"));
951
952 return _SUCCESS;
953 }
954
_netdev_open(struct net_device * pnetdev)955 int _netdev_open(struct net_device *pnetdev)
956 {
957 uint status;
958 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
959 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
960
961 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - dev_open\n"));
962 DBG_88E("+88eu_drv - drv_open, bup =%d\n", padapter->bup);
963
964 if (pwrctrlpriv->ps_flag) {
965 padapter->net_closed = false;
966 goto netdev_open_normal_process;
967 }
968
969 if (!padapter->bup) {
970 padapter->bDriverStopped = false;
971 padapter->bSurpriseRemoved = false;
972
973 status = rtw_hal_init(padapter);
974 if (status == _FAIL) {
975 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl88eu_hal_init(): Can't init h/w!\n"));
976 goto netdev_open_error;
977 }
978
979 pr_info("MAC Address = %pM\n", pnetdev->dev_addr);
980
981 status = rtw_start_drv_threads(padapter);
982 if (status == _FAIL) {
983 pr_info("Initialize driver software resource Failed!\n");
984 goto netdev_open_error;
985 }
986
987 if (init_hw_mlme_ext(padapter) == _FAIL) {
988 pr_info("can't init mlme_ext_priv\n");
989 goto netdev_open_error;
990 }
991 if (padapter->intf_start)
992 padapter->intf_start(padapter);
993 rtw_proc_init_one(pnetdev);
994
995 rtw_led_control(padapter, LED_CTL_NO_LINK);
996
997 padapter->bup = true;
998 }
999 padapter->net_closed = false;
1000
1001 mod_timer(&padapter->mlmepriv.dynamic_chk_timer,
1002 jiffies + msecs_to_jiffies(2000));
1003
1004 padapter->pwrctrlpriv.bips_processing = false;
1005 rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
1006
1007 if (!rtw_netif_queue_stopped(pnetdev))
1008 netif_tx_start_all_queues(pnetdev);
1009 else
1010 netif_tx_wake_all_queues(pnetdev);
1011
1012 netdev_open_normal_process:
1013 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - dev_open\n"));
1014 DBG_88E("-88eu_drv - drv_open, bup =%d\n", padapter->bup);
1015 return 0;
1016
1017 netdev_open_error:
1018 padapter->bup = false;
1019 netif_carrier_off(pnetdev);
1020 netif_tx_stop_all_queues(pnetdev);
1021 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-88eu_drv - dev_open, fail!\n"));
1022 DBG_88E("-88eu_drv - drv_open fail, bup =%d\n", padapter->bup);
1023 return -1;
1024 }
1025
netdev_open(struct net_device * pnetdev)1026 int netdev_open(struct net_device *pnetdev)
1027 {
1028 int ret;
1029 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
1030
1031 _enter_critical_mutex(&padapter->hw_init_mutex, NULL);
1032 ret = _netdev_open(pnetdev);
1033 mutex_unlock(&padapter->hw_init_mutex);
1034 return ret;
1035 }
1036
ips_netdrv_open(struct adapter * padapter)1037 static int ips_netdrv_open(struct adapter *padapter)
1038 {
1039 int status = _SUCCESS;
1040 padapter->net_closed = false;
1041 DBG_88E("===> %s.........\n", __func__);
1042
1043 padapter->bDriverStopped = false;
1044 padapter->bSurpriseRemoved = false;
1045
1046 status = rtw_hal_init(padapter);
1047 if (status == _FAIL) {
1048 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("ips_netdrv_open(): Can't init h/w!\n"));
1049 goto netdev_open_error;
1050 }
1051
1052 if (padapter->intf_start)
1053 padapter->intf_start(padapter);
1054
1055 rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
1056 mod_timer(&padapter->mlmepriv.dynamic_chk_timer,
1057 jiffies + msecs_to_jiffies(5000));
1058
1059 return _SUCCESS;
1060
1061 netdev_open_error:
1062 DBG_88E("-ips_netdrv_open - drv_open failure, bup =%d\n", padapter->bup);
1063
1064 return _FAIL;
1065 }
1066
1067
rtw_ips_pwr_up(struct adapter * padapter)1068 int rtw_ips_pwr_up(struct adapter *padapter)
1069 {
1070 int result;
1071 u32 start_time = jiffies;
1072 DBG_88E("===> rtw_ips_pwr_up..............\n");
1073 rtw_reset_drv_sw(padapter);
1074
1075 result = ips_netdrv_open(padapter);
1076
1077 rtw_led_control(padapter, LED_CTL_NO_LINK);
1078
1079 DBG_88E("<=== rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time));
1080 return result;
1081 }
1082
rtw_ips_pwr_down(struct adapter * padapter)1083 void rtw_ips_pwr_down(struct adapter *padapter)
1084 {
1085 u32 start_time = jiffies;
1086 DBG_88E("===> rtw_ips_pwr_down...................\n");
1087
1088 padapter->net_closed = true;
1089
1090 rtw_led_control(padapter, LED_CTL_POWER_OFF);
1091
1092 rtw_ips_dev_unload(padapter);
1093 DBG_88E("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time));
1094 }
1095
rtw_ips_dev_unload(struct adapter * padapter)1096 void rtw_ips_dev_unload(struct adapter *padapter)
1097 {
1098 DBG_88E("====> %s...\n", __func__);
1099
1100 rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, NULL);
1101
1102 if (padapter->intf_stop)
1103 padapter->intf_stop(padapter);
1104
1105 /* s5. */
1106 if (!padapter->bSurpriseRemoved)
1107 rtw_hal_deinit(padapter);
1108 }
1109
pm_netdev_open(struct net_device * pnetdev,u8 bnormal)1110 int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
1111 {
1112 int status;
1113
1114 if (bnormal)
1115 status = netdev_open(pnetdev);
1116 else
1117 status = (_SUCCESS == ips_netdrv_open((struct adapter *)rtw_netdev_priv(pnetdev))) ? (0) : (-1);
1118 return status;
1119 }
1120
netdev_close(struct net_device * pnetdev)1121 int netdev_close(struct net_device *pnetdev)
1122 {
1123 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
1124 struct hal_data_8188e *rtlhal = GET_HAL_DATA(padapter);
1125
1126 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - drv_close\n"));
1127
1128 if (padapter->pwrctrlpriv.bInternalAutoSuspend) {
1129 if (padapter->pwrctrlpriv.rf_pwrstate == rf_off)
1130 padapter->pwrctrlpriv.ps_flag = true;
1131 }
1132 padapter->net_closed = true;
1133
1134 if (padapter->pwrctrlpriv.rf_pwrstate == rf_on) {
1135 DBG_88E("(2)88eu_drv - drv_close, bup =%d, hw_init_completed =%d\n",
1136 padapter->bup, padapter->hw_init_completed);
1137
1138 /* s1. */
1139 if (pnetdev) {
1140 if (!rtw_netif_queue_stopped(pnetdev))
1141 netif_tx_stop_all_queues(pnetdev);
1142 }
1143
1144 /* s2. */
1145 LeaveAllPowerSaveMode(padapter);
1146 rtw_disassoc_cmd(padapter, 500, false);
1147 /* s2-2. indicate disconnect to os */
1148 rtw_indicate_disconnect(padapter);
1149 /* s2-3. */
1150 rtw_free_assoc_resources(padapter, 1);
1151 /* s2-4. */
1152 rtw_free_network_queue(padapter, true);
1153 /* Close LED */
1154 rtw_led_control(padapter, LED_CTL_POWER_OFF);
1155 }
1156
1157 kfree(rtlhal->pfirmware);
1158 rtlhal->pfirmware = NULL;
1159
1160 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - drv_close\n"));
1161 DBG_88E("-88eu_drv - drv_close, bup =%d\n", padapter->bup);
1162 return 0;
1163 }
1164