drivers/staging/r8188eu/os_dep/os_intfs.c

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