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