drivers/staging/rtl8188eu/os_dep/os_intfs.c

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