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 33MODULE_LICENSE("GPL"); 34MODULE_DESCRIPTION("Realtek Wireless Lan Driver"); 35MODULE_AUTHOR("Realtek Semiconductor Corp."); 36MODULE_VERSION(DRIVERVERSION); 37 38#define RTW_NOTCH_FILTER 0 /* 0:Disable, 1:Enable, */ 39 40/* module param defaults */ 41static int rtw_chip_version = 0x00; 42static int rtw_rfintfs = HWPI; 43static int rtw_lbkmode;/* RTL8712_AIR_TRX; */ 44static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure; infra, ad-hoc, auto */ 45static int rtw_channel = 1;/* ad-hoc support requirement */ 46static int rtw_wireless_mode = WIRELESS_11BG_24N; 47static int rtw_vrtl_carrier_sense = AUTO_VCS; 48static int rtw_vcs_type = RTS_CTS;/* */ 49static int rtw_rts_thresh = 2347;/* */ 50static int rtw_frag_thresh = 2346;/* */ 51static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */ 52static int rtw_scan_mode = 1;/* active, passive */ 53static int rtw_adhoc_tx_pwr = 1; 54static int rtw_soft_ap; 55static int rtw_power_mgnt = 1; 56static int rtw_ips_mode = IPS_NORMAL; 57 58static int rtw_smart_ps = 2; 59 60module_param(rtw_ips_mode, int, 0644); 61MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode"); 62 63static int rtw_debug = 1; 64static int rtw_radio_enable = 1; 65static int rtw_long_retry_lmt = 7; 66static int rtw_short_retry_lmt = 7; 67static int rtw_busy_thresh = 40; 68static int rtw_ack_policy = NORMAL_ACK; 69 70static int rtw_software_encrypt; 71static int rtw_software_decrypt; 72 73static int rtw_acm_method;/* 0:By SW 1:By HW. */ 74 75static int rtw_wmm_enable = 1;/* default is set to enable the wmm. */ 76static int rtw_uapsd_enable; 77static int rtw_uapsd_max_sp = NO_LIMIT; 78static int rtw_uapsd_acbk_en; 79static int rtw_uapsd_acbe_en; 80static int rtw_uapsd_acvi_en; 81static int rtw_uapsd_acvo_en; 82 83static int rtw_ht_enable = 1; 84static int rtw_cbw40_enable = 3; /* 0 :disable, bit(0): enable 2.4g, bit(1): enable 5g */ 85static int rtw_ampdu_enable = 1;/* for enable tx_ampdu */ 86static 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 */ 87static int rtw_ampdu_amsdu;/* 0: disabled, 1:enabled, 2:auto */ 88 89static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */ 90 91static int rtw_rf_config = RF_819X_MAX_TYPE; /* auto */ 92static int rtw_low_power; 93static int rtw_wifi_spec; 94static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX; 95static int rtw_AcceptAddbaReq = true;/* 0:Reject AP's Add BA req, 1:Accept AP's Add BA req. */ 96 97static int rtw_antdiv_cfg = 2; /* 0:OFF , 1:ON, 2:decide by Efuse config */ 98static 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 100static int rtw_enusbss;/* 0:disable, 1:enable */ 101 102static int rtw_hwpdn_mode = 2;/* 0:disable, 1:enable, 2: by EFUSE config */ 103 104static int rtw_hwpwrp_detect; /* HW power ping detect 0:disable , 1:enable */ 105 106static int rtw_hw_wps_pbc = 1; 107 108int rtw_mc2u_disable; 109 110static int rtw_80211d; 111 112static char *ifname = "wlan%d"; 113module_param(ifname, charp, 0644); 114MODULE_PARM_DESC(ifname, "The default name to allocate for first interface"); 115 116static char *if2name = "wlan%d"; 117module_param(if2name, charp, 0644); 118MODULE_PARM_DESC(if2name, "The default name to allocate for second interface"); 119 120char *rtw_initmac; /* temp mac address if users want to use instead of the mac address in Efuse */ 121 122module_param(rtw_initmac, charp, 0644); 123module_param(rtw_channel_plan, int, 0644); 124module_param(rtw_chip_version, int, 0644); 125module_param(rtw_rfintfs, int, 0644); 126module_param(rtw_lbkmode, int, 0644); 127module_param(rtw_network_mode, int, 0644); 128module_param(rtw_channel, int, 0644); 129module_param(rtw_wmm_enable, int, 0644); 130module_param(rtw_vrtl_carrier_sense, int, 0644); 131module_param(rtw_vcs_type, int, 0644); 132module_param(rtw_busy_thresh, int, 0644); 133module_param(rtw_ht_enable, int, 0644); 134module_param(rtw_cbw40_enable, int, 0644); 135module_param(rtw_ampdu_enable, int, 0644); 136module_param(rtw_rx_stbc, int, 0644); 137module_param(rtw_ampdu_amsdu, int, 0644); 138module_param(rtw_lowrate_two_xmit, int, 0644); 139module_param(rtw_rf_config, int, 0644); 140module_param(rtw_power_mgnt, int, 0644); 141module_param(rtw_smart_ps, int, 0644); 142module_param(rtw_low_power, int, 0644); 143module_param(rtw_wifi_spec, int, 0644); 144module_param(rtw_antdiv_cfg, int, 0644); 145module_param(rtw_antdiv_type, int, 0644); 146module_param(rtw_enusbss, int, 0644); 147module_param(rtw_hwpdn_mode, int, 0644); 148module_param(rtw_hwpwrp_detect, int, 0644); 149module_param(rtw_hw_wps_pbc, int, 0644); 150 151static uint rtw_max_roaming_times = 2; 152module_param(rtw_max_roaming_times, uint, 0644); 153MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try"); 154 155static int rtw_fw_iol = 1;/* 0:Disable, 1:enable, 2:by usb speed */ 156module_param(rtw_fw_iol, int, 0644); 157MODULE_PARM_DESC(rtw_fw_iol, "FW IOL"); 158 159module_param(rtw_mc2u_disable, int, 0644); 160 161module_param(rtw_80211d, int, 0644); 162MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism"); 163 164static uint rtw_notch_filter = RTW_NOTCH_FILTER; 165module_param(rtw_notch_filter, uint, 0644); 166MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P"); 167module_param_named(debug, rtw_debug, int, 0444); 168MODULE_PARM_DESC(debug, "Set debug level (1-9) (default 1)"); 169 170/* dummy routines */ 171void rtw_proc_remove_one(struct net_device *dev) 172{ 173} 174 175void rtw_proc_init_one(struct net_device *dev) 176{ 177} 178 179#if 0 /* TODO: Convert these to /sys */ 180void 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 449void 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 513static uint loadparam(struct adapter *padapter, struct net_device *pnetdev) 514{ 515 uint status = _SUCCESS; 516 struct registry_priv *registry_par = &padapter->registrypriv; 517 518 519 GlobalDebugLevel = rtw_debug; 520 registry_par->chip_version = (u8)rtw_chip_version; 521 registry_par->rfintfs = (u8)rtw_rfintfs; 522 registry_par->lbkmode = (u8)rtw_lbkmode; 523 registry_par->network_mode = (u8)rtw_network_mode; 524 525 memcpy(registry_par->ssid.Ssid, "ANY", 3); 526 registry_par->ssid.SsidLength = 3; 527 528 registry_par->channel = (u8)rtw_channel; 529 registry_par->wireless_mode = (u8)rtw_wireless_mode; 530 registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense ; 531 registry_par->vcs_type = (u8)rtw_vcs_type; 532 registry_par->rts_thresh = (u16)rtw_rts_thresh; 533 registry_par->frag_thresh = (u16)rtw_frag_thresh; 534 registry_par->preamble = (u8)rtw_preamble; 535 registry_par->scan_mode = (u8)rtw_scan_mode; 536 registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr; 537 registry_par->soft_ap = (u8)rtw_soft_ap; 538 registry_par->smart_ps = (u8)rtw_smart_ps; 539 registry_par->power_mgnt = (u8)rtw_power_mgnt; 540 registry_par->ips_mode = (u8)rtw_ips_mode; 541 registry_par->radio_enable = (u8)rtw_radio_enable; 542 registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt; 543 registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt; 544 registry_par->busy_thresh = (u16)rtw_busy_thresh; 545 registry_par->ack_policy = (u8)rtw_ack_policy; 546 registry_par->mp_mode = 0; 547 registry_par->software_encrypt = (u8)rtw_software_encrypt; 548 registry_par->software_decrypt = (u8)rtw_software_decrypt; 549 registry_par->acm_method = (u8)rtw_acm_method; 550 551 /* UAPSD */ 552 registry_par->wmm_enable = (u8)rtw_wmm_enable; 553 registry_par->uapsd_enable = (u8)rtw_uapsd_enable; 554 registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp; 555 registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en; 556 registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en; 557 registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en; 558 registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en; 559 560 registry_par->ht_enable = (u8)rtw_ht_enable; 561 registry_par->cbw40_enable = (u8)rtw_cbw40_enable; 562 registry_par->ampdu_enable = (u8)rtw_ampdu_enable; 563 registry_par->rx_stbc = (u8)rtw_rx_stbc; 564 registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu; 565 registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit; 566 registry_par->rf_config = (u8)rtw_rf_config; 567 registry_par->low_power = (u8)rtw_low_power; 568 registry_par->wifi_spec = (u8)rtw_wifi_spec; 569 registry_par->channel_plan = (u8)rtw_channel_plan; 570 registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq; 571 registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg; 572 registry_par->antdiv_type = (u8)rtw_antdiv_type; 573 registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;/* 0:disable, 1:enable, 2:by EFUSE config */ 574 registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;/* 0:disable, 1:enable */ 575 registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc; 576 577 registry_par->max_roaming_times = (u8)rtw_max_roaming_times; 578 579 registry_par->fw_iol = rtw_fw_iol; 580 581 registry_par->enable80211d = (u8)rtw_80211d; 582 snprintf(registry_par->ifname, 16, "%s", ifname); 583 snprintf(registry_par->if2name, 16, "%s", if2name); 584 registry_par->notch_filter = (u8)rtw_notch_filter; 585 return status; 586} 587 588static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p) 589{ 590 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); 591 struct sockaddr *addr = p; 592 593 if (!padapter->bup) 594 memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN); 595 596 return 0; 597} 598 599static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev) 600{ 601 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); 602 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv); 603 struct recv_priv *precvpriv = &(padapter->recvpriv); 604 605 padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */ 606 padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */ 607 padapter->stats.tx_dropped = pxmitpriv->tx_drop; 608 padapter->stats.rx_dropped = precvpriv->rx_drop; 609 padapter->stats.tx_bytes = pxmitpriv->tx_bytes; 610 padapter->stats.rx_bytes = precvpriv->rx_bytes; 611 return &padapter->stats; 612} 613 614/* 615 * AC to queue mapping 616 * 617 * AC_VO -> queue 0 618 * AC_VI -> queue 1 619 * AC_BE -> queue 2 620 * AC_BK -> queue 3 621 */ 622static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 }; 623 624/* Given a data frame determine the 802.1p/1d tag to use. */ 625static unsigned int rtw_classify8021d(struct sk_buff *skb) 626{ 627 unsigned int dscp; 628 629 /* skb->priority values from 256->263 are magic values to 630 * directly indicate a specific 802.1d priority. This is used 631 * to allow 802.1d priority to be passed directly in from VLAN 632 * tags, etc. 633 */ 634 if (skb->priority >= 256 && skb->priority <= 263) 635 return skb->priority - 256; 636 637 switch (skb->protocol) { 638 case htons(ETH_P_IP): 639 dscp = ip_hdr(skb)->tos & 0xfc; 640 break; 641 default: 642 return 0; 643 } 644 645 return dscp >> 5; 646} 647 648static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb, 649 void *accel_priv, select_queue_fallback_t fallback) 650{ 651 struct adapter *padapter = rtw_netdev_priv(dev); 652 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 653 654 skb->priority = rtw_classify8021d(skb); 655 656 if (pmlmepriv->acm_mask != 0) 657 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority); 658 659 return rtw_1d_to_queue[skb->priority]; 660} 661 662u16 rtw_recv_select_queue(struct sk_buff *skb) 663{ 664 struct iphdr *piphdr; 665 unsigned int dscp; 666 __be16 eth_type; 667 u32 priority; 668 u8 *pdata = skb->data; 669 670 memcpy(ð_type, pdata+(ETH_ALEN<<1), 2); 671 672 switch (eth_type) { 673 case htons(ETH_P_IP): 674 piphdr = (struct iphdr *)(pdata+ETH_HLEN); 675 dscp = piphdr->tos & 0xfc; 676 priority = dscp >> 5; 677 break; 678 default: 679 priority = 0; 680 } 681 682 return rtw_1d_to_queue[priority]; 683} 684 685static const struct net_device_ops rtw_netdev_ops = { 686 .ndo_open = netdev_open, 687 .ndo_stop = netdev_close, 688 .ndo_start_xmit = rtw_xmit_entry, 689 .ndo_select_queue = rtw_select_queue, 690 .ndo_set_mac_address = rtw_net_set_mac_address, 691 .ndo_get_stats = rtw_net_get_stats, 692 .ndo_do_ioctl = rtw_ioctl, 693}; 694 695int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname) 696{ 697 if (dev_alloc_name(pnetdev, ifname) < 0) 698 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("dev_alloc_name, fail!\n")); 699 700 netif_carrier_off(pnetdev); 701 return 0; 702} 703 704static const struct device_type wlan_type = { 705 .name = "wlan", 706}; 707 708struct net_device *rtw_init_netdev(struct adapter *old_padapter) 709{ 710 struct adapter *padapter; 711 struct net_device *pnetdev = NULL; 712 713 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+init_net_dev\n")); 714 715 if (old_padapter != NULL) 716 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter); 717 718 if (!pnetdev) 719 return NULL; 720 721 pnetdev->dev.type = &wlan_type; 722 padapter = rtw_netdev_priv(pnetdev); 723 padapter->pnetdev = pnetdev; 724 DBG_88E("register rtw_netdev_ops to netdev_ops\n"); 725 pnetdev->netdev_ops = &rtw_netdev_ops; 726 pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */ 727 pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def; 728 729 /* step 2. */ 730 loadparam(padapter, pnetdev); 731 732 return pnetdev; 733} 734 735u32 rtw_start_drv_threads(struct adapter *padapter) 736{ 737 u32 _status = _SUCCESS; 738 739 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_start_drv_threads\n")); 740 741 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD"); 742 if (IS_ERR(padapter->cmdThread)) 743 _status = _FAIL; 744 else 745 _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); /* wait for cmd_thread to run */ 746 747 return _status; 748} 749 750void rtw_stop_drv_threads(struct adapter *padapter) 751{ 752 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_stop_drv_threads\n")); 753 754 /* Below is to termindate rtw_cmd_thread & event_thread... */ 755 up(&padapter->cmdpriv.cmd_queue_sema); 756 if (padapter->cmdThread) 757 _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); 758 759} 760 761static u8 rtw_init_default_value(struct adapter *padapter) 762{ 763 u8 ret = _SUCCESS; 764 struct registry_priv *pregistrypriv = &padapter->registrypriv; 765 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 766 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 767 struct security_priv *psecuritypriv = &padapter->securitypriv; 768 769 /* xmit_priv */ 770 pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense; 771 pxmitpriv->vcs = pregistrypriv->vcs_type; 772 pxmitpriv->vcs_type = pregistrypriv->vcs_type; 773 pxmitpriv->frag_len = pregistrypriv->frag_thresh; 774 775 /* mlme_priv */ 776 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */ 777 pmlmepriv->scan_mode = SCAN_ACTIVE; 778 779 /* ht_priv */ 780 pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */ 781 782 /* security_priv */ 783 psecuritypriv->binstallGrpkey = _FAIL; 784 psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt; 785 psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt; 786 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 787 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_; 788 psecuritypriv->dot11PrivacyKeyIndex = 0; 789 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 790 psecuritypriv->dot118021XGrpKeyid = 1; 791 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen; 792 psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled; 793 794 /* registry_priv */ 795 rtw_init_registrypriv_dev_network(padapter); 796 rtw_update_registrypriv_dev_network(padapter); 797 798 /* hal_priv */ 799 rtw_hal_def_value_init(padapter); 800 801 /* misc. */ 802 padapter->bReadPortCancel = false; 803 padapter->bWritePortCancel = false; 804 padapter->bRxRSSIDisplay = 0; 805 padapter->bNotifyChannelChange = 0; 806 return ret; 807} 808 809u8 rtw_reset_drv_sw(struct adapter *padapter) 810{ 811 u8 ret8 = _SUCCESS; 812 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 813 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; 814 815 /* hal_priv */ 816 rtw_hal_def_value_init(padapter); 817 padapter->bReadPortCancel = false; 818 padapter->bWritePortCancel = false; 819 padapter->bRxRSSIDisplay = 0; 820 pmlmepriv->scan_interval = SCAN_INTERVAL;/* 30*2 sec = 60sec */ 821 822 padapter->xmitpriv.tx_pkts = 0; 823 padapter->recvpriv.rx_pkts = 0; 824 825 pmlmepriv->LinkDetectInfo.bBusyTraffic = false; 826 827 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING); 828 rtw_hal_sreset_init(padapter); 829 pwrctrlpriv->pwr_state_check_cnts = 0; 830 831 /* mlmeextpriv */ 832 padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE; 833 834 rtw_set_signal_stat_timer(&padapter->recvpriv); 835 836 return ret8; 837} 838 839u8 rtw_init_drv_sw(struct adapter *padapter) 840{ 841 u8 ret8 = _SUCCESS; 842 843 844 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_init_drv_sw\n")); 845 846 if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL) { 847 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init cmd_priv\n")); 848 ret8 = _FAIL; 849 goto exit; 850 } 851 852 padapter->cmdpriv.padapter = padapter; 853 854 if (rtw_init_mlme_priv(padapter) == _FAIL) { 855 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_priv\n")); 856 ret8 = _FAIL; 857 goto exit; 858 } 859 860 if (init_mlme_ext_priv(padapter) == _FAIL) { 861 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_ext_priv\n")); 862 ret8 = _FAIL; 863 goto exit; 864 } 865 866 if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) { 867 DBG_88E("Can't _rtw_init_xmit_priv\n"); 868 ret8 = _FAIL; 869 goto exit; 870 } 871 872 if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL) { 873 DBG_88E("Can't _rtw_init_recv_priv\n"); 874 ret8 = _FAIL; 875 goto exit; 876 } 877 878 if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) { 879 DBG_88E("Can't _rtw_init_sta_priv\n"); 880 ret8 = _FAIL; 881 goto exit; 882 } 883 884 padapter->stapriv.padapter = padapter; 885 886 rtw_init_bcmc_stainfo(padapter); 887 888 rtw_init_pwrctrl_priv(padapter); 889 890 ret8 = rtw_init_default_value(padapter); 891 892 rtw_hal_dm_init(padapter); 893 rtw_hal_sw_led_init(padapter); 894 895 rtw_hal_sreset_init(padapter); 896 897 spin_lock_init(&padapter->br_ext_lock); 898 899exit: 900 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_init_drv_sw\n")); 901 902 903 return ret8; 904} 905 906void rtw_cancel_all_timer(struct adapter *padapter) 907{ 908 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_cancel_all_timer\n")); 909 910 del_timer_sync(&padapter->mlmepriv.assoc_timer); 911 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel association timer complete!\n")); 912 913 del_timer_sync(&padapter->mlmepriv.scan_to_timer); 914 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel scan_to_timer!\n")); 915 916 del_timer_sync(&padapter->mlmepriv.dynamic_chk_timer); 917 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel dynamic_chk_timer!\n")); 918 919 /* cancel sw led timer */ 920 rtw_hal_sw_led_deinit(padapter); 921 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel DeInitSwLeds!\n")); 922 923 del_timer_sync(&padapter->pwrctrlpriv.pwr_state_check_timer); 924 925 del_timer_sync(&padapter->recvpriv.signal_stat_timer); 926} 927 928u8 rtw_free_drv_sw(struct adapter *padapter) 929{ 930 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("==>rtw_free_drv_sw")); 931 932 free_mlme_ext_priv(&padapter->mlmeextpriv); 933 934 rtw_free_mlme_priv(&padapter->mlmepriv); 935 _rtw_free_xmit_priv(&padapter->xmitpriv); 936 937 _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */ 938 939 _rtw_free_recv_priv(&padapter->recvpriv); 940 941 rtw_hal_free_data(padapter); 942 943 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("<== rtw_free_drv_sw\n")); 944 945 /* free the old_pnetdev */ 946 if (padapter->rereg_nd_name_priv.old_pnetdev) { 947 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev); 948 padapter->rereg_nd_name_priv.old_pnetdev = NULL; 949 } 950 951 mutex_destroy(&padapter->hw_init_mutex); 952 953 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_free_drv_sw\n")); 954 955 return _SUCCESS; 956} 957 958int _netdev_open(struct net_device *pnetdev) 959{ 960 uint status; 961 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); 962 struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv; 963 964 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - dev_open\n")); 965 DBG_88E("+88eu_drv - drv_open, bup =%d\n", padapter->bup); 966 967 if (pwrctrlpriv->ps_flag) { 968 padapter->net_closed = false; 969 goto netdev_open_normal_process; 970 } 971 972 if (!padapter->bup) { 973 padapter->bDriverStopped = false; 974 padapter->bSurpriseRemoved = false; 975 976 status = rtw_hal_init(padapter); 977 if (status == _FAIL) { 978 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl88eu_hal_init(): Can't init h/w!\n")); 979 goto netdev_open_error; 980 } 981 982 pr_info("MAC Address = %pM\n", pnetdev->dev_addr); 983 984 status = rtw_start_drv_threads(padapter); 985 if (status == _FAIL) { 986 pr_info("Initialize driver software resource Failed!\n"); 987 goto netdev_open_error; 988 } 989 990 if (init_hw_mlme_ext(padapter) == _FAIL) { 991 pr_info("can't init mlme_ext_priv\n"); 992 goto netdev_open_error; 993 } 994 if (padapter->intf_start) 995 padapter->intf_start(padapter); 996 rtw_proc_init_one(pnetdev); 997 998 rtw_led_control(padapter, LED_CTL_NO_LINK); 999 1000 padapter->bup = true; 1001 } 1002 padapter->net_closed = false; 1003 1004 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000); 1005 1006 padapter->pwrctrlpriv.bips_processing = false; 1007 rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv); 1008 1009 if (!rtw_netif_queue_stopped(pnetdev)) 1010 netif_tx_start_all_queues(pnetdev); 1011 else 1012 netif_tx_wake_all_queues(pnetdev); 1013 1014netdev_open_normal_process: 1015 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - dev_open\n")); 1016 DBG_88E("-88eu_drv - drv_open, bup =%d\n", padapter->bup); 1017 return 0; 1018 1019netdev_open_error: 1020 padapter->bup = false; 1021 netif_carrier_off(pnetdev); 1022 netif_tx_stop_all_queues(pnetdev); 1023 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-88eu_drv - dev_open, fail!\n")); 1024 DBG_88E("-88eu_drv - drv_open fail, bup =%d\n", padapter->bup); 1025 return -1; 1026} 1027 1028int netdev_open(struct net_device *pnetdev) 1029{ 1030 int ret; 1031 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); 1032 1033 _enter_critical_mutex(&padapter->hw_init_mutex, NULL); 1034 ret = _netdev_open(pnetdev); 1035 mutex_unlock(&padapter->hw_init_mutex); 1036 return ret; 1037} 1038 1039static int ips_netdrv_open(struct adapter *padapter) 1040{ 1041 int status = _SUCCESS; 1042 padapter->net_closed = false; 1043 DBG_88E("===> %s.........\n", __func__); 1044 1045 padapter->bDriverStopped = false; 1046 padapter->bSurpriseRemoved = false; 1047 1048 status = rtw_hal_init(padapter); 1049 if (status == _FAIL) { 1050 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("ips_netdrv_open(): Can't init h/w!\n")); 1051 goto netdev_open_error; 1052 } 1053 1054 if (padapter->intf_start) 1055 padapter->intf_start(padapter); 1056 1057 rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv); 1058 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 5000); 1059 1060 return _SUCCESS; 1061 1062netdev_open_error: 1063 DBG_88E("-ips_netdrv_open - drv_open failure, bup =%d\n", padapter->bup); 1064 1065 return _FAIL; 1066} 1067 1068 1069int rtw_ips_pwr_up(struct adapter *padapter) 1070{ 1071 int result; 1072 u32 start_time = jiffies; 1073 DBG_88E("===> rtw_ips_pwr_up..............\n"); 1074 rtw_reset_drv_sw(padapter); 1075 1076 result = ips_netdrv_open(padapter); 1077 1078 rtw_led_control(padapter, LED_CTL_NO_LINK); 1079 1080 DBG_88E("<=== rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time)); 1081 return result; 1082} 1083 1084void rtw_ips_pwr_down(struct adapter *padapter) 1085{ 1086 u32 start_time = jiffies; 1087 DBG_88E("===> rtw_ips_pwr_down...................\n"); 1088 1089 padapter->net_closed = true; 1090 1091 rtw_led_control(padapter, LED_CTL_POWER_OFF); 1092 1093 rtw_ips_dev_unload(padapter); 1094 DBG_88E("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time)); 1095} 1096 1097void rtw_ips_dev_unload(struct adapter *padapter) 1098{ 1099 DBG_88E("====> %s...\n", __func__); 1100 1101 rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, NULL); 1102 1103 if (padapter->intf_stop) 1104 padapter->intf_stop(padapter); 1105 1106 /* s5. */ 1107 if (!padapter->bSurpriseRemoved) 1108 rtw_hal_deinit(padapter); 1109} 1110 1111int pm_netdev_open(struct net_device *pnetdev, u8 bnormal) 1112{ 1113 int status; 1114 1115 if (bnormal) 1116 status = netdev_open(pnetdev); 1117 else 1118 status = (_SUCCESS == ips_netdrv_open((struct adapter *)rtw_netdev_priv(pnetdev))) ? (0) : (-1); 1119 return status; 1120} 1121 1122int netdev_close(struct net_device *pnetdev) 1123{ 1124 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev); 1125 struct hal_data_8188e *rtlhal = GET_HAL_DATA(padapter); 1126 1127 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - drv_close\n")); 1128 1129 if (padapter->pwrctrlpriv.bInternalAutoSuspend) { 1130 if (padapter->pwrctrlpriv.rf_pwrstate == rf_off) 1131 padapter->pwrctrlpriv.ps_flag = true; 1132 } 1133 padapter->net_closed = true; 1134 1135 if (padapter->pwrctrlpriv.rf_pwrstate == rf_on) { 1136 DBG_88E("(2)88eu_drv - drv_close, bup =%d, hw_init_completed =%d\n", 1137 padapter->bup, padapter->hw_init_completed); 1138 1139 /* s1. */ 1140 if (pnetdev) { 1141 if (!rtw_netif_queue_stopped(pnetdev)) 1142 netif_tx_stop_all_queues(pnetdev); 1143 } 1144 1145 /* s2. */ 1146 LeaveAllPowerSaveMode(padapter); 1147 rtw_disassoc_cmd(padapter, 500, false); 1148 /* s2-2. indicate disconnect to os */ 1149 rtw_indicate_disconnect(padapter); 1150 /* s2-3. */ 1151 rtw_free_assoc_resources(padapter, 1); 1152 /* s2-4. */ 1153 rtw_free_network_queue(padapter, true); 1154 /* Close LED */ 1155 rtw_led_control(padapter, LED_CTL_POWER_OFF); 1156 } 1157 1158 kfree(rtlhal->pfirmware); 1159 rtlhal->pfirmware = NULL; 1160 1161 RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - drv_close\n")); 1162 DBG_88E("-88eu_drv - drv_close, bup =%d\n", padapter->bup); 1163 return 0; 1164} 1165