kernel/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  * 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 */
 171 void rtw_proc_remove_one(struct net_device *dev)
 172 {
 173 }
 174
 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
 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
 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
 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. */
 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
 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
 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(&eth_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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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 }