rtl8723bu/os_dep/linux/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 <drv_types.h>
  23 #include <hal_data.h>
  24
  25 #if defined (PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
  26
  27 #error "Shall be Linux or Windows, but not both!\n"
  28
  29 #endif
  30
  31
  32 MODULE_LICENSE("GPL");
  33 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
  34 MODULE_AUTHOR("Realtek Semiconductor Corp.");
  35 MODULE_VERSION(DRIVERVERSION);
  36
  37 /* module param defaults */
  38 int rtw_chip_version = 0x00;
  39 int rtw_rfintfs = HWPI;
  40 int rtw_lbkmode = 0;//RTL8712_AIR_TRX;
  41
  42
  43 int rtw_network_mode = Ndis802_11IBSS;//Ndis802_11Infrastructure;//infra, ad-hoc, auto
  44 //NDIS_802_11_SSID      ssid;
  45 int rtw_channel = 1;//ad-hoc support requirement
  46 int rtw_wireless_mode = WIRELESS_MODE_MAX;
  47 int rtw_vrtl_carrier_sense = AUTO_VCS;
  48 int rtw_vcs_type = RTS_CTS;//*
  49 int rtw_rts_thresh = 2347;//*
  50 int rtw_frag_thresh = 2346;//*
  51 int rtw_preamble = PREAMBLE_LONG;//long, short, auto
  52 int rtw_scan_mode = 1;//active, passive
  53 int rtw_adhoc_tx_pwr = 1;
  54 int rtw_soft_ap = 0;
  55 //int smart_ps = 1;
  56 #ifdef CONFIG_POWER_SAVING
  57 int rtw_power_mgnt = PS_MODE_MAX;
  58 #ifdef CONFIG_IPS_LEVEL_2
  59 int rtw_ips_mode = IPS_LEVEL_2;
  60 #else
  61 int rtw_ips_mode = IPS_NORMAL;
  62 #endif
  63 #else
  64 int rtw_power_mgnt = PS_MODE_ACTIVE;
  65 int rtw_ips_mode = IPS_NONE;
  66 #endif
  67 module_param(rtw_ips_mode, int, 0644);
  68 MODULE_PARM_DESC(rtw_ips_mode,"The default IPS mode");
  69
  70 int rtw_smart_ps = 2;
  71
  72 int rtw_check_fw_ps = 1;
  73
  74 #ifdef CONFIG_TX_EARLY_MODE
  75 int rtw_early_mode=1;
  76 #endif
  77
  78 int rtw_usb_rxagg_mode = 2;//USB_RX_AGG_DMA =1,USB_RX_AGG_USB=2
  79 module_param(rtw_usb_rxagg_mode, int, 0644);
  80
  81 int rtw_radio_enable = 1;
  82 int rtw_long_retry_lmt = 7;
  83 int rtw_short_retry_lmt = 7;
  84 int rtw_busy_thresh = 40;
  85 //int qos_enable = 0; //*
  86 int rtw_ack_policy = NORMAL_ACK;
  87
  88 int rtw_mp_mode = 0;
  89
  90 int rtw_software_encrypt = 0;
  91 int rtw_software_decrypt = 0;
  92
  93 int rtw_acm_method = 0;// 0:By SW 1:By HW.
  94
  95 int rtw_wmm_enable = 1;// default is set to enable the wmm.
  96 int rtw_uapsd_enable = 0;
  97 int rtw_uapsd_max_sp = NO_LIMIT;
  98 int rtw_uapsd_acbk_en = 0;
  99 int rtw_uapsd_acbe_en = 0;
 100 int rtw_uapsd_acvi_en = 0;
 101 int rtw_uapsd_acvo_en = 0;
 102 #ifdef CONFIG_RTL8814A
 103 int rtw_rfkfree_enable = 2; /* disable kfree */
 104 #else
 105 int rtw_rfkfree_enable = 0; /* Default Enalbe kfree by efuse config */
 106 #endif
 107 #ifdef CONFIG_80211N_HT
 108 int rtw_ht_enable = 1;
 109 // 0: 20 MHz, 1: 40 MHz, 2: 80 MHz, 3: 160MHz, 4: 80+80MHz
 110 // 2.4G use bit 0 ~ 3, 5G use bit 4 ~ 7
 111 // 0x21 means enable 2.4G 40MHz & 5G 80MHz
 112 int rtw_bw_mode = 0x21;
 113 int rtw_ampdu_enable = 1;//for enable tx_ampdu ,// 0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec)
 114 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
 115 int rtw_ampdu_amsdu = 0;// 0: disabled, 1:enabled, 2:auto . There is an IOT issu with DLINK DIR-629 when the flag turn on
 116 // Short GI support Bit Map
 117 // BIT0 - 20MHz, 0: non-support, 1: support
 118 // BIT1 - 40MHz, 0: non-support, 1: support
 119 // BIT2 - 80MHz, 0: non-support, 1: support
 120 // BIT3 - 160MHz, 0: non-support, 1: support
 121 int rtw_short_gi = 0xf;
 122 // BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx
 123 int rtw_ldpc_cap = 0x00;
 124 // BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx
 125 int rtw_stbc_cap = 0x13;
 126 // BIT0: Enable VHT Beamformer, BIT1: Enable VHT Beamformee, BIT4: Enable HT Beamformer, BIT5: Enable HT Beamformee
 127 int rtw_beamform_cap = 0x2;
 128 int rtw_bfer_rf_number = 0; /*BeamformerCapRfNum Rf path number, 0 for auto, others for manual*/
 129 int rtw_bfee_rf_number = 0; /*BeamformeeCapRfNum  Rf path number, 0 for auto, others for manual*/
 130
 131 #endif //CONFIG_80211N_HT
 132
 133
 134 int rtw_lowrate_two_xmit = 1;//Use 2 path Tx to transmit MCS0~7 and legacy mode
 135
 136 //int rf_config = RF_1T2R;  // 1T2R
 137 int rtw_rf_config = RF_MAX_TYPE;  //auto
 138
 139 int rtw_low_power = 0;
 140 #ifdef CONFIG_WIFI_TEST
 141 int rtw_wifi_spec = 1;//for wifi test
 142 #else
 143 int rtw_wifi_spec = 0;
 144 #endif
 145
 146 int rtw_special_rf_path = 0; //0: 2T2R ,1: only turn on path A 1T1R
 147
 148 char rtw_country_unspecified[] = {0xFF, 0xFF, 0x00};
 149 char *rtw_country_code = rtw_country_unspecified;
 150 module_param(rtw_country_code, charp, 0644);
 151 MODULE_PARM_DESC(rtw_country_code, "The default country code (in alpha2)");
 152
 153 int rtw_channel_plan = RTW_CHPLAN_MAX;
 154 module_param(rtw_channel_plan, int, 0644);
 155 MODULE_PARM_DESC(rtw_channel_plan, "The default chplan ID when rtw_alpha2 is not specified or valid");
 156
 157 /*if concurrent softap + p2p(GO) is needed, this param lets p2p response full channel list.
 158 But Softap must be SHUT DOWN once P2P decide to set up connection and become a GO.*/
 159 #ifdef CONFIG_FULL_CH_IN_P2P_HANDSHAKE
 160 int rtw_full_ch_in_p2p_handshake = 1; /* reply full channel list*/
 161 #else
 162 int rtw_full_ch_in_p2p_handshake = 0; /* reply only softap channel*/
 163 #endif
 164
 165 #ifdef CONFIG_BT_COEXIST
 166 int rtw_btcoex_enable = 1;
 167 module_param(rtw_btcoex_enable, int, 0644);
 168 MODULE_PARM_DESC(rtw_btcoex_enable, "Enable BT co-existence mechanism");
 169 int rtw_bt_iso = 2;// 0:Low, 1:High, 2:From Efuse
 170 int rtw_bt_sco = 3;// 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter, 4.Busy, 5.OtherBusy
 171 int rtw_bt_ampdu =1 ;// 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU.
 172 int rtw_ant_num = -1; // <0: undefined, >0: Antenna number
 173 module_param(rtw_ant_num, int, 0644);
 174 MODULE_PARM_DESC(rtw_ant_num, "Antenna number setting");
 175 #endif
 176
 177 int rtw_AcceptAddbaReq = _TRUE;// 0:Reject AP's Add BA req, 1:Accept AP's Add BA req.
 178
 179 int rtw_antdiv_cfg = 2; // 0:OFF , 1:ON, 2:decide by Efuse config
 180 int rtw_antdiv_type = 0 ; //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)
 181
 182 int rtw_switch_usb3 = _FALSE; /* _FALSE: doesn't switch, _TRUE: switch from usb2.0 to usb 3.0 */
 183
 184 #ifdef CONFIG_USB_AUTOSUSPEND
 185 int rtw_enusbss = 1;//0:disable,1:enable
 186 #else
 187 int rtw_enusbss = 0;//0:disable,1:enable
 188 #endif
 189
 190 int rtw_hwpdn_mode=2;//0:disable,1:enable,2: by EFUSE config
 191
 192 #ifdef CONFIG_HW_PWRP_DETECTION
 193 int rtw_hwpwrp_detect = 1;
 194 #else
 195 int rtw_hwpwrp_detect = 0; //HW power  ping detect 0:disable , 1:enable
 196 #endif
 197
 198 #ifdef CONFIG_USB_HCI
 199 int rtw_hw_wps_pbc = 1;
 200 #else
 201 int rtw_hw_wps_pbc = 0;
 202 #endif
 203
 204 #ifdef CONFIG_TX_MCAST2UNI
 205 int rtw_mc2u_disable = 0;
 206 #endif  // CONFIG_TX_MCAST2UNI
 207
 208 #ifdef CONFIG_80211D
 209 int rtw_80211d = 0;
 210 #endif
 211
 212 #ifdef CONFIG_SPECIAL_SETTING_FOR_FUNAI_TV
 213 int rtw_force_ant = 2;//0 :normal, 1:Main ant, 2:Aux ant
 214 int rtw_force_igi =0;//0 :normal
 215 module_param(rtw_force_ant, int, 0644);
 216 module_param(rtw_force_igi, int, 0644);
 217 #endif
 218
 219 #ifdef CONFIG_QOS_OPTIMIZATION
 220 int rtw_qos_opt_enable=1;//0: disable,1:enable
 221 #else
 222 int rtw_qos_opt_enable=0;//0: disable,1:enable
 223 #endif
 224 module_param(rtw_qos_opt_enable,int,0644);
 225
 226 #ifdef CONFIG_AUTO_CHNL_SEL_NHM
 227 int rtw_acs_mode = 1; /*0:disable, 1:enable*/
 228 module_param(rtw_acs_mode, int, 0644);
 229
 230 int rtw_acs_auto_scan = 0; /*0:disable, 1:enable*/
 231 module_param(rtw_acs_auto_scan, int, 0644);
 232
 233 #endif
 234
 235 char* ifname = "wlan%d";
 236 module_param(ifname, charp, 0644);
 237 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
 238
 239 #ifdef CONFIG_PLATFORM_ANDROID
 240 char* if2name = "p2p%d";
 241 #else //CONFIG_PLATFORM_ANDROID
 242 char* if2name = "wlan%d";
 243 #endif //CONFIG_PLATFORM_ANDROID
 244 module_param(if2name, charp, 0644);
 245 MODULE_PARM_DESC(if2name, "The default name to allocate for second interface");
 246
 247 char* rtw_initmac = 0;  // temp mac address if users want to use instead of the mac address in Efuse
 248
 249 #ifdef CONFIG_MULTI_VIR_IFACES
 250 int rtw_ext_iface_num  = 1;//primary/secondary iface is excluded
 251 module_param(rtw_ext_iface_num, int, 0644);
 252 #endif //CONFIG_MULTI_VIR_IFACES
 253
 254 module_param(rtw_rfkfree_enable, int, 0644);
 255 module_param(rtw_initmac, charp, 0644);
 256 module_param(rtw_special_rf_path, int, 0644);
 257 module_param(rtw_chip_version, int, 0644);
 258 module_param(rtw_rfintfs, int, 0644);
 259 module_param(rtw_lbkmode, int, 0644);
 260 module_param(rtw_network_mode, int, 0644);
 261 module_param(rtw_channel, int, 0644);
 262 module_param(rtw_wmm_enable, int, 0644);
 263 module_param(rtw_vrtl_carrier_sense, int, 0644);
 264 module_param(rtw_vcs_type, int, 0644);
 265 module_param(rtw_busy_thresh, int, 0644);
 266
 267 #ifdef CONFIG_80211N_HT
 268 module_param(rtw_ht_enable, int, 0644);
 269 module_param(rtw_bw_mode, int, 0644);
 270 module_param(rtw_ampdu_enable, int, 0644);
 271 module_param(rtw_rx_stbc, int, 0644);
 272 module_param(rtw_ampdu_amsdu, int, 0644);
 273 #endif //CONFIG_80211N_HT
 274 module_param(rtw_lowrate_two_xmit, int, 0644);
 275
 276 module_param(rtw_rf_config, int, 0644);
 277 module_param(rtw_power_mgnt, int, 0644);
 278 module_param(rtw_smart_ps, int, 0644);
 279 module_param(rtw_low_power, int, 0644);
 280 module_param(rtw_wifi_spec, int, 0644);
 281
 282 module_param(rtw_full_ch_in_p2p_handshake, int, 0644);
 283 module_param(rtw_antdiv_cfg, int, 0644);
 284 module_param(rtw_antdiv_type, int, 0644);
 285
 286 module_param(rtw_switch_usb3, int, 0644);
 287
 288 module_param(rtw_enusbss, int, 0644);
 289 module_param(rtw_hwpdn_mode, int, 0644);
 290 module_param(rtw_hwpwrp_detect, int, 0644);
 291
 292 module_param(rtw_hw_wps_pbc, int, 0644);
 293
 294 #ifdef CONFIG_TX_EARLY_MODE
 295 module_param(rtw_early_mode, int, 0644);
 296 #endif
 297 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
 298 char *rtw_adaptor_info_caching_file_path= "/data/misc/wifi/rtw_cache";
 299 module_param(rtw_adaptor_info_caching_file_path, charp, 0644);
 300 MODULE_PARM_DESC(rtw_adaptor_info_caching_file_path, "The path of adapter info cache file");
 301 #endif //CONFIG_ADAPTOR_INFO_CACHING_FILE
 302
 303 #ifdef CONFIG_IOL
 304 int rtw_fw_iol=1;
 305 module_param(rtw_fw_iol, int, 0644);
 306 MODULE_PARM_DESC(rtw_fw_iol, "FW IOL. 0:Disable, 1:enable, 2:by usb speed");
 307 #endif //CONFIG_IOL
 308
 309 #ifdef CONFIG_TX_MCAST2UNI
 310 module_param(rtw_mc2u_disable, int, 0644);
 311 #endif  // CONFIG_TX_MCAST2UNI
 312
 313 #ifdef CONFIG_80211D
 314 module_param(rtw_80211d, int, 0644);
 315 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
 316 #endif
 317
 318 uint rtw_notch_filter = RTW_NOTCH_FILTER;
 319 module_param(rtw_notch_filter, uint, 0644);
 320 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
 321
 322 uint rtw_hiq_filter = CONFIG_RTW_HIQ_FILTER;
 323 module_param(rtw_hiq_filter, uint, 0644);
 324 MODULE_PARM_DESC(rtw_hiq_filter, "0:allow all, 1:allow special, 2:deny all");
 325
 326 uint rtw_adaptivity_en = CONFIG_RTW_ADAPTIVITY_EN;
 327 module_param(rtw_adaptivity_en, uint, 0644);
 328 MODULE_PARM_DESC(rtw_adaptivity_en, "0:disable, 1:enable");
 329
 330 uint rtw_adaptivity_mode = CONFIG_RTW_ADAPTIVITY_MODE;
 331 module_param(rtw_adaptivity_mode, uint, 0644);
 332 MODULE_PARM_DESC(rtw_adaptivity_mode, "0:normal, 1:carrier sense");
 333
 334 uint rtw_adaptivity_dml = CONFIG_RTW_ADAPTIVITY_DML;
 335 module_param(rtw_adaptivity_dml, uint, 0644);
 336 MODULE_PARM_DESC(rtw_adaptivity_dml, "0:disable, 1:enable");
 337
 338 uint rtw_adaptivity_dc_backoff = CONFIG_RTW_ADAPTIVITY_DC_BACKOFF;
 339 module_param(rtw_adaptivity_dc_backoff, uint, 0644);
 340 MODULE_PARM_DESC(rtw_adaptivity_dc_backoff, "DC backoff for Adaptivity");
 341
 342 int rtw_adaptivity_th_l2h_ini = CONFIG_RTW_ADAPTIVITY_TH_L2H_INI;
 343 module_param(rtw_adaptivity_th_l2h_ini, int, 0644);
 344 MODULE_PARM_DESC(rtw_adaptivity_th_l2h_ini, "TH_L2H_ini for Adaptivity");
 345
 346 int rtw_adaptivity_th_edcca_hl_diff = CONFIG_RTW_ADAPTIVITY_TH_EDCCA_HL_DIFF;
 347 module_param(rtw_adaptivity_th_edcca_hl_diff, int, 0644);
 348 MODULE_PARM_DESC(rtw_adaptivity_th_edcca_hl_diff, "TH_EDCCA_HL_diff for Adaptivity");
 349
 350 uint rtw_amplifier_type_2g = CONFIG_RTW_AMPLIFIER_TYPE_2G;
 351 module_param(rtw_amplifier_type_2g, uint, 0644);
 352 MODULE_PARM_DESC(rtw_amplifier_type_2g, "BIT3:2G ext-PA, BIT4:2G ext-LNA");
 353
 354 uint rtw_amplifier_type_5g = CONFIG_RTW_AMPLIFIER_TYPE_5G;
 355 module_param(rtw_amplifier_type_5g, uint, 0644);
 356 MODULE_PARM_DESC(rtw_amplifier_type_5g, "BIT6:5G ext-PA, BIT7:5G ext-LNA");
 357
 358 uint rtw_RFE_type = CONFIG_RTW_RFE_TYPE;
 359 module_param(rtw_RFE_type, uint, 0644);
 360 MODULE_PARM_DESC(rtw_RFE_type, "default init value:64");
 361
 362 uint rtw_GLNA_type = CONFIG_RTW_GLNA_TYPE;
 363 module_param(rtw_GLNA_type, uint, 0644);
 364 MODULE_PARM_DESC(rtw_GLNA_type, "default init value:0");
 365
 366 uint rtw_TxBBSwing_2G = 0xFF;
 367 module_param(rtw_TxBBSwing_2G, uint, 0644);
 368 MODULE_PARM_DESC(rtw_TxBBSwing_2G, "default init value:0xFF");
 369
 370 uint rtw_TxBBSwing_5G = 0xFF;
 371 module_param(rtw_TxBBSwing_5G, uint, 0644);
 372 MODULE_PARM_DESC(rtw_TxBBSwing_5G, "default init value:0xFF");
 373
 374 uint rtw_OffEfuseMask = 0;
 375 module_param(rtw_OffEfuseMask, uint, 0644);
 376 MODULE_PARM_DESC(rtw_OffEfuseMask, "default open Efuse Mask value:0");
 377
 378 uint rtw_FileMaskEfuse = 0;
 379 module_param(rtw_FileMaskEfuse, uint, 0644);
 380 MODULE_PARM_DESC(rtw_FileMaskEfuse, "default drv Mask Efuse value:0");
 381
 382 uint rtw_kfree = 0;
 383 module_param(rtw_kfree, uint, 0644);
 384 MODULE_PARM_DESC(rtw_kfree, "default kfree config value:0");
 385
 386 uint rtw_rxgain_offset_2g = 0;
 387 module_param(rtw_rxgain_offset_2g, uint, 0644);
 388 MODULE_PARM_DESC(rtw_rxgain_offset_2g, "default RF Gain 2G Offset value:0");
 389
 390 uint rtw_rxgain_offset_5gl = 0;
 391 module_param(rtw_rxgain_offset_5gl, uint, 0644);
 392 MODULE_PARM_DESC(rtw_rxgain_offset_5gl, "default RF Gain 5GL Offset value:0");
 393
 394 uint rtw_rxgain_offset_5gm = 0;
 395 module_param(rtw_rxgain_offset_5gm, uint, 0644);
 396 MODULE_PARM_DESC(rtw_rxgain_offset_5gm, "default RF Gain 5GM Offset value:0");
 397
 398 uint rtw_rxgain_offset_5gh = 0;
 399 module_param(rtw_rxgain_offset_5gh, uint, 0644);
 400 MODULE_PARM_DESC(rtw_rxgain_offset_5gm, "default RF Gain 5GL Offset value:0");
 401
 402
 403 uint rtw_pll_ref_clk_sel = CONFIG_RTW_PLL_REF_CLK_SEL;
 404 module_param(rtw_pll_ref_clk_sel, uint, 0644);
 405 MODULE_PARM_DESC(rtw_pll_ref_clk_sel, "force pll_ref_clk_sel, 0xF:use autoload value");
 406
 407 #if defined(CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY) //eFuse: Regulatory selection=1
 408 int rtw_tx_pwr_lmt_enable = 1;
 409 int rtw_tx_pwr_by_rate = 1;
 410 #elif defined(CONFIG_CALIBRATE_TX_POWER_TO_MAX)//eFuse: Regulatory selection=0
 411 int rtw_tx_pwr_lmt_enable = 0;
 412 int rtw_tx_pwr_by_rate = 1;
 413 #else //eFuse: Regulatory selection=2
 414 #ifdef CONFIG_PCI_HCI
 415 int rtw_tx_pwr_lmt_enable = 2; // 2- Depend on efuse
 416 int rtw_tx_pwr_by_rate = 2;// 2- Depend on efuse
 417 #else // USB & SDIO
 418 int rtw_tx_pwr_lmt_enable = 0;
 419 int rtw_tx_pwr_by_rate = 0;
 420 #endif
 421 #endif
 422
 423 module_param(rtw_tx_pwr_lmt_enable, int, 0644);
 424 MODULE_PARM_DESC(rtw_tx_pwr_lmt_enable,"0:Disable, 1:Enable, 2: Depend on efuse");
 425
 426 module_param(rtw_tx_pwr_by_rate, int, 0644);
 427 MODULE_PARM_DESC(rtw_tx_pwr_by_rate,"0:Disable, 1:Enable, 2: Depend on efuse");
 428
 429 int _netdev_open(struct net_device *pnetdev);
 430 int netdev_open (struct net_device *pnetdev);
 431 static int netdev_close (struct net_device *pnetdev);
 432 #ifdef CONFIG_PLATFORM_INTEL_BYT
 433 extern int rtw_sdio_set_power(int on);
 434 #endif //CONFIG_PLATFORM_INTEL_BYT
 435
 436 uint loadparam(_adapter *padapter)
 437 {
 438         uint status = _SUCCESS;
 439         struct registry_priv  *registry_par = &padapter->registrypriv;
 440
 441 _func_enter_;
 442
 443         registry_par->chip_version = (u8)rtw_chip_version;
 444         registry_par->rfintfs = (u8)rtw_rfintfs;
 445         registry_par->lbkmode = (u8)rtw_lbkmode;
 446         //registry_par->hci = (u8)hci;
 447         registry_par->network_mode  = (u8)rtw_network_mode;
 448
 449         _rtw_memcpy(registry_par->ssid.Ssid, "ANY", 3);
 450         registry_par->ssid.SsidLength = 3;
 451
 452         registry_par->channel = (u8)rtw_channel;
 453         registry_par->wireless_mode = (u8)rtw_wireless_mode;
 454
 455         if (IsSupported24G(registry_par->wireless_mode) && (!IsSupported5G(registry_par->wireless_mode))
 456                 && (registry_par->channel > 14)) {
 457                 registry_par->channel = 1;
 458         }
 459         else if (IsSupported5G(registry_par->wireless_mode) && (!IsSupported24G(registry_par->wireless_mode))
 460                 && (registry_par->channel <= 14)) {
 461                 registry_par->channel = 36;
 462         }
 463
 464         registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense ;
 465         registry_par->vcs_type = (u8)rtw_vcs_type;
 466         registry_par->rts_thresh=(u16)rtw_rts_thresh;
 467         registry_par->frag_thresh=(u16)rtw_frag_thresh;
 468         registry_par->preamble = (u8)rtw_preamble;
 469         registry_par->scan_mode = (u8)rtw_scan_mode;
 470         registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
 471         registry_par->soft_ap=  (u8)rtw_soft_ap;
 472         registry_par->smart_ps =  (u8)rtw_smart_ps;
 473         registry_par->check_fw_ps = (u8)rtw_check_fw_ps;
 474         registry_par->power_mgnt = (u8)rtw_power_mgnt;
 475         registry_par->ips_mode = (u8)rtw_ips_mode;
 476         registry_par->radio_enable = (u8)rtw_radio_enable;
 477         registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
 478         registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
 479         registry_par->busy_thresh = (u16)rtw_busy_thresh;
 480         //registry_par->qos_enable = (u8)rtw_qos_enable;
 481         registry_par->ack_policy = (u8)rtw_ack_policy;
 482         registry_par->software_encrypt = (u8)rtw_software_encrypt;
 483         registry_par->software_decrypt = (u8)rtw_software_decrypt;
 484
 485         registry_par->acm_method = (u8)rtw_acm_method;
 486         registry_par->usb_rxagg_mode = (u8)rtw_usb_rxagg_mode;
 487
 488          //UAPSD
 489         registry_par->wmm_enable = (u8)rtw_wmm_enable;
 490         registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
 491         registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
 492         registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
 493         registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
 494         registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
 495         registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
 496
 497         registry_par->RegRfKFreeEnable = (u8)rtw_rfkfree_enable;
 498
 499 #ifdef CONFIG_80211N_HT
 500         registry_par->ht_enable = (u8)rtw_ht_enable;
 501         registry_par->bw_mode = (u8)rtw_bw_mode;
 502         registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
 503         registry_par->rx_stbc = (u8)rtw_rx_stbc;
 504         registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
 505         registry_par->short_gi = (u8)rtw_short_gi;
 506         registry_par->ldpc_cap = (u8)rtw_ldpc_cap;
 507         registry_par->stbc_cap = (u8)rtw_stbc_cap;
 508         registry_par->beamform_cap = (u8)rtw_beamform_cap;
 509         registry_par->beamformer_rf_num = (u8)rtw_bfer_rf_number;
 510         registry_par->beamformee_rf_num = (u8)rtw_bfee_rf_number;
 511 #endif
 512
 513
 514 #ifdef CONFIG_TX_EARLY_MODE
 515         registry_par->early_mode = (u8)rtw_early_mode;
 516 #endif
 517         registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
 518         registry_par->rf_config = (u8)rtw_rf_config;
 519         registry_par->low_power = (u8)rtw_low_power;
 520
 521
 522         registry_par->wifi_spec = (u8)rtw_wifi_spec;
 523
 524         if (strlen(rtw_country_code) != 2
 525                 || is_alpha(rtw_country_code[0]) == _FALSE
 526                 || is_alpha(rtw_country_code[1]) == _FALSE
 527         ) {
 528                 if (rtw_country_code != rtw_country_unspecified)
 529                         DBG_871X_LEVEL(_drv_err_, "%s discard rtw_country_code not in alpha2\n", __func__);
 530                 _rtw_memset(registry_par->alpha2, 0xFF, 2);
 531         } else
 532                 _rtw_memcpy(registry_par->alpha2, rtw_country_code, 2);
 533
 534         registry_par->channel_plan = (u8)rtw_channel_plan;
 535         registry_par->special_rf_path = (u8)rtw_special_rf_path;
 536
 537         registry_par->full_ch_in_p2p_handshake = (u8)rtw_full_ch_in_p2p_handshake;
 538 #ifdef CONFIG_BT_COEXIST
 539         registry_par->btcoex = (u8)rtw_btcoex_enable;
 540         registry_par->bt_iso = (u8)rtw_bt_iso;
 541         registry_par->bt_sco = (u8)rtw_bt_sco;
 542         registry_par->bt_ampdu = (u8)rtw_bt_ampdu;
 543         registry_par->ant_num = (s8)rtw_ant_num;
 544 #endif
 545
 546         registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq;
 547
 548         registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
 549         registry_par->antdiv_type = (u8)rtw_antdiv_type;
 550
 551         registry_par->switch_usb3 = (u8)rtw_switch_usb3;
 552
 553 #ifdef CONFIG_AUTOSUSPEND
 554         registry_par->usbss_enable = (u8)rtw_enusbss;//0:disable,1:enable
 555 #endif
 556 #ifdef SUPPORT_HW_RFOFF_DETECTED
 557         registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;//0:disable,1:enable,2:by EFUSE config
 558         registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;//0:disable,1:enable
 559 #endif
 560
 561         registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
 562
 563 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
 564         snprintf(registry_par->adaptor_info_caching_file_path, PATH_LENGTH_MAX, "%s", rtw_adaptor_info_caching_file_path);
 565         registry_par->adaptor_info_caching_file_path[PATH_LENGTH_MAX-1]=0;
 566 #endif
 567
 568 #ifdef CONFIG_IOL
 569         registry_par->fw_iol = rtw_fw_iol;
 570 #endif
 571
 572 #ifdef CONFIG_80211D
 573         registry_par->enable80211d = (u8)rtw_80211d;
 574 #endif
 575
 576         snprintf(registry_par->ifname, 16, "%s", ifname);
 577         snprintf(registry_par->if2name, 16, "%s", if2name);
 578
 579         registry_par->notch_filter = (u8)rtw_notch_filter;
 580
 581 #ifdef CONFIG_SPECIAL_SETTING_FOR_FUNAI_TV
 582         registry_par->force_ant = (u8)rtw_force_ant;
 583         registry_par->force_igi = (u8)rtw_force_igi;
 584 #endif
 585
 586 #ifdef CONFIG_MULTI_VIR_IFACES
 587         registry_par->ext_iface_num = (u8)rtw_ext_iface_num;
 588 #endif //CONFIG_MULTI_VIR_IFACES
 589
 590         registry_par->pll_ref_clk_sel = (u8)rtw_pll_ref_clk_sel;
 591
 592         registry_par->RegEnableTxPowerLimit = (u8)rtw_tx_pwr_lmt_enable;
 593         registry_par->RegEnableTxPowerByRate = (u8)rtw_tx_pwr_by_rate;
 594
 595         registry_par->RegPowerBase = 14;
 596         registry_par->TxBBSwing_2G = (s8)rtw_TxBBSwing_2G;
 597         registry_par->TxBBSwing_5G = (s8)rtw_TxBBSwing_5G;
 598         registry_par->bEn_RFE = 1;
 599         registry_par->RFE_Type = (u8)rtw_RFE_type;
 600         registry_par->AmplifierType_2G = (u8)rtw_amplifier_type_2g;
 601         registry_par->AmplifierType_5G = (u8)rtw_amplifier_type_5g;
 602         registry_par->GLNA_Type = (u8)rtw_GLNA_type;
 603         registry_par->qos_opt_enable = (u8)rtw_qos_opt_enable;
 604
 605         registry_par->hiq_filter = (u8)rtw_hiq_filter;
 606
 607         registry_par->adaptivity_en = (u8)rtw_adaptivity_en;
 608         registry_par->adaptivity_mode = (u8)rtw_adaptivity_mode;
 609         registry_par->adaptivity_dml = (u8)rtw_adaptivity_dml;
 610         registry_par->adaptivity_dc_backoff = (u8)rtw_adaptivity_dc_backoff;
 611         registry_par->adaptivity_th_l2h_ini = (s8)rtw_adaptivity_th_l2h_ini;
 612         registry_par->adaptivity_th_edcca_hl_diff = (s8)rtw_adaptivity_th_edcca_hl_diff;
 613
 614         registry_par->boffefusemask = (u8)rtw_OffEfuseMask;
 615         registry_par->bFileMaskEfuse = (u8)rtw_FileMaskEfuse;
 616 #ifdef CONFIG_AUTO_CHNL_SEL_NHM
 617         registry_par->acs_mode = (u8)rtw_acs_mode;
 618         registry_par->acs_auto_scan = (u8)rtw_acs_auto_scan;
 619 #endif
 620         registry_par->reg_rxgain_offset_2g = (u32) rtw_rxgain_offset_2g;
 621         registry_par->reg_rxgain_offset_5gl = (u32) rtw_rxgain_offset_5gl;
 622         registry_par->reg_rxgain_offset_5gm = (u32) rtw_rxgain_offset_5gm;
 623         registry_par->reg_rxgain_offset_5gh = (u32) rtw_rxgain_offset_5gh;
 624 _func_exit_;
 625
 626         return status;
 627 }
 628
 629 /**
 630  * rtw_net_set_mac_address
 631  * This callback function is used for the Media Access Control address
 632  * of each net_device needs to be changed.
 633  *
 634  * Arguments:
 635  * @pnetdev: net_device pointer.
 636  * @addr: new MAC address.
 637  *
 638  * Return:
 639  * ret = 0: Permit to change net_device's MAC address.
 640  * ret = -1 (Default): Operation not permitted.
 641  *
 642  * Auther: Arvin Liu
 643  * Date: 2015/05/29
 644  */
 645 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *addr)
 646 {
 647         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
 648         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 649         struct sockaddr *sa = (struct sockaddr *)addr;
 650         int ret = -1;
 651
 652         /* only the net_device is in down state to permit modifying mac addr */
 653         if ((pnetdev->flags & IFF_UP) == _TRUE) {
 654                 DBG_871X(FUNC_ADPT_FMT": The net_device's is not in down state\n"
 655                         , FUNC_ADPT_ARG(padapter));
 656
 657                 return ret;
 658         }
 659
 660         /* if the net_device is linked, it's not permit to modify mac addr */
 661         if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) ||
 662                 check_fwstate(pmlmepriv, _FW_LINKED) ||
 663                 check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
 664                 DBG_871X(FUNC_ADPT_FMT": The net_device's is not idle currently\n"
 665                         , FUNC_ADPT_ARG(padapter));
 666
 667                 return ret;
 668         }
 669
 670         /* check whether the input mac address is valid to permit modifying mac addr */
 671         if (rtw_check_invalid_mac_address(sa->sa_data, _FALSE) == _TRUE) {
 672                 DBG_871X(FUNC_ADPT_FMT": Invalid Mac Addr for "MAC_FMT"\n"
 673                         , FUNC_ADPT_ARG(padapter), MAC_ARG(sa->sa_data));
 674
 675                 return ret;
 676         }
 677
 678         _rtw_memcpy(adapter_mac_addr(padapter), sa->sa_data, ETH_ALEN); /* set mac addr to adapter */
 679         _rtw_memcpy(pnetdev->dev_addr, sa->sa_data, ETH_ALEN); /* set mac addr to net_device */
 680
 681         rtw_ps_deny(padapter, PS_DENY_IOCTL);
 682         LeaveAllPowerSaveModeDirect(padapter); /* leave PS mode for guaranteeing to access hw register successfully */
 683         rtw_hal_set_hwreg(padapter, HW_VAR_MAC_ADDR, sa->sa_data); /* set mac addr to mac register */
 684         rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
 685
 686         DBG_871X(FUNC_ADPT_FMT": Set Mac Addr to "MAC_FMT" Successfully\n"
 687                 , FUNC_ADPT_ARG(padapter), MAC_ARG(sa->sa_data));
 688
 689         ret = 0;
 690
 691         return ret;
 692 }
 693
 694 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
 695 {
 696         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
 697         struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
 698         struct recv_priv *precvpriv = &(padapter->recvpriv);
 699
 700         padapter->stats.tx_packets = pxmitpriv->tx_pkts;//pxmitpriv->tx_pkts++;
 701         padapter->stats.rx_packets = precvpriv->rx_pkts;//precvpriv->rx_pkts++;
 702         padapter->stats.tx_dropped = pxmitpriv->tx_drop;
 703         padapter->stats.rx_dropped = precvpriv->rx_drop;
 704         padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
 705         padapter->stats.rx_bytes = precvpriv->rx_bytes;
 706
 707         return &padapter->stats;
 708 }
 709
 710 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
 711 /*
 712  * AC to queue mapping
 713  *
 714  * AC_VO -> queue 0
 715  * AC_VI -> queue 1
 716  * AC_BE -> queue 2
 717  * AC_BK -> queue 3
 718  */
 719 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
 720
 721 /* Given a data frame determine the 802.1p/1d tag to use. */
 722 unsigned int rtw_classify8021d(struct sk_buff *skb)
 723 {
 724         unsigned int dscp;
 725
 726         /* skb->priority values from 256->263 are magic values to
 727          * directly indicate a specific 802.1d priority.  This is used
 728          * to allow 802.1d priority to be passed directly in from VLAN
 729          * tags, etc.
 730          */
 731         if (skb->priority >= 256 && skb->priority <= 263)
 732                 return skb->priority - 256;
 733
 734         switch (skb->protocol) {
 735         case htons(ETH_P_IP):
 736                 dscp = ip_hdr(skb)->tos & 0xfc;
 737                 break;
 738         default:
 739                 return 0;
 740         }
 741
 742         return dscp >> 5;
 743 }
 744
 745
 746 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb
 747 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 13, 0)
 748 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0)
 749                                 , struct net_device *sb_dev
 750 #else
 751                                 , void *accel_priv
 752 #endif
 753 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) && (LINUX_VERSION_CODE < KERNEL_VERSION(5, 2, 0))
 754                                 , select_queue_fallback_t fallback
 755 #endif
 756 #endif
 757 )
 758 {
 759         _adapter        *padapter = rtw_netdev_priv(dev);
 760         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 761
 762         skb->priority = rtw_classify8021d(skb);
 763
 764         if(pmlmepriv->acm_mask != 0)
 765         {
 766                 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
 767         }
 768
 769         return rtw_1d_to_queue[skb->priority];
 770 }
 771
 772 u16 rtw_recv_select_queue(struct sk_buff *skb)
 773 {
 774         struct iphdr *piphdr;
 775         unsigned int dscp;
 776         u16     eth_type;
 777         u32 priority;
 778         u8 *pdata = skb->data;
 779
 780         _rtw_memcpy(&eth_type, pdata+(ETH_ALEN<<1), 2);
 781
 782         switch (eth_type) {
 783                 case htons(ETH_P_IP):
 784
 785                         piphdr = (struct iphdr *)(pdata+ETH_HLEN);
 786
 787                         dscp = piphdr->tos & 0xfc;
 788
 789                         priority = dscp >> 5;
 790
 791                         break;
 792                 default:
 793                         priority = 0;
 794         }
 795
 796         return rtw_1d_to_queue[priority];
 797
 798 }
 799
 800 #endif
 801 static int rtw_ndev_notifier_call(struct notifier_block * nb, unsigned long state, void *ptr)
 802 {
 803 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,11,0))
 804         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 805 #else
 806         struct net_device *dev = ptr;
 807 #endif
 808
 809 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
 810         if (dev->netdev_ops->ndo_do_ioctl == NULL)
 811                 return NOTIFY_DONE;
 812
 813         if (dev->netdev_ops->ndo_do_ioctl != rtw_ioctl)
 814 #else
 815         if (dev->do_ioctl == NULL)
 816                 return NOTIFY_DONE;
 817
 818         if (dev->do_ioctl != rtw_ioctl)
 819 #endif
 820                 return NOTIFY_DONE;
 821
 822         DBG_871X_LEVEL(_drv_info_, FUNC_NDEV_FMT" state:%lu\n", FUNC_NDEV_ARG(dev), state);
 823
 824         return NOTIFY_DONE;
 825 }
 826
 827 static struct notifier_block rtw_ndev_notifier = {
 828         .notifier_call = rtw_ndev_notifier_call,
 829 };
 830
 831 int rtw_ndev_notifier_register(void)
 832 {
 833         return register_netdevice_notifier(&rtw_ndev_notifier);
 834 }
 835
 836 void rtw_ndev_notifier_unregister(void)
 837 {
 838         unregister_netdevice_notifier(&rtw_ndev_notifier);
 839 }
 840
 841
 842 int rtw_ndev_init(struct net_device *dev)
 843 {
 844         _adapter *adapter = rtw_netdev_priv(dev);
 845
 846         DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" if%d mac_addr="MAC_FMT"\n"
 847                 , FUNC_ADPT_ARG(adapter), (adapter->iface_id+1), MAC_ARG(dev->dev_addr));
 848         strncpy(adapter->old_ifname, dev->name, IFNAMSIZ);
 849         adapter->old_ifname[IFNAMSIZ-1] = '\0';
 850
 851         return 0;
 852 }
 853
 854 void rtw_ndev_uninit(struct net_device *dev)
 855 {
 856         _adapter *adapter = rtw_netdev_priv(dev);
 857
 858         DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" if%d\n"
 859                 , FUNC_ADPT_ARG(adapter), (adapter->iface_id+1));
 860 }
 861
 862 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
 863 static const struct net_device_ops rtw_netdev_ops = {
 864         .ndo_init = rtw_ndev_init,
 865         .ndo_uninit = rtw_ndev_uninit,
 866         .ndo_open = netdev_open,
 867         .ndo_stop = netdev_close,
 868         .ndo_start_xmit = rtw_xmit_entry,
 869 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
 870         .ndo_select_queue       = rtw_select_queue,
 871 #endif
 872         .ndo_set_mac_address = rtw_net_set_mac_address,
 873         .ndo_get_stats = rtw_net_get_stats,
 874         .ndo_do_ioctl = rtw_ioctl,
 875 };
 876 #endif
 877
 878 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
 879 {
 880         _adapter *padapter = rtw_netdev_priv(pnetdev);
 881
 882 #ifdef CONFIG_EASY_REPLACEMENT
 883         struct net_device       *TargetNetdev = NULL;
 884         _adapter                        *TargetAdapter = NULL;
 885         struct net              *devnet = NULL;
 886
 887         if(padapter->bDongle == 1)
 888         {
 889 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 890                 TargetNetdev = dev_get_by_name("wlan0");
 891 #else
 892         #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
 893                 devnet = pnetdev->nd_net;
 894         #else
 895                 devnet = dev_net(pnetdev);
 896         #endif
 897                 TargetNetdev = dev_get_by_name(devnet, "wlan0");
 898 #endif
 899                 if(TargetNetdev) {
 900                         DBG_871X("Force onboard module driver disappear !!!\n");
 901                         TargetAdapter = rtw_netdev_priv(TargetNetdev);
 902                         TargetAdapter->DriverState = DRIVER_DISAPPEAR;
 903
 904                         padapter->pid[0] = TargetAdapter->pid[0];
 905                         padapter->pid[1] = TargetAdapter->pid[1];
 906                         padapter->pid[2] = TargetAdapter->pid[2];
 907
 908                         dev_put(TargetNetdev);
 909                         unregister_netdev(TargetNetdev);
 910
 911                         padapter->DriverState = DRIVER_REPLACE_DONGLE;
 912                 }
 913         }
 914 #endif //CONFIG_EASY_REPLACEMENT
 915
 916         if(dev_alloc_name(pnetdev, ifname) < 0)
 917         {
 918                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("dev_alloc_name, fail! \n"));
 919         }
 920
 921         netif_carrier_off(pnetdev);
 922         //rtw_netif_stop_queue(pnetdev);
 923
 924         return 0;
 925 }
 926
 927 void rtw_hook_if_ops(struct net_device *ndev)
 928 {
 929 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
 930         ndev->netdev_ops = &rtw_netdev_ops;
 931 #else
 932         ndev->init = rtw_ndev_init;
 933         ndev->uninit = rtw_ndev_uninit;
 934         ndev->open = netdev_open;
 935         ndev->stop = netdev_close;
 936         ndev->hard_start_xmit = rtw_xmit_entry;
 937         ndev->set_mac_address = rtw_net_set_mac_address;
 938         ndev->get_stats = rtw_net_get_stats;
 939         ndev->do_ioctl = rtw_ioctl;
 940 #endif
 941 }
 942
 943 struct net_device *rtw_init_netdev(_adapter *old_padapter)
 944 {
 945         _adapter *padapter;
 946         struct net_device *pnetdev;
 947
 948         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+init_net_dev\n"));
 949
 950         if(old_padapter != NULL)
 951                 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(_adapter), (void *)old_padapter);
 952         else
 953                 pnetdev = rtw_alloc_etherdev(sizeof(_adapter));
 954
 955         if (!pnetdev)
 956                 return NULL;
 957
 958         padapter = rtw_netdev_priv(pnetdev);
 959         padapter->pnetdev = pnetdev;
 960
 961 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 962         SET_MODULE_OWNER(pnetdev);
 963 #endif
 964
 965         rtw_hook_if_ops(pnetdev);
 966
 967 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
 968         pnetdev->features |= NETIF_F_IP_CSUM;
 969 #endif
 970
 971         //pnetdev->tx_timeout = NULL;
 972         pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */
 973
 974 #ifdef CONFIG_WIRELESS_EXT
 975         pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
 976 #endif
 977
 978 #ifdef WIRELESS_SPY
 979         //priv->wireless_data.spy_data = &priv->spy_data;
 980         //pnetdev->wireless_data = &priv->wireless_data;
 981 #endif
 982
 983         return pnetdev;
 984 }
 985
 986 int rtw_os_ndev_alloc(_adapter *adapter)
 987 {
 988         int ret = _FAIL;
 989         struct net_device *ndev = NULL;
 990
 991         ndev = rtw_init_netdev(adapter);
 992         if (ndev == NULL) {
 993                 rtw_warn_on(1);
 994                 goto exit;
 995         }
 996         #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
 997         SET_NETDEV_DEV(ndev, dvobj_to_dev(adapter_to_dvobj(adapter)));
 998         #endif
 999
1000         #ifdef CONFIG_PCI_HCI
1001         if (adapter_to_dvobj(adapter)->bdma64)
1002                 ndev->features |= NETIF_F_HIGHDMA;
1003         ndev->irq = adapter_to_dvobj(adapter)->irq;
1004         #endif
1005
1006 #if defined(CONFIG_IOCTL_CFG80211)
1007         if (rtw_cfg80211_ndev_res_alloc(adapter) != _SUCCESS) {
1008                 rtw_warn_on(1);
1009                 goto free_ndev;
1010         }
1011 #endif
1012
1013         ret = _SUCCESS;
1014
1015 free_ndev:
1016         if (ret != _SUCCESS && ndev)
1017                 rtw_free_netdev(ndev);
1018 exit:
1019         return ret;
1020 }
1021
1022 void rtw_os_ndev_free(_adapter *adapter)
1023 {
1024 #if defined(CONFIG_IOCTL_CFG80211)
1025         rtw_cfg80211_ndev_res_free(adapter);
1026 #endif
1027
1028         if (adapter->pnetdev) {
1029                 rtw_free_netdev(adapter->pnetdev);
1030                 adapter->pnetdev = NULL;
1031         }
1032 }
1033
1034 int rtw_os_ndev_register(_adapter *adapter, char *name)
1035 {
1036         int ret = _SUCCESS;
1037         struct net_device *ndev = adapter->pnetdev;
1038
1039 #if defined(CONFIG_IOCTL_CFG80211)
1040         if (rtw_cfg80211_ndev_res_register(adapter) != _SUCCESS) {
1041                 rtw_warn_on(1);
1042                 ret = _FAIL;
1043                 goto exit;
1044         }
1045 #endif
1046
1047         /* alloc netdev name */
1048         rtw_init_netdev_name(ndev, name);
1049
1050         _rtw_memcpy(ndev->dev_addr, adapter_mac_addr(adapter), ETH_ALEN);
1051
1052         /* Tell the network stack we exist */
1053         if (register_netdev(ndev) != 0) {
1054                 DBG_871X(FUNC_NDEV_FMT" if%d Failed!\n", FUNC_NDEV_ARG(ndev), (adapter->iface_id+1));
1055                 ret = _FAIL;
1056         }
1057
1058 #if defined(CONFIG_IOCTL_CFG80211)
1059         if (ret != _SUCCESS) {
1060                 rtw_cfg80211_ndev_res_unregister(adapter);
1061                 #if !defined(RTW_SINGLE_WIPHY)
1062                 rtw_wiphy_unregister(adapter_to_wiphy(adapter));
1063                 #endif
1064         }
1065 #endif
1066
1067 exit:
1068         return ret;
1069 }
1070
1071 void rtw_os_ndev_unregister(_adapter *adapter)
1072 {
1073         struct net_device *netdev = NULL;
1074
1075         if (adapter == NULL)
1076                 return;
1077
1078         adapter->ndev_unregistering = 1;
1079
1080         netdev = adapter->pnetdev;
1081
1082 #if defined(CONFIG_IOCTL_CFG80211)
1083         rtw_cfg80211_ndev_res_unregister(adapter);
1084 #endif
1085
1086         if ((adapter->DriverState != DRIVER_DISAPPEAR) && netdev)
1087                 unregister_netdev(netdev); /* will call netdev_close() */
1088
1089 #if defined(CONFIG_IOCTL_CFG80211) && !defined(RTW_SINGLE_WIPHY)
1090         rtw_wiphy_unregister(adapter_to_wiphy(adapter));
1091 #endif
1092
1093         adapter->ndev_unregistering = 0;
1094 }
1095
1096 /**
1097  * rtw_os_ndev_init - Allocate and register OS layer net device and relating structures for @adapter
1098  * @adapter: the adapter on which this function applies
1099  * @name: the requesting net device name
1100  *
1101  * Returns:
1102  * _SUCCESS or _FAIL
1103  */
1104 int rtw_os_ndev_init(_adapter *adapter, char *name)
1105 {
1106         int ret = _FAIL;
1107
1108         if (rtw_os_ndev_alloc(adapter) != _SUCCESS)
1109                 goto exit;
1110
1111         if (rtw_os_ndev_register(adapter, name) != _SUCCESS)
1112                 goto os_ndev_free;
1113
1114         ret = _SUCCESS;
1115
1116 os_ndev_free:
1117         if (ret != _SUCCESS)
1118                 rtw_os_ndev_free(adapter);
1119 exit:
1120         return ret;
1121 }
1122
1123 /**
1124  * rtw_os_ndev_deinit - Unregister and free OS layer net device and relating structures for @adapter
1125  * @adapter: the adapter on which this function applies
1126  */
1127 void rtw_os_ndev_deinit(_adapter *adapter)
1128 {
1129         rtw_os_ndev_unregister(adapter);
1130         rtw_os_ndev_free(adapter);
1131 }
1132
1133 int rtw_os_ndevs_alloc(struct dvobj_priv *dvobj)
1134 {
1135         int i, status = _SUCCESS;
1136         _adapter *adapter;
1137
1138 #if defined(CONFIG_IOCTL_CFG80211)
1139         if (rtw_cfg80211_dev_res_alloc(dvobj) != _SUCCESS) {
1140                 rtw_warn_on(1);
1141                 status = _FAIL;
1142                 goto exit;
1143         }
1144 #endif
1145
1146         for (i = 0; i < dvobj->iface_nums; i++) {
1147
1148                 if (i >= IFACE_ID_MAX) {
1149                         DBG_871X_LEVEL(_drv_err_, "%s %d >= IFACE_ID_MAX\n", __func__, i);
1150                         rtw_warn_on(1);
1151                         continue;
1152                 }
1153
1154                 adapter = dvobj->padapters[i];
1155                 if (adapter && !adapter->pnetdev) {
1156                         status = rtw_os_ndev_alloc(adapter);
1157                         if (status != _SUCCESS) {
1158                                 rtw_warn_on(1);
1159                                 break;
1160                         }
1161                 }
1162         }
1163
1164         if (status != _SUCCESS) {
1165                 for (; i >= 0; i--) {
1166                         adapter = dvobj->padapters[i];
1167                         if (adapter && adapter->pnetdev)
1168                                 rtw_os_ndev_free(adapter);
1169                 }
1170         }
1171
1172 #if defined(CONFIG_IOCTL_CFG80211)
1173         if (status != _SUCCESS)
1174                 rtw_cfg80211_dev_res_free(dvobj);
1175 #endif
1176 exit:
1177         return status;
1178 }
1179
1180 void rtw_os_ndevs_free(struct dvobj_priv *dvobj)
1181 {
1182         int i;
1183         _adapter *adapter = NULL;
1184
1185         for (i = 0; i < dvobj->iface_nums; i++) {
1186
1187                 if (i >= IFACE_ID_MAX) {
1188                         DBG_871X_LEVEL(_drv_err_, "%s %d >= IFACE_ID_MAX\n", __func__, i);
1189                         rtw_warn_on(1);
1190                         continue;
1191                 }
1192
1193                 adapter = dvobj->padapters[i];
1194
1195                 if (adapter == NULL)
1196                         continue;
1197
1198                 rtw_os_ndev_free(adapter);
1199         }
1200
1201 #if defined(CONFIG_IOCTL_CFG80211)
1202         rtw_cfg80211_dev_res_free(dvobj);
1203 #endif
1204 }
1205
1206 u32 rtw_start_drv_threads(_adapter *padapter)
1207 {
1208         u32 _status = _SUCCESS;
1209
1210         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_start_drv_threads\n"));
1211
1212 #ifdef CONFIG_XMIT_THREAD_MODE
1213 #if defined(CONFIG_SDIO_HCI)
1214         if (is_primary_adapter(padapter))
1215 #endif
1216         {
1217                 padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
1218                 if(IS_ERR(padapter->xmitThread))
1219                         _status = _FAIL;
1220         }
1221 #endif //#ifdef CONFIG_XMIT_THREAD_MODE
1222
1223 #ifdef CONFIG_RECV_THREAD_MODE
1224         padapter->recvThread = kthread_run(rtw_recv_thread, padapter, "RTW_RECV_THREAD");
1225         if(IS_ERR(padapter->recvThread))
1226                 _status = _FAIL;
1227 #endif
1228
1229         if (is_primary_adapter(padapter)) {
1230                 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
1231                 if(IS_ERR(padapter->cmdThread))
1232                         _status = _FAIL;
1233                 else
1234                         _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); //wait for cmd_thread to run
1235         }
1236
1237
1238 #ifdef CONFIG_EVENT_THREAD_MODE
1239         padapter->evtThread = kthread_run(event_thread, padapter, "RTW_EVENT_THREAD");
1240         if(IS_ERR(padapter->evtThread))
1241                 _status = _FAIL;
1242 #endif
1243
1244         rtw_hal_start_thread(padapter);
1245         return _status;
1246
1247 }
1248
1249 void rtw_stop_drv_threads (_adapter *padapter)
1250 {
1251         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_stop_drv_threads\n"));
1252
1253         if (is_primary_adapter(padapter))
1254                 rtw_stop_cmd_thread(padapter);
1255
1256 #ifdef CONFIG_EVENT_THREAD_MODE
1257         _rtw_up_sema(&padapter->evtpriv.evt_notify);
1258         if(padapter->evtThread){
1259                 _rtw_down_sema(&padapter->evtpriv.terminate_evtthread_sema);
1260         }
1261 #endif
1262
1263 #ifdef CONFIG_XMIT_THREAD_MODE
1264         // Below is to termindate tx_thread...
1265 #if defined(CONFIG_SDIO_HCI)
1266         // Only wake-up primary adapter
1267         if (is_primary_adapter(padapter))
1268 #endif  /*SDIO_HCI */
1269         {
1270                 _rtw_up_sema(&padapter->xmitpriv.xmit_sema);
1271                 _rtw_down_sema(&padapter->xmitpriv.terminate_xmitthread_sema);
1272         }
1273         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("\n drv_halt: rtw_xmit_thread can be terminated !\n"));
1274 #endif
1275
1276 #ifdef CONFIG_RECV_THREAD_MODE
1277         // Below is to termindate rx_thread...
1278         _rtw_up_sema(&padapter->recvpriv.recv_sema);
1279         _rtw_down_sema(&padapter->recvpriv.terminate_recvthread_sema);
1280         RT_TRACE(_module_os_intfs_c_,_drv_info_,("\n drv_halt:recv_thread can be terminated! \n"));
1281 #endif
1282
1283         rtw_hal_stop_thread(padapter);
1284 }
1285
1286 u8 rtw_init_default_value(_adapter *padapter);
1287 u8 rtw_init_default_value(_adapter *padapter)
1288 {
1289         u8 ret  = _SUCCESS;
1290         struct registry_priv* pregistrypriv = &padapter->registrypriv;
1291         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
1292         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1293         struct security_priv *psecuritypriv = &padapter->securitypriv;
1294
1295         //xmit_priv
1296         pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
1297         pxmitpriv->vcs = pregistrypriv->vcs_type;
1298         pxmitpriv->vcs_type = pregistrypriv->vcs_type;
1299         //pxmitpriv->rts_thresh = pregistrypriv->rts_thresh;
1300         pxmitpriv->frag_len = pregistrypriv->frag_thresh;
1301
1302         //recv_priv
1303
1304         //mlme_priv
1305         pmlmepriv->scan_mode = SCAN_ACTIVE;
1306
1307         //qos_priv
1308         //pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable;
1309
1310         //ht_priv
1311 #ifdef CONFIG_80211N_HT
1312         pmlmepriv->htpriv.ampdu_enable = _FALSE;//set to disabled
1313 #endif
1314
1315         //security_priv
1316         //rtw_get_encrypt_decrypt_from_registrypriv(padapter);
1317         psecuritypriv->binstallGrpkey = _FAIL;
1318 #ifdef CONFIG_GTK_OL
1319         psecuritypriv->binstallKCK_KEK = _FAIL;
1320 #endif //CONFIG_GTK_OL
1321         psecuritypriv->sw_encrypt=pregistrypriv->software_encrypt;
1322         psecuritypriv->sw_decrypt=pregistrypriv->software_decrypt;
1323
1324         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; //open system
1325         psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
1326
1327         psecuritypriv->dot11PrivacyKeyIndex = 0;
1328
1329         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
1330         psecuritypriv->dot118021XGrpKeyid = 1;
1331
1332         psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
1333         psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
1334
1335
1336         //pwrctrl_priv
1337
1338
1339         //registry_priv
1340         rtw_init_registrypriv_dev_network(padapter);
1341         rtw_update_registrypriv_dev_network(padapter);
1342
1343
1344         //hal_priv
1345         rtw_hal_def_value_init(padapter);
1346
1347         //misc.
1348         RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
1349         RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
1350         padapter->bLinkInfoDump = 0;
1351         padapter->bNotifyChannelChange = _FALSE;
1352 #ifdef CONFIG_P2P
1353         padapter->bShowGetP2PState = 1;
1354 #endif
1355
1356         //for debug purpose
1357         padapter->fix_rate = 0xFF;
1358         padapter->data_fb = 0;
1359         padapter->driver_ampdu_spacing = 0xFF;
1360         padapter->driver_rx_ampdu_factor =  0xFF;
1361         padapter->driver_rx_ampdu_spacing = 0xFF;
1362         padapter->fix_rx_ampdu_accept = RX_AMPDU_ACCEPT_INVALID;
1363         padapter->fix_rx_ampdu_size = RX_AMPDU_SIZE_INVALID;
1364 #ifdef DBG_RX_COUNTER_DUMP
1365         padapter->dump_rx_cnt_mode = 0;
1366         padapter->drv_rx_cnt_ok = 0;
1367         padapter->drv_rx_cnt_crcerror = 0;
1368         padapter->drv_rx_cnt_drop = 0;
1369 #endif
1370         return ret;
1371 }
1372
1373 struct dvobj_priv *devobj_init(void)
1374 {
1375         struct dvobj_priv *pdvobj = NULL;
1376
1377         if ((pdvobj = (struct dvobj_priv*)rtw_zmalloc(sizeof(*pdvobj))) == NULL)
1378         {
1379                 return NULL;
1380         }
1381
1382         _rtw_mutex_init(&pdvobj->hw_init_mutex);
1383         _rtw_mutex_init(&pdvobj->h2c_fwcmd_mutex);
1384         _rtw_mutex_init(&pdvobj->setch_mutex);
1385         _rtw_mutex_init(&pdvobj->setbw_mutex);
1386         _rtw_mutex_init(&pdvobj->rf_read_reg_mutex);
1387 #ifdef CONFIG_SDIO_INDIRECT_ACCESS
1388         _rtw_mutex_init(&pdvobj->sd_indirect_access_mutex);
1389 #endif
1390
1391         pdvobj->processing_dev_remove = _FALSE;
1392
1393         ATOMIC_SET(&pdvobj->disable_func, 0);
1394
1395         rtw_macid_ctl_init(&pdvobj->macid_ctl);
1396         _rtw_spinlock_init(&pdvobj->cam_ctl.lock);
1397         _rtw_mutex_init(&pdvobj->cam_ctl.sec_cam_access_mutex);
1398
1399         return pdvobj;
1400
1401 }
1402
1403 void devobj_deinit(struct dvobj_priv *pdvobj)
1404 {
1405         if(!pdvobj)
1406                 return;
1407
1408         /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */
1409 #if defined(CONFIG_IOCTL_CFG80211)
1410         rtw_cfg80211_dev_res_free(pdvobj);
1411 #endif
1412
1413         _rtw_mutex_free(&pdvobj->hw_init_mutex);
1414         _rtw_mutex_free(&pdvobj->h2c_fwcmd_mutex);
1415         _rtw_mutex_free(&pdvobj->setch_mutex);
1416         _rtw_mutex_free(&pdvobj->setbw_mutex);
1417         _rtw_mutex_free(&pdvobj->rf_read_reg_mutex);
1418 #ifdef CONFIG_SDIO_INDIRECT_ACCESS
1419         _rtw_mutex_free(&pdvobj->sd_indirect_access_mutex);
1420 #endif
1421
1422         rtw_macid_ctl_deinit(&pdvobj->macid_ctl);
1423         _rtw_spinlock_free(&pdvobj->cam_ctl.lock);
1424         _rtw_mutex_free(&pdvobj->cam_ctl.sec_cam_access_mutex);
1425
1426         rtw_mfree((u8*)pdvobj, sizeof(*pdvobj));
1427 }
1428
1429 u8 rtw_reset_drv_sw(_adapter *padapter)
1430 {
1431         u8      ret8=_SUCCESS;
1432         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1433         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1434
1435         //hal_priv
1436         if( is_primary_adapter(padapter))
1437                 rtw_hal_def_value_init(padapter);
1438
1439         RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
1440         RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
1441         padapter->bLinkInfoDump = 0;
1442
1443         padapter->xmitpriv.tx_pkts = 0;
1444         padapter->recvpriv.rx_pkts = 0;
1445
1446         pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
1447
1448         //pmlmepriv->LinkDetectInfo.TrafficBusyState = _FALSE;
1449         pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
1450         pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
1451
1452         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY |_FW_UNDER_LINKING);
1453
1454 #ifdef CONFIG_AUTOSUSPEND
1455         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,22) && LINUX_VERSION_CODE<=KERNEL_VERSION(2,6,34))
1456                 adapter_to_dvobj(padapter)->pusbdev->autosuspend_disabled = 1;//autosuspend disabled by the user
1457         #endif
1458 #endif
1459
1460 #ifdef DBG_CONFIG_ERROR_DETECT
1461         if (is_primary_adapter(padapter))
1462                 rtw_hal_sreset_reset_value(padapter);
1463 #endif
1464         pwrctrlpriv->pwr_state_check_cnts = 0;
1465
1466         //mlmeextpriv
1467         mlmeext_set_scan_state(&padapter->mlmeextpriv, SCAN_DISABLE);
1468
1469 #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
1470         rtw_set_signal_stat_timer(&padapter->recvpriv);
1471 #endif
1472
1473         return ret8;
1474 }
1475
1476
1477 u8 rtw_init_drv_sw(_adapter *padapter)
1478 {
1479
1480         u8      ret8=_SUCCESS;
1481
1482 _func_enter_;
1483
1484         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_init_drv_sw\n"));
1485
1486         ret8 = rtw_init_default_value(padapter);
1487
1488         if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL)
1489         {
1490                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init cmd_priv\n"));
1491                 ret8=_FAIL;
1492                 goto exit;
1493         }
1494
1495         padapter->cmdpriv.padapter=padapter;
1496
1497         if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL)
1498         {
1499                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init evt_priv\n"));
1500                 ret8=_FAIL;
1501                 goto exit;
1502         }
1503
1504
1505         if (rtw_init_mlme_priv(padapter) == _FAIL)
1506         {
1507                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init mlme_priv\n"));
1508                 ret8=_FAIL;
1509                 goto exit;
1510         }
1511
1512 #ifdef CONFIG_P2P
1513         rtw_init_wifidirect_timers(padapter);
1514         init_wifidirect_info(padapter, P2P_ROLE_DISABLE);
1515         reset_global_wifidirect_info(padapter);
1516         #ifdef CONFIG_IOCTL_CFG80211
1517         rtw_init_cfg80211_wifidirect_info(padapter);
1518         #endif
1519 #ifdef CONFIG_WFD
1520         if(rtw_init_wifi_display_info(padapter) == _FAIL)
1521                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init init_wifi_display_info\n"));
1522 #endif
1523 #endif /* CONFIG_P2P */
1524
1525         if(init_mlme_ext_priv(padapter) == _FAIL)
1526         {
1527                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init mlme_ext_priv\n"));
1528                 ret8=_FAIL;
1529                 goto exit;
1530         }
1531
1532 #ifdef CONFIG_TDLS
1533         if(rtw_init_tdls_info(padapter) == _FAIL)
1534         {
1535                 DBG_871X("Can't rtw_init_tdls_info\n");
1536                 ret8=_FAIL;
1537                 goto exit;
1538         }
1539 #endif //CONFIG_TDLS
1540
1541         if(_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL)
1542         {
1543                 DBG_871X("Can't _rtw_init_xmit_priv\n");
1544                 ret8=_FAIL;
1545                 goto exit;
1546         }
1547
1548         if(_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL)
1549         {
1550                 DBG_871X("Can't _rtw_init_recv_priv\n");
1551                 ret8=_FAIL;
1552                 goto exit;
1553         }
1554         // add for CONFIG_IEEE80211W, none 11w also can use
1555         _rtw_spinlock_init(&padapter->security_key_mutex);
1556
1557         // We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc().
1558         //_rtw_memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv));
1559
1560         //_init_timer(&(padapter->securitypriv.tkip_timer), padapter->pifp, rtw_use_tkipkey_handler, padapter);
1561
1562         if(_rtw_init_sta_priv(&padapter->stapriv) == _FAIL)
1563         {
1564                 DBG_871X("Can't _rtw_init_sta_priv\n");
1565                 ret8=_FAIL;
1566                 goto exit;
1567         }
1568
1569         padapter->stapriv.padapter = padapter;
1570         padapter->setband = WIFI_FREQUENCY_BAND_AUTO;
1571         padapter->fix_rate = 0xFF;
1572         padapter->data_fb = 0;
1573         padapter->fix_rx_ampdu_accept = RX_AMPDU_ACCEPT_INVALID;
1574         padapter->fix_rx_ampdu_size = RX_AMPDU_SIZE_INVALID;
1575 #ifdef DBG_RX_COUNTER_DUMP
1576         padapter->dump_rx_cnt_mode = 0;
1577         padapter->drv_rx_cnt_ok = 0;
1578         padapter->drv_rx_cnt_crcerror = 0;
1579         padapter->drv_rx_cnt_drop = 0;
1580 #endif
1581         rtw_init_bcmc_stainfo(padapter);
1582
1583         rtw_init_pwrctrl_priv(padapter);
1584
1585         //_rtw_memset((u8 *)&padapter->qospriv, 0, sizeof (struct qos_priv));//move to mlme_priv
1586
1587         rtw_hal_dm_init(padapter);
1588 #ifdef CONFIG_SW_LED
1589         rtw_hal_sw_led_init(padapter);
1590 #endif
1591 #ifdef DBG_CONFIG_ERROR_DETECT
1592         rtw_hal_sreset_init(padapter);
1593 #endif
1594
1595 #ifdef CONFIG_INTEL_WIDI
1596         if(rtw_init_intel_widi(padapter) == _FAIL)
1597         {
1598                 DBG_871X("Can't rtw_init_intel_widi\n");
1599                 ret8=_FAIL;
1600                 goto exit;
1601         }
1602 #endif //CONFIG_INTEL_WIDI
1603
1604 #ifdef CONFIG_WAPI_SUPPORT
1605         padapter->WapiSupport = true; //set true temp, will revise according to Efuse or Registry value later.
1606         rtw_wapi_init(padapter);
1607 #endif
1608
1609 #ifdef CONFIG_BR_EXT
1610         _rtw_spinlock_init(&padapter->br_ext_lock);
1611 #endif  // CONFIG_BR_EXT
1612
1613 exit:
1614
1615         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-rtw_init_drv_sw\n"));
1616
1617         _func_exit_;
1618
1619         return ret8;
1620
1621 }
1622
1623 void rtw_cancel_all_timer(_adapter *padapter)
1624 {
1625         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_cancel_all_timer\n"));
1626
1627         _cancel_timer_ex(&padapter->mlmepriv.assoc_timer);
1628         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel association timer complete!\n"));
1629
1630         #if 0
1631         _cancel_timer_ex(&padapter->securitypriv.tkip_timer);
1632         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel tkip_timer!\n"));
1633         #endif
1634
1635         _cancel_timer_ex(&padapter->mlmepriv.scan_to_timer);
1636         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel scan_to_timer!\n"));
1637
1638         #ifdef CONFIG_DFS_MASTER
1639         _cancel_timer_ex(&padapter->mlmepriv.dfs_master_timer);
1640         #endif
1641
1642         _cancel_timer_ex(&padapter->mlmepriv.dynamic_chk_timer);
1643         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel dynamic_chk_timer!\n"));
1644
1645         // cancel sw led timer
1646         rtw_hal_sw_led_deinit(padapter);
1647         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel DeInitSwLeds! \n"));
1648
1649         _cancel_timer_ex(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
1650
1651 #ifdef CONFIG_IOCTL_CFG80211
1652 #ifdef CONFIG_P2P
1653         _cancel_timer_ex(&padapter->cfg80211_wdinfo.remain_on_ch_timer);
1654 #endif //CONFIG_P2P
1655 #endif //CONFIG_IOCTL_CFG80211
1656
1657 #ifdef CONFIG_SET_SCAN_DENY_TIMER
1658         _cancel_timer_ex(&padapter->mlmepriv.set_scan_deny_timer);
1659         rtw_clear_scan_deny(padapter);
1660         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel set_scan_deny_timer! \n"));
1661 #endif
1662
1663 #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
1664         _cancel_timer_ex(&padapter->recvpriv.signal_stat_timer);
1665 #endif
1666         //cancel dm timer
1667         rtw_hal_dm_deinit(padapter);
1668
1669 #ifdef CONFIG_PLATFORM_FS_MX61
1670         msleep(50);
1671 #endif
1672 }
1673
1674 u8 rtw_free_drv_sw(_adapter *padapter)
1675 {
1676         RT_TRACE(_module_os_intfs_c_,_drv_info_,("==>rtw_free_drv_sw"));
1677
1678 #ifdef CONFIG_WAPI_SUPPORT
1679         rtw_wapi_free(padapter);
1680 #endif
1681
1682         //we can call rtw_p2p_enable here, but:
1683         // 1. rtw_p2p_enable may have IO operation
1684         // 2. rtw_p2p_enable is bundled with wext interface
1685         #ifdef CONFIG_P2P
1686         {
1687                 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
1688                 if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1689                 {
1690                         _cancel_timer_ex( &pwdinfo->find_phase_timer );
1691                         _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
1692                         _cancel_timer_ex( &pwdinfo->pre_tx_scan_timer);
1693 #ifdef CONFIG_CONCURRENT_MODE
1694                         _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer );
1695 #endif // CONFIG_CONCURRENT_MODE
1696                         rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
1697                 }
1698         }
1699         #endif
1700         // add for CONFIG_IEEE80211W, none 11w also can use
1701         _rtw_spinlock_free(&padapter->security_key_mutex);
1702
1703 #ifdef CONFIG_BR_EXT
1704         _rtw_spinlock_free(&padapter->br_ext_lock);
1705 #endif  // CONFIG_BR_EXT
1706
1707 #ifdef CONFIG_INTEL_WIDI
1708         rtw_free_intel_widi(padapter);
1709 #endif //CONFIG_INTEL_WIDI
1710
1711         free_mlme_ext_priv(&padapter->mlmeextpriv);
1712
1713 #ifdef CONFIG_TDLS
1714         //rtw_free_tdls_info(&padapter->tdlsinfo);
1715 #endif //CONFIG_TDLS
1716
1717         rtw_free_cmd_priv(&padapter->cmdpriv);
1718
1719         rtw_free_evt_priv(&padapter->evtpriv);
1720
1721         rtw_free_mlme_priv(&padapter->mlmepriv);
1722
1723         //free_io_queue(padapter);
1724
1725         _rtw_free_xmit_priv(&padapter->xmitpriv);
1726
1727         _rtw_free_sta_priv(&padapter->stapriv); //will free bcmc_stainfo here
1728
1729         _rtw_free_recv_priv(&padapter->recvpriv);
1730
1731         rtw_free_pwrctrl_priv(padapter);
1732
1733         //rtw_mfree((void *)padapter, sizeof (padapter));
1734
1735 #ifdef CONFIG_DRVEXT_MODULE
1736         free_drvext(&padapter->drvextpriv);
1737 #endif
1738
1739         rtw_hal_free_data(padapter);
1740
1741         RT_TRACE(_module_os_intfs_c_,_drv_info_,("<==rtw_free_drv_sw\n"));
1742
1743         //free the old_pnetdev
1744         if(padapter->rereg_nd_name_priv.old_pnetdev) {
1745                 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
1746                 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
1747         }
1748
1749         // clear pbuddy_adapter to avoid access wrong pointer.
1750         if(padapter->pbuddy_adapter != NULL) {
1751                 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
1752         }
1753
1754         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-rtw_free_drv_sw\n"));
1755
1756         return _SUCCESS;
1757
1758 }
1759
1760 #ifdef CONFIG_CONCURRENT_MODE
1761 #ifdef CONFIG_MULTI_VIR_IFACES
1762 int _netdev_vir_if_open(struct net_device *pnetdev)
1763 {
1764         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1765         _adapter *primary_padapter = GET_PRIMARY_ADAPTER(padapter);
1766
1767         DBG_871X(FUNC_NDEV_FMT" enter\n", FUNC_NDEV_ARG(pnetdev));
1768
1769         if(!primary_padapter)
1770                 goto _netdev_virtual_iface_open_error;
1771
1772         if (primary_padapter->bup == _FALSE || !rtw_is_hw_init_completed(primary_padapter))
1773                 _netdev_open(primary_padapter->pnetdev);
1774
1775         if(padapter->bup == _FALSE && primary_padapter->bup == _TRUE &&
1776                 rtw_is_hw_init_completed(primary_padapter))
1777         {
1778                 padapter->bFWReady = primary_padapter->bFWReady;
1779
1780                 if(rtw_start_drv_threads(padapter) == _FAIL)
1781                 {
1782                         goto _netdev_virtual_iface_open_error;
1783                 }
1784
1785 #ifdef CONFIG_IOCTL_CFG80211
1786                 rtw_cfg80211_init_wiphy(padapter);
1787 #endif
1788
1789                 padapter->bup = _TRUE;
1790
1791         }
1792
1793         padapter->net_closed = _FALSE;
1794
1795         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
1796
1797         rtw_netif_wake_queue(pnetdev);
1798
1799         DBG_871X(FUNC_NDEV_FMT" exit\n", FUNC_NDEV_ARG(pnetdev));
1800         return 0;
1801
1802 _netdev_virtual_iface_open_error:
1803
1804         padapter->bup = _FALSE;
1805
1806         netif_carrier_off(pnetdev);
1807         rtw_netif_stop_queue(pnetdev);
1808
1809         return (-1);
1810
1811 }
1812
1813 int netdev_vir_if_open(struct net_device *pnetdev)
1814 {
1815         int ret;
1816         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1817
1818         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
1819         ret = _netdev_vir_if_open(pnetdev);
1820         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
1821
1822 #ifdef CONFIG_AUTO_AP_MODE
1823         //if(padapter->iface_id == 2)
1824         //      rtw_start_auto_ap(padapter);
1825 #endif
1826
1827         return ret;
1828 }
1829
1830 static int netdev_vir_if_close(struct net_device *pnetdev)
1831 {
1832         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1833
1834         padapter->net_closed = _TRUE;
1835
1836         if(pnetdev)
1837         {
1838                 rtw_netif_stop_queue(pnetdev);
1839         }
1840
1841 #ifdef CONFIG_IOCTL_CFG80211
1842         rtw_scan_abort(padapter);
1843         rtw_cfg80211_wait_scan_req_empty(padapter, 200);
1844         adapter_wdev_data(padapter)->bandroid_scan = _FALSE;
1845 #endif
1846
1847         return 0;
1848 }
1849
1850 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1851 static const struct net_device_ops rtw_netdev_vir_if_ops = {
1852          .ndo_open = netdev_vir_if_open,
1853         .ndo_stop = netdev_vir_if_close,
1854         .ndo_start_xmit = rtw_xmit_entry,
1855         .ndo_set_mac_address = rtw_net_set_mac_address,
1856         .ndo_get_stats = rtw_net_get_stats,
1857         .ndo_do_ioctl = rtw_ioctl,
1858 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1859         .ndo_select_queue       = rtw_select_queue,
1860 #endif
1861 };
1862 #endif
1863
1864 void rtw_hook_vir_if_ops(struct net_device *ndev)
1865 {
1866 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
1867         ndev->netdev_ops = &rtw_netdev_vir_if_ops;
1868 #else
1869         ndev->open = netdev_vir_if_open;
1870         ndev->stop = netdev_vir_if_close;
1871         ndev->set_mac_address = rtw_net_set_mac_address;
1872 #endif
1873 }
1874
1875 _adapter *rtw_drv_add_vir_if(_adapter *primary_padapter,
1876         void (*set_intf_ops)(_adapter *primary_padapter,struct _io_ops *pops))
1877 {
1878         int res = _FAIL;
1879         _adapter *padapter = NULL;
1880         struct dvobj_priv *pdvobjpriv;
1881         u8 mac[ETH_ALEN];
1882
1883 /*
1884         if((primary_padapter->bup == _FALSE) ||
1885                 (rtw_buddy_adapter_up(primary_padapter) == _FALSE))
1886                 goto exit;
1887 */
1888
1889         /****** init adapter ******/
1890         padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter));
1891         if (padapter == NULL)
1892                 goto exit;
1893
1894         if (loadparam(padapter) != _SUCCESS)
1895                 goto free_adapter;
1896
1897         _rtw_memcpy(padapter, primary_padapter, sizeof(_adapter));
1898
1899         //
1900         padapter->bup = _FALSE;
1901         padapter->net_closed = _TRUE;
1902         padapter->dir_dev = NULL;
1903         padapter->dir_odm = NULL;
1904
1905
1906         //set adapter_type/iface type
1907         padapter->isprimary = _FALSE;
1908         padapter->adapter_type = MAX_ADAPTER;
1909         padapter->pbuddy_adapter = primary_padapter;
1910 #if 0
1911 #ifndef CONFIG_HWPORT_SWAP      //Port0 -> Pri , Port1 -> Sec
1912         padapter->iface_type = IFACE_PORT1;
1913 #else
1914         padapter->iface_type = IFACE_PORT0;
1915 #endif  //CONFIG_HWPORT_SWAP
1916 #else
1917         //extended virtual interfaces always are set to port0
1918         padapter->iface_type = IFACE_PORT0;
1919 #endif
1920
1921         /****** hook vir if into dvobj ******/
1922         pdvobjpriv = adapter_to_dvobj(padapter);
1923         padapter->iface_id = pdvobjpriv->iface_nums;
1924         pdvobjpriv->padapters[pdvobjpriv->iface_nums++] = padapter;
1925
1926         padapter->intf_start = NULL;
1927         padapter->intf_stop = NULL;
1928
1929         //step init_io_priv
1930         if ((rtw_init_io_priv(padapter, set_intf_ops)) == _FAIL) {
1931                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("\n Can't init io_reqs\n"));
1932                 goto free_adapter;
1933         }
1934
1935         //init drv data
1936         if(rtw_init_drv_sw(padapter)!= _SUCCESS)
1937                 goto free_drv_sw;
1938
1939
1940         //get mac address from primary_padapter
1941         _rtw_memcpy(mac, adapter_mac_addr(primary_padapter), ETH_ALEN);
1942
1943         /*
1944         * If the BIT1 is 0, the address is universally administered.
1945         * If it is 1, the address is locally administered
1946         */
1947 #if 1 /* needs enable MBSSID CAM */
1948         mac[0] |= BIT(1);
1949         mac[0] |= (padapter->iface_id-1)<<4;
1950 #endif
1951
1952         _rtw_memcpy(adapter_mac_addr(padapter), mac, ETH_ALEN);
1953
1954         res = _SUCCESS;
1955
1956 free_drv_sw:
1957         if (res != _SUCCESS && padapter)
1958                 rtw_free_drv_sw(padapter);
1959 free_adapter:
1960         if (res != _SUCCESS && padapter) {
1961                 rtw_vmfree((u8 *)padapter, sizeof(*padapter));
1962                 padapter = NULL;
1963         }
1964 exit:
1965         return padapter;
1966 }
1967
1968 void rtw_drv_stop_vir_if(_adapter *padapter)
1969 {
1970         struct net_device *pnetdev=NULL;
1971
1972         if (padapter == NULL)
1973                 return;
1974
1975         pnetdev = padapter->pnetdev;
1976
1977
1978         if (padapter->bup == _TRUE)
1979         {
1980                 #ifdef CONFIG_XMIT_ACK
1981                 if (padapter->xmitpriv.ack_tx)
1982                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
1983                 #endif
1984
1985                 if (padapter->intf_stop)
1986                 {
1987                         padapter->intf_stop(padapter);
1988                 }
1989
1990                 rtw_stop_drv_threads(padapter);
1991
1992                 padapter->bup = _FALSE;
1993         }
1994
1995         /* cancel timer after thread stop */
1996         rtw_cancel_all_timer(padapter);
1997 }
1998
1999 void rtw_drv_free_vir_if(_adapter *padapter)
2000 {
2001         if (padapter == NULL)
2002                 return;
2003
2004         padapter->pbuddy_adapter = NULL;
2005
2006         rtw_free_drv_sw(padapter);
2007
2008         /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */
2009         rtw_os_ndev_free(padapter);
2010
2011         rtw_vmfree((u8 *)padapter, sizeof(_adapter));
2012 }
2013
2014 void rtw_drv_stop_vir_ifaces(struct dvobj_priv *dvobj)
2015 {
2016         int i;
2017         //struct dvobj_priv *dvobj = primary_padapter->dvobj;
2018
2019         for(i=2;i<dvobj->iface_nums;i++)
2020         {
2021                 rtw_drv_stop_vir_if(dvobj->padapters[i]);
2022         }
2023 }
2024
2025 void rtw_drv_free_vir_ifaces(struct dvobj_priv *dvobj)
2026 {
2027         int i;
2028         //struct dvobj_priv *dvobj = primary_padapter->dvobj;
2029
2030         for(i=2;i<dvobj->iface_nums;i++)
2031         {
2032                 rtw_drv_free_vir_if(dvobj->padapters[i]);
2033         }
2034 }
2035
2036 void rtw_drv_del_vir_if(_adapter *padapter)
2037 {
2038         rtw_drv_stop_vir_if(padapter);
2039         rtw_drv_free_vir_if(padapter);
2040 }
2041
2042 void rtw_drv_del_vir_ifaces(_adapter *primary_padapter)
2043 {
2044         int i;
2045         struct dvobj_priv *dvobj = primary_padapter->dvobj;
2046
2047         for(i=2;i<dvobj->iface_nums;i++)
2048         {
2049                 rtw_drv_del_vir_if(dvobj->padapters[i]);
2050         }
2051 }
2052 #endif //CONFIG_MULTI_VIR_IFACES
2053
2054 int _netdev_if2_open(struct net_device *pnetdev)
2055 {
2056         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2057         _adapter *primary_padapter = padapter->pbuddy_adapter;
2058
2059         DBG_871X("+871x_drv - if2_open, bup=%d\n", padapter->bup);
2060
2061 #ifdef CONFIG_PLATFORM_INTEL_BYT
2062         if (padapter->bup == _FALSE)
2063         {
2064                 u8 mac[ETH_ALEN];
2065
2066                 /* get mac address from primary_padapter */
2067                 if (primary_padapter->bup == _FALSE)
2068                         rtw_macaddr_cfg(adapter_mac_addr(primary_padapter), get_hal_mac_addr(primary_padapter));
2069
2070                 _rtw_memcpy(mac, adapter_mac_addr(primary_padapter), ETH_ALEN);
2071
2072                 /*
2073                 * If the BIT1 is 0, the address is universally administered.
2074                 * If it is 1, the address is locally administered
2075                 */
2076                 mac[0] |= BIT(1);
2077
2078                 _rtw_memcpy(adapter_mac_addr(padapter), mac, ETH_ALEN);
2079                 rtw_init_wifidirect_addrs(padapter, adapter_mac_addr(padapter), adapter_mac_addr(padapter));
2080                 _rtw_memcpy(pnetdev->dev_addr, adapter_mac_addr(padapter), ETH_ALEN);
2081         }
2082 #endif //CONFIG_PLATFORM_INTEL_BYT
2083
2084         if (primary_padapter->bup == _FALSE || !rtw_is_hw_init_completed(primary_padapter))
2085                 _netdev_open(primary_padapter->pnetdev);
2086
2087         if(padapter->bup == _FALSE && primary_padapter->bup == _TRUE &&
2088                 rtw_is_hw_init_completed(primary_padapter))
2089         {
2090                 padapter->bFWReady = primary_padapter->bFWReady;
2091
2092                 //if (init_mlme_ext_priv(padapter) == _FAIL)
2093                 //      goto netdev_if2_open_error;
2094
2095
2096                 if (rtw_start_drv_threads(padapter) == _FAIL)
2097                 {
2098                         goto netdev_if2_open_error;
2099                 }
2100
2101
2102                 if (padapter->intf_start)
2103                 {
2104                         padapter->intf_start(padapter);
2105                 }
2106
2107 #ifdef CONFIG_IOCTL_CFG80211
2108                 rtw_cfg80211_init_wiphy(padapter);
2109 #endif
2110
2111                 padapter->bup = _TRUE;
2112
2113         }
2114
2115         padapter->net_closed = _FALSE;
2116
2117         //execute dynamic_chk_timer only on primary interface
2118         // secondary interface shares the timer with primary interface.
2119         //_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
2120
2121         rtw_netif_wake_queue(pnetdev);
2122
2123         DBG_871X("-871x_drv - if2_open, bup=%d\n", padapter->bup);
2124         return 0;
2125
2126 netdev_if2_open_error:
2127
2128         padapter->bup = _FALSE;
2129
2130         netif_carrier_off(pnetdev);
2131         rtw_netif_stop_queue(pnetdev);
2132
2133         return (-1);
2134
2135 }
2136
2137 int netdev_if2_open(struct net_device *pnetdev)
2138 {
2139         int ret;
2140         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2141         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
2142
2143         if (pwrctrlpriv->bInSuspend == _TRUE)
2144         {
2145                 DBG_871X("+871x_drv - netdev_if2_open, bInSuspend=%d\n", pwrctrlpriv->bInSuspend);
2146                 return 0;
2147         }
2148
2149         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2150         ret = _netdev_if2_open(pnetdev);
2151         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2152
2153 #ifdef CONFIG_AUTO_AP_MODE
2154         //if(padapter->iface_id == 2)
2155                 rtw_start_auto_ap(padapter);
2156 #endif
2157
2158         return ret;
2159 }
2160
2161 static int netdev_if2_close(struct net_device *pnetdev)
2162 {
2163         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2164         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2165
2166         padapter->net_closed = _TRUE;
2167         pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
2168
2169         if(pnetdev)
2170         {
2171                 rtw_netif_stop_queue(pnetdev);
2172         }
2173
2174 #ifdef CONFIG_P2P
2175         if (!rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_DISABLE))
2176                 rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
2177 #endif
2178
2179 #ifdef CONFIG_IOCTL_CFG80211
2180         rtw_scan_abort(padapter);
2181         rtw_cfg80211_wait_scan_req_empty(padapter, 200);
2182         adapter_wdev_data(padapter)->bandroid_scan = _FALSE;
2183 #endif
2184
2185         return 0;
2186 }
2187
2188 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
2189 static const struct net_device_ops rtw_netdev_if2_ops = {
2190         .ndo_init = rtw_ndev_init,
2191         .ndo_uninit = rtw_ndev_uninit,
2192         .ndo_open = netdev_if2_open,
2193         .ndo_stop = netdev_if2_close,
2194         .ndo_start_xmit = rtw_xmit_entry,
2195         .ndo_set_mac_address = rtw_net_set_mac_address,
2196         .ndo_get_stats = rtw_net_get_stats,
2197         .ndo_do_ioctl = rtw_ioctl,
2198 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
2199         .ndo_select_queue       = rtw_select_queue,
2200 #endif
2201 };
2202 #endif
2203
2204 void rtw_hook_if2_ops(struct net_device *ndev)
2205 {
2206 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
2207         ndev->netdev_ops = &rtw_netdev_if2_ops;
2208 #else
2209         ndev->init = rtw_ndev_init;
2210         ndev->uninit = rtw_ndev_uninit;
2211         ndev->open = netdev_if2_open;
2212         ndev->stop = netdev_if2_close;
2213         ndev->set_mac_address = rtw_net_set_mac_address;
2214 #endif
2215 }
2216
2217 _adapter *rtw_drv_if2_init(_adapter *primary_padapter,
2218         void (*set_intf_ops)(_adapter *primary_padapter,struct _io_ops *pops))
2219 {
2220         int res = _FAIL;
2221         _adapter *padapter = NULL;
2222         struct dvobj_priv *pdvobjpriv;
2223         u8 mac[ETH_ALEN];
2224
2225         /****** init adapter ******/
2226         padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter));
2227         if (padapter == NULL)
2228                 goto exit;
2229
2230         if (loadparam(padapter) != _SUCCESS)
2231                 goto free_adapter;
2232
2233         _rtw_memcpy(padapter, primary_padapter, sizeof(*padapter));
2234
2235         //
2236         padapter->bup = _FALSE;
2237         padapter->net_closed = _TRUE;
2238         padapter->dir_dev = NULL;
2239         padapter->dir_odm = NULL;
2240
2241         //set adapter_type/iface type
2242         padapter->isprimary = _FALSE;
2243         padapter->adapter_type = SECONDARY_ADAPTER;
2244         padapter->pbuddy_adapter = primary_padapter;
2245         padapter->iface_id = IFACE_ID1;
2246 #ifndef CONFIG_HWPORT_SWAP                      //Port0 -> Pri , Port1 -> Sec
2247         padapter->iface_type = IFACE_PORT1;
2248 #else
2249         padapter->iface_type = IFACE_PORT0;
2250 #endif  //CONFIG_HWPORT_SWAP
2251
2252         /****** hook if2 into dvobj ******/
2253         pdvobjpriv = adapter_to_dvobj(padapter);
2254         pdvobjpriv->padapters[pdvobjpriv->iface_nums++] = padapter;
2255
2256         //
2257         padapter->intf_start = primary_padapter->intf_start;
2258         padapter->intf_stop = primary_padapter->intf_stop;
2259
2260         //step init_io_priv
2261         if ((rtw_init_io_priv(padapter, set_intf_ops)) == _FAIL) {
2262                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("\n Can't init io_reqs\n"));
2263                 goto free_adapter;
2264         }
2265
2266         //init drv data
2267         if(rtw_init_drv_sw(padapter)!= _SUCCESS)
2268                 goto free_drv_sw;
2269
2270
2271         /* get mac address from primary_padapter */
2272         _rtw_memcpy(mac, adapter_mac_addr(primary_padapter), ETH_ALEN);
2273
2274         /*
2275         * If the BIT1 is 0, the address is universally administered.
2276         * If it is 1, the address is locally administered
2277         */
2278         mac[0] |= BIT(1);
2279
2280         _rtw_memcpy(adapter_mac_addr(padapter), mac, ETH_ALEN);
2281         rtw_init_wifidirect_addrs(padapter, adapter_mac_addr(padapter), adapter_mac_addr(padapter));
2282
2283         primary_padapter->pbuddy_adapter = padapter;
2284
2285         res = _SUCCESS;
2286
2287 free_drv_sw:
2288         if (res != _SUCCESS && padapter)
2289                 rtw_free_drv_sw(padapter);
2290 free_adapter:
2291         if (res != _SUCCESS && padapter) {
2292                 rtw_vmfree((u8 *)padapter, sizeof(*padapter));
2293                 padapter = NULL;
2294         }
2295 exit:
2296         return padapter;
2297 }
2298
2299 void rtw_drv_if2_free(_adapter *if2)
2300 {
2301         _adapter *padapter = if2;
2302
2303         if (padapter == NULL)
2304                 return;
2305
2306         rtw_free_drv_sw(padapter);
2307
2308         /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */
2309         rtw_os_ndev_free(padapter);
2310
2311         rtw_vmfree((u8 *)padapter, sizeof(_adapter));
2312 }
2313
2314 void rtw_drv_if2_stop(_adapter *if2)
2315 {
2316         _adapter *padapter = if2;
2317         struct net_device *pnetdev = NULL;
2318
2319         if (padapter == NULL)
2320                 return;
2321
2322
2323         if (padapter->bup == _TRUE) {
2324                 #ifdef CONFIG_XMIT_ACK
2325                 if (padapter->xmitpriv.ack_tx)
2326                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
2327                 #endif
2328
2329                 if (padapter->intf_stop)
2330                 {
2331                         padapter->intf_stop(padapter);
2332                 }
2333
2334                 rtw_stop_drv_threads(padapter);
2335
2336                 padapter->bup = _FALSE;
2337         }
2338
2339         /* cancel timer after thread stop */
2340         rtw_cancel_all_timer(padapter);
2341 }
2342 #endif //end of CONFIG_CONCURRENT_MODE
2343
2344 int rtw_os_ndevs_register(struct dvobj_priv *dvobj)
2345 {
2346         int i, status = _SUCCESS;
2347         struct registry_priv *regsty = dvobj_to_regsty(dvobj);
2348         _adapter *adapter;
2349
2350 #if defined(CONFIG_IOCTL_CFG80211)
2351         if (rtw_cfg80211_dev_res_register(dvobj) != _SUCCESS) {
2352                 rtw_warn_on(1);
2353                 status = _FAIL;
2354                 goto exit;
2355         }
2356 #endif
2357
2358         for (i = 0; i < dvobj->iface_nums; i++) {
2359
2360                 if (i >= IFACE_ID_MAX) {
2361                         DBG_871X_LEVEL(_drv_err_, "%s %d >= IFACE_ID_MAX\n", __func__, i);
2362                         rtw_warn_on(1);
2363                         continue;
2364                 }
2365
2366                 adapter = dvobj->padapters[i];
2367                 if (adapter) {
2368                         char *name;
2369
2370                         if (adapter->iface_id == IFACE_ID0)
2371                                 name = regsty->ifname;
2372                         else if (adapter->iface_id == IFACE_ID1)
2373                                 name = regsty->if2name;
2374                         else
2375                                 name = "wlan%d";
2376
2377                         #ifdef CONFIG_CONCURRENT_MODE
2378                         switch (adapter->adapter_type) {
2379                         case SECONDARY_ADAPTER:
2380                                 rtw_hook_if2_ops(adapter->pnetdev);
2381                                 break;
2382                         #ifdef CONFIG_MULTI_VIR_IFACES
2383                         case MAX_ADAPTER:
2384                                 rtw_hook_vir_if_ops(adapter->pnetdev);
2385                                 break;
2386                         #endif
2387                         }
2388                         #endif /* CONFIG_CONCURRENT_MODE */
2389
2390                         status = rtw_os_ndev_register(adapter, name);
2391
2392                         if (status != _SUCCESS) {
2393                                 rtw_warn_on(1);
2394                                 break;
2395                         }
2396                 }
2397         }
2398
2399         if (status != _SUCCESS) {
2400                 for (; i >= 0; i--) {
2401                         adapter = dvobj->padapters[i];
2402                         if (adapter)
2403                                 rtw_os_ndev_unregister(adapter);
2404                 }
2405         }
2406
2407 #if defined(CONFIG_IOCTL_CFG80211)
2408         if (status != _SUCCESS)
2409                 rtw_cfg80211_dev_res_unregister(dvobj);
2410 #endif
2411 exit:
2412         return status;
2413 }
2414
2415 void rtw_os_ndevs_unregister(struct dvobj_priv *dvobj)
2416 {
2417         int i;
2418         _adapter *adapter = NULL;
2419
2420         for (i = 0; i < dvobj->iface_nums; i++) {
2421                 adapter = dvobj->padapters[i];
2422
2423                 if (adapter == NULL)
2424                         continue;
2425
2426                 rtw_os_ndev_unregister(adapter);
2427         }
2428
2429 #if defined(CONFIG_IOCTL_CFG80211)
2430         rtw_cfg80211_dev_res_unregister(dvobj);
2431 #endif
2432 }
2433
2434 /**
2435  * rtw_os_ndevs_init - Allocate and register OS layer net devices and relating structures for @dvobj
2436  * @dvobj: the dvobj on which this function applies
2437  *
2438  * Returns:
2439  * _SUCCESS or _FAIL
2440  */
2441 int rtw_os_ndevs_init(struct dvobj_priv *dvobj)
2442 {
2443         int ret = _FAIL;
2444
2445         if (rtw_os_ndevs_alloc(dvobj) != _SUCCESS)
2446                 goto exit;
2447
2448         if (rtw_os_ndevs_register(dvobj) != _SUCCESS)
2449                 goto os_ndevs_free;
2450
2451         ret = _SUCCESS;
2452
2453 os_ndevs_free:
2454         if (ret != _SUCCESS)
2455                 rtw_os_ndevs_free(dvobj);
2456 exit:
2457         return ret;
2458 }
2459
2460 /**
2461  * rtw_os_ndevs_deinit - Unregister and free OS layer net devices and relating structures for @dvobj
2462  * @dvobj: the dvobj on which this function applies
2463  */
2464 void rtw_os_ndevs_deinit(struct dvobj_priv *dvobj)
2465 {
2466         rtw_os_ndevs_unregister(dvobj);
2467         rtw_os_ndevs_free(dvobj);
2468 }
2469
2470 #ifdef CONFIG_BR_EXT
2471 void netdev_br_init(struct net_device *netdev)
2472 {
2473         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
2474
2475 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2476         rcu_read_lock();
2477 #endif  // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2478
2479         //if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE)
2480         {
2481                 //struct net_bridge     *br = netdev->br_port->br;//->dev->dev_addr;
2482 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2483                 if (netdev->br_port)
2484 #else   // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2485                 if (rcu_dereference(adapter->pnetdev->rx_handler_data))
2486 #endif  // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2487                 {
2488                         struct net_device *br_netdev;
2489 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2490                         br_netdev = dev_get_by_name(CONFIG_BR_EXT_BRNAME);
2491 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2492                         struct net *devnet = NULL;
2493
2494 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2495                         devnet = netdev->nd_net;
2496 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2497                         devnet = dev_net(netdev);
2498 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2499
2500                         br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME);
2501 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2502
2503                         if (br_netdev) {
2504                                 memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN);
2505                                 dev_put(br_netdev);
2506                         } else
2507                                 printk("%s()-%d: dev_get_by_name(%s) failed!", __FUNCTION__, __LINE__, CONFIG_BR_EXT_BRNAME);
2508                 }
2509
2510                 adapter->ethBrExtInfo.addPPPoETag = 1;
2511         }
2512
2513 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2514         rcu_read_unlock();
2515 #endif  // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2516 }
2517 #endif //CONFIG_BR_EXT
2518
2519 int _netdev_open(struct net_device *pnetdev)
2520 {
2521         uint status;
2522         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2523         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
2524 #ifdef CONFIG_BT_COEXIST_SOCKET_TRX
2525         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(padapter);
2526 #endif //CONFIG_BT_COEXIST_SOCKET_TRX
2527
2528         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - dev_open\n"));
2529         DBG_871X("+871x_drv - drv_open, bup=%d\n", padapter->bup);
2530
2531         padapter->netif_up = _TRUE;
2532
2533 #ifdef CONFIG_PLATFORM_INTEL_BYT
2534         rtw_sdio_set_power(1);
2535 #endif //CONFIG_PLATFORM_INTEL_BYT
2536
2537         if(pwrctrlpriv->ps_flag == _TRUE){
2538                 padapter->net_closed = _FALSE;
2539                 goto netdev_open_normal_process;
2540         }
2541
2542         if(padapter->bup == _FALSE)
2543         {
2544 #ifdef CONFIG_PLATFORM_INTEL_BYT
2545                 rtw_macaddr_cfg(adapter_mac_addr(padapter),  get_hal_mac_addr(padapter));
2546                 rtw_init_wifidirect_addrs(padapter, adapter_mac_addr(padapter), adapter_mac_addr(padapter));
2547                 _rtw_memcpy(pnetdev->dev_addr, adapter_mac_addr(padapter), ETH_ALEN);
2548 #endif //CONFIG_PLATFORM_INTEL_BYT
2549
2550                 rtw_clr_surprise_removed(padapter);
2551                 rtw_clr_drv_stopped(padapter);
2552
2553                 status = rtw_hal_init(padapter);
2554                 if (status ==_FAIL)
2555                 {
2556                         RT_TRACE(_module_os_intfs_c_,_drv_err_,("rtl871x_hal_init(): Can't init h/w!\n"));
2557                         goto netdev_open_error;
2558                 }
2559
2560                 DBG_871X("MAC Address = "MAC_FMT"\n", MAC_ARG(pnetdev->dev_addr));
2561
2562                 status=rtw_start_drv_threads(padapter);
2563                 if(status ==_FAIL)
2564                 {
2565                         DBG_871X("Initialize driver software resource Failed!\n");
2566                         goto netdev_open_error;
2567                 }
2568
2569 #ifdef CONFIG_DRVEXT_MODULE
2570                 init_drvext(padapter);
2571 #endif
2572
2573                 if (padapter->intf_start)
2574                 {
2575                         padapter->intf_start(padapter);
2576                 }
2577
2578 #ifdef CONFIG_IOCTL_CFG80211
2579                 rtw_cfg80211_init_wiphy(padapter);
2580 #endif
2581
2582                 rtw_led_control(padapter, LED_CTL_NO_LINK);
2583
2584                 padapter->bup = _TRUE;
2585                 pwrctrlpriv->bips_processing = _FALSE;
2586
2587 #ifdef CONFIG_PLATFORM_INTEL_BYT
2588 #ifdef CONFIG_BT_COEXIST
2589                 rtw_btcoex_IpsNotify(padapter, IPS_NONE);
2590 #endif // CONFIG_BT_COEXIST
2591 #endif //CONFIG_PLATFORM_INTEL_BYT
2592         }
2593         padapter->net_closed = _FALSE;
2594
2595         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
2596
2597 #ifndef CONFIG_IPS_CHECK_IN_WD
2598         rtw_set_pwr_state_check_timer(pwrctrlpriv);
2599 #endif
2600
2601         //netif_carrier_on(pnetdev);//call this func when rtw_joinbss_event_callback return success
2602         rtw_netif_wake_queue(pnetdev);
2603
2604 #ifdef CONFIG_BR_EXT
2605         netdev_br_init(pnetdev);
2606 #endif  // CONFIG_BR_EXT
2607
2608 #ifdef CONFIG_BT_COEXIST_SOCKET_TRX
2609         if(is_primary_adapter(padapter) &&  _TRUE == pHalData->EEPROMBluetoothCoexist)
2610         {
2611                 rtw_btcoex_init_socket(padapter);
2612                 padapter->coex_info.BtMgnt.ExtConfig.HCIExtensionVer = 0x04;
2613                 rtw_btcoex_SetHciVersion(padapter,0x04);
2614         }
2615         else
2616                 DBG_871X("CONFIG_BT_COEXIST: SECONDARY_ADAPTER\n");
2617 #endif //CONFIG_BT_COEXIST_SOCKET_TRX
2618
2619
2620 netdev_open_normal_process:
2621
2622         #ifdef CONFIG_CONCURRENT_MODE
2623         {
2624                 _adapter *sec_adapter = padapter->pbuddy_adapter;
2625                 if(sec_adapter && (sec_adapter->bup == _FALSE))
2626                         _netdev_if2_open(sec_adapter->pnetdev);
2627         }
2628         #endif
2629
2630         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - dev_open\n"));
2631         DBG_871X("-871x_drv - drv_open, bup=%d\n", padapter->bup);
2632
2633         return 0;
2634
2635 netdev_open_error:
2636
2637         padapter->bup = _FALSE;
2638
2639         netif_carrier_off(pnetdev);
2640         rtw_netif_stop_queue(pnetdev);
2641
2642         RT_TRACE(_module_os_intfs_c_,_drv_err_,("-871x_drv - dev_open, fail!\n"));
2643         DBG_871X("-871x_drv - drv_open fail, bup=%d\n", padapter->bup);
2644
2645         return (-1);
2646
2647 }
2648
2649 int netdev_open(struct net_device *pnetdev)
2650 {
2651         int ret;
2652         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2653         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
2654
2655         if (pwrctrlpriv->bInSuspend == _TRUE)
2656         {
2657                 DBG_871X("+871x_drv - drv_open, bInSuspend=%d\n", pwrctrlpriv->bInSuspend);
2658                 return 0;
2659         }
2660
2661         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2662         ret = _netdev_open(pnetdev);
2663         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2664
2665         return ret;
2666 }
2667
2668 #ifdef CONFIG_IPS
2669 int  ips_netdrv_open(_adapter *padapter)
2670 {
2671         int status = _SUCCESS;
2672         //struct pwrctrl_priv   *pwrpriv = adapter_to_pwrctl(padapter);
2673
2674         padapter->net_closed = _FALSE;
2675
2676         DBG_871X("===> %s.........\n",__FUNCTION__);
2677
2678
2679         rtw_clr_drv_stopped(padapter);
2680         //padapter->bup = _TRUE;
2681
2682         status = rtw_hal_init(padapter);
2683         if (status ==_FAIL)
2684         {
2685                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("ips_netdrv_open(): Can't init h/w!\n"));
2686                 goto netdev_open_error;
2687         }
2688
2689         if (padapter->intf_start)
2690         {
2691                 padapter->intf_start(padapter);
2692         }
2693
2694 #ifndef CONFIG_IPS_CHECK_IN_WD
2695         rtw_set_pwr_state_check_timer(adapter_to_pwrctl(padapter));
2696 #endif
2697         _set_timer(&padapter->mlmepriv.dynamic_chk_timer,2000);
2698
2699          return _SUCCESS;
2700
2701 netdev_open_error:
2702         //padapter->bup = _FALSE;
2703         DBG_871X("-ips_netdrv_open - drv_open failure, bup=%d\n", padapter->bup);
2704
2705         return _FAIL;
2706 }
2707
2708
2709 int rtw_ips_pwr_up(_adapter *padapter)
2710 {
2711         int result;
2712         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
2713 #ifdef DBG_CONFIG_ERROR_DETECT
2714         struct sreset_priv *psrtpriv = &pHalData->srestpriv;
2715 #endif//#ifdef DBG_CONFIG_ERROR_DETECT
2716         u32 start_time = rtw_get_current_time();
2717         DBG_871X("===>  rtw_ips_pwr_up..............\n");
2718
2719 #if defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2720 #ifdef DBG_CONFIG_ERROR_DETECT
2721         if (psrtpriv->silent_reset_inprogress == _TRUE)
2722 #endif//#ifdef DBG_CONFIG_ERROR_DETECT
2723 #endif //defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2724                 rtw_reset_drv_sw(padapter);
2725
2726         result = ips_netdrv_open(padapter);
2727
2728         rtw_led_control(padapter, LED_CTL_NO_LINK);
2729
2730         DBG_871X("<===  rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time));
2731         return result;
2732
2733 }
2734
2735 void rtw_ips_pwr_down(_adapter *padapter)
2736 {
2737         u32 start_time = rtw_get_current_time();
2738         DBG_871X("===> rtw_ips_pwr_down...................\n");
2739
2740         padapter->net_closed = _TRUE;
2741
2742         rtw_ips_dev_unload(padapter);
2743         DBG_871X("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time));
2744 }
2745 #endif
2746 void rtw_ips_dev_unload(_adapter *padapter)
2747 {
2748         struct net_device *pnetdev= (struct net_device*)padapter->pnetdev;
2749         struct xmit_priv        *pxmitpriv = &(padapter->xmitpriv);
2750         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
2751 #ifdef DBG_CONFIG_ERROR_DETECT
2752         struct sreset_priv *psrtpriv = &pHalData->srestpriv;
2753 #endif//#ifdef DBG_CONFIG_ERROR_DETECT
2754         DBG_871X("====> %s...\n",__FUNCTION__);
2755
2756
2757 #if defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2758 #ifdef DBG_CONFIG_ERROR_DETECT
2759         if (psrtpriv->silent_reset_inprogress == _TRUE)
2760 #endif //#ifdef DBG_CONFIG_ERROR_DETECT
2761 #endif //defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2762         {
2763                 rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, 0);
2764
2765                 if (padapter->intf_stop)
2766                 {
2767                         padapter->intf_stop(padapter);
2768                 }
2769         }
2770
2771         if (!rtw_is_surprise_removed(padapter))
2772                 rtw_hal_deinit(padapter);
2773
2774 }
2775
2776
2777 int pm_netdev_open(struct net_device *pnetdev,u8 bnormal)
2778 {
2779         int status = 0;
2780
2781         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2782
2783         if (_TRUE == bnormal)
2784         {
2785                 _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2786                 status = _netdev_open(pnetdev);
2787                 _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2788         }
2789 #ifdef CONFIG_IPS
2790         else
2791                 status =  (_SUCCESS == ips_netdrv_open(padapter))?(0):(-1);
2792 #endif
2793
2794         return status;
2795 }
2796
2797 static int netdev_close(struct net_device *pnetdev)
2798 {
2799         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2800         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2801         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2802 #ifdef CONFIG_BT_COEXIST_SOCKET_TRX
2803         HAL_DATA_TYPE           *pHalData = GET_HAL_DATA(padapter);
2804 #endif //CONFIG_BT_COEXIST_SOCKET_TRX
2805
2806         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - drv_close\n"));
2807
2808 #ifndef CONFIG_PLATFORM_INTEL_BYT
2809         if(pwrctl->bInternalAutoSuspend == _TRUE)
2810         {
2811                 //rtw_pwr_wakeup(padapter);
2812                 if(pwrctl->rf_pwrstate == rf_off)
2813                         pwrctl->ps_flag = _TRUE;
2814         }
2815         padapter->net_closed = _TRUE;
2816         padapter->netif_up = _FALSE;
2817         pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
2818
2819 /*      if (!rtw_is_hw_init_completed(padapter)) {
2820                 DBG_871X("(1)871x_drv - drv_close, bup=%d, hw_init_completed=%s\n", padapter->bup, rtw_is_hw_init_completed(padapter)?"_TRUE":"_FALSE");
2821
2822                 rtw_set_drv_stopped(padapter);
2823
2824                 rtw_dev_unload(padapter);
2825         }
2826         else*/
2827         if(pwrctl->rf_pwrstate == rf_on){
2828                 DBG_871X("(2)871x_drv - drv_close, bup=%d, hw_init_completed=%s\n", padapter->bup, rtw_is_hw_init_completed(padapter)?"_TRUE":"_FALSE");
2829
2830                 //s1.
2831                 if(pnetdev)
2832                 {
2833                         rtw_netif_stop_queue(pnetdev);
2834                 }
2835
2836 #ifndef CONFIG_ANDROID
2837                 //s2.
2838                 LeaveAllPowerSaveMode(padapter);
2839                 rtw_disassoc_cmd(padapter, 500, _FALSE);
2840                 //s2-2.  indicate disconnect to os
2841                 rtw_indicate_disconnect(padapter, 0, _FALSE);
2842                 //s2-3.
2843                 rtw_free_assoc_resources(padapter, 1);
2844                 //s2-4.
2845                 rtw_free_network_queue(padapter,_TRUE);
2846 #endif
2847                 // Close LED
2848                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
2849         }
2850
2851 #ifdef CONFIG_BR_EXT
2852         //if (OPMODE & (WIFI_STATION_STATE | WIFI_ADHOC_STATE))
2853         {
2854                 //void nat25_db_cleanup(_adapter *priv);
2855                 nat25_db_cleanup(padapter);
2856         }
2857 #endif  // CONFIG_BR_EXT
2858
2859 #ifdef CONFIG_P2P
2860         if (!rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_DISABLE))
2861                 rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
2862 #endif //CONFIG_P2P
2863
2864 #ifdef CONFIG_IOCTL_CFG80211
2865         rtw_scan_abort(padapter);
2866         rtw_cfg80211_wait_scan_req_empty(padapter, 200);
2867         adapter_wdev_data(padapter)->bandroid_scan = _FALSE;
2868         //padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR; //set this at the end
2869 #endif //CONFIG_IOCTL_CFG80211
2870
2871 #ifdef CONFIG_WAPI_SUPPORT
2872         rtw_wapi_disable_tx(padapter);
2873 #endif
2874 #ifdef CONFIG_BT_COEXIST_SOCKET_TRX
2875         if(is_primary_adapter(padapter) &&  _TRUE == pHalData->EEPROMBluetoothCoexist)
2876                 rtw_btcoex_close_socket(padapter);
2877         else
2878                 DBG_871X("CONFIG_BT_COEXIST: SECONDARY_ADAPTER\n");
2879 #endif //CONFIG_BT_COEXIST_SOCKET_TRX
2880 #else //!CONFIG_PLATFORM_INTEL_BYT
2881
2882         if (pwrctl->bInSuspend == _TRUE)
2883         {
2884                 DBG_871X("+871x_drv - drv_close, bInSuspend=%d\n", pwrctl->bInSuspend);
2885                 return 0;
2886         }
2887
2888         rtw_scan_abort(padapter); // stop scanning process before wifi is going to down
2889         #ifdef CONFIG_IOCTL_CFG80211
2890         rtw_cfg80211_wait_scan_req_empty(padapter, 200);
2891         #endif
2892
2893         DBG_871X("netdev_close, bips_processing=%d\n", pwrctl->bips_processing);
2894         while (pwrctl->bips_processing == _TRUE) // waiting for ips_processing done before call rtw_dev_unload()
2895                 rtw_msleep_os(1);
2896
2897         rtw_dev_unload(padapter);
2898         rtw_sdio_set_power(0);
2899
2900 #endif //!CONFIG_PLATFORM_INTEL_BYT
2901
2902         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - drv_close\n"));
2903         DBG_871X("-871x_drv - drv_close, bup=%d\n", padapter->bup);
2904
2905         return 0;
2906
2907 }
2908
2909 int pm_netdev_close(struct net_device *pnetdev,u8 bnormal)
2910 {
2911         int status = 0;
2912
2913         status = netdev_close(pnetdev);
2914
2915         return status;
2916 }
2917
2918 void rtw_ndev_destructor(struct net_device *ndev)
2919 {
2920         DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2921
2922 #ifdef CONFIG_IOCTL_CFG80211
2923         if (ndev->ieee80211_ptr)
2924                 rtw_mfree((u8 *)ndev->ieee80211_ptr, sizeof(struct wireless_dev));
2925 #endif
2926         free_netdev(ndev);
2927 }
2928
2929 #ifdef CONFIG_ARP_KEEP_ALIVE
2930 struct route_info {
2931     struct in_addr dst_addr;
2932     struct in_addr src_addr;
2933     struct in_addr gateway;
2934     unsigned int dev_index;
2935 };
2936
2937 static void parse_routes(struct nlmsghdr *nl_hdr, struct route_info *rt_info)
2938 {
2939     struct rtmsg *rt_msg;
2940     struct rtattr *rt_attr;
2941     int rt_len;
2942
2943     rt_msg = (struct rtmsg *) NLMSG_DATA(nl_hdr);
2944     if ((rt_msg->rtm_family != AF_INET) || (rt_msg->rtm_table != RT_TABLE_MAIN))
2945         return;
2946
2947     rt_attr = (struct rtattr *) RTM_RTA(rt_msg);
2948     rt_len = RTM_PAYLOAD(nl_hdr);
2949
2950     for (; RTA_OK(rt_attr, rt_len); rt_attr = RTA_NEXT(rt_attr, rt_len))
2951         {
2952         switch (rt_attr->rta_type) {
2953         case RTA_OIF:
2954                 rt_info->dev_index = *(int *) RTA_DATA(rt_attr);
2955             break;
2956         case RTA_GATEWAY:
2957             rt_info->gateway.s_addr = *(u_int *) RTA_DATA(rt_attr);
2958             break;
2959         case RTA_PREFSRC:
2960             rt_info->src_addr.s_addr = *(u_int *) RTA_DATA(rt_attr);
2961             break;
2962         case RTA_DST:
2963             rt_info->dst_addr.s_addr = *(u_int *) RTA_DATA(rt_attr);
2964             break;
2965         }
2966     }
2967 }
2968
2969 static int route_dump(u32 *gw_addr ,int* gw_index)
2970 {
2971         int err = 0;
2972         struct socket *sock;
2973         struct {
2974                 struct nlmsghdr nlh;
2975                 struct rtgenmsg g;
2976         } req;
2977         struct msghdr msg;
2978         struct iovec iov;
2979         struct sockaddr_nl nladdr;
2980         mm_segment_t oldfs;
2981         char *pg;
2982         int size = 0;
2983
2984         err = sock_create(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE, &sock);
2985         if (err)
2986         {
2987                 printk( ": Could not create a datagram socket, error = %d\n", -ENXIO);
2988                 return err;
2989         }
2990
2991         memset(&nladdr, 0, sizeof(nladdr));
2992         nladdr.nl_family = AF_NETLINK;
2993
2994         req.nlh.nlmsg_len = sizeof(req);
2995         req.nlh.nlmsg_type = RTM_GETROUTE;
2996         req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
2997         req.nlh.nlmsg_pid = 0;
2998         req.g.rtgen_family = AF_INET;
2999
3000         iov.iov_base = &req;
3001         iov.iov_len = sizeof(req);
3002
3003         msg.msg_name = &nladdr;
3004         msg.msg_namelen = sizeof(nladdr);
3005 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
3006         /* referece:sock_xmit in kernel code
3007          * WRITE for sock_sendmsg, READ for sock_recvmsg
3008          * third parameter for msg_iovlen
3009          * last parameter for iov_len
3010          */
3011         iov_iter_init(&msg.msg_iter, WRITE, &iov, 1, sizeof(req));
3012 #else
3013         msg.msg_iov = &iov;
3014         msg.msg_iovlen = 1;
3015 #endif
3016         msg.msg_control = NULL;
3017         msg.msg_controllen = 0;
3018         msg.msg_flags = MSG_DONTWAIT;
3019
3020         oldfs = get_fs(); set_fs(KERNEL_DS);
3021 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0))
3022         err = sock_sendmsg(sock, &msg);
3023 #else
3024         err = sock_sendmsg(sock, &msg, sizeof(req));
3025 #endif
3026         set_fs(oldfs);
3027
3028         if (err < 0)
3029                 goto out_sock;
3030
3031         pg = (char *) __get_free_page(GFP_KERNEL);
3032         if (pg == NULL) {
3033                 err = -ENOMEM;
3034                 goto out_sock;
3035         }
3036
3037 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
3038 restart:
3039 #endif
3040
3041         for (;;)
3042         {
3043                 struct nlmsghdr *h;
3044
3045                 iov.iov_base = pg;
3046                 iov.iov_len = PAGE_SIZE;
3047
3048 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
3049                 iov_iter_init(&msg.msg_iter, READ, &iov, 1, PAGE_SIZE);
3050 #endif
3051
3052                 oldfs = get_fs(); set_fs(KERNEL_DS);
3053                 err = sock_recvmsg(sock, &msg, PAGE_SIZE, MSG_DONTWAIT);
3054                 set_fs(oldfs);
3055
3056                 if (err < 0)
3057                         goto out_sock_pg;
3058
3059                 if (msg.msg_flags & MSG_TRUNC) {
3060                         err = -ENOBUFS;
3061                         goto out_sock_pg;
3062                 }
3063
3064                 h = (struct nlmsghdr*) pg;
3065
3066                 while (NLMSG_OK(h, err))
3067                 {
3068                         struct route_info rt_info;
3069                         if (h->nlmsg_type == NLMSG_DONE) {
3070                                 err = 0;
3071                                 goto done;
3072                         }
3073
3074                         if (h->nlmsg_type == NLMSG_ERROR) {
3075                                 struct nlmsgerr *errm = (struct nlmsgerr*) NLMSG_DATA(h);
3076                                 err = errm->error;
3077                                 printk( "NLMSG error: %d\n", errm->error);
3078                                 goto done;
3079                         }
3080
3081                         if (h->nlmsg_type == RTM_GETROUTE)
3082                         {
3083                                 printk( "RTM_GETROUTE: NLMSG: %d\n", h->nlmsg_type);
3084                         }
3085                         if (h->nlmsg_type != RTM_NEWROUTE) {
3086                                 printk( "NLMSG: %d\n", h->nlmsg_type);
3087                                 err = -EINVAL;
3088                                 goto done;
3089                         }
3090
3091                         memset(&rt_info, 0, sizeof(struct route_info));
3092                         parse_routes(h, &rt_info);
3093                         if(!rt_info.dst_addr.s_addr && rt_info.gateway.s_addr && rt_info.dev_index)
3094                         {
3095                                 *gw_addr = rt_info.gateway.s_addr;
3096                                 *gw_index = rt_info.dev_index;
3097
3098                         }
3099                         h = NLMSG_NEXT(h, err);
3100                 }
3101
3102                 if (err)
3103                 {
3104                         printk( "!!!Remnant of size %d %d %d\n", err, h->nlmsg_len, h->nlmsg_type);
3105                         err = -EINVAL;
3106                         break;
3107                 }
3108         }
3109
3110 done:
3111 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
3112         if (!err && req.g.rtgen_family == AF_INET) {
3113                 req.g.rtgen_family = AF_INET6;
3114
3115                 iov.iov_base = &req;
3116                 iov.iov_len = sizeof(req);
3117
3118                 msg.msg_name = &nladdr;
3119                 msg.msg_namelen = sizeof(nladdr);
3120 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
3121                 iov_iter_init(&msg.msg_iter, WRITE, &iov, 1, sizeof(req));
3122 #else
3123                 msg.msg_iov = &iov;
3124                 msg.msg_iovlen = 1;
3125 #endif
3126                 msg.msg_control = NULL;
3127                 msg.msg_controllen = 0;
3128                 msg.msg_flags=MSG_DONTWAIT;
3129
3130                 oldfs = get_fs(); set_fs(KERNEL_DS);
3131 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0))
3132                 err = sock_sendmsg(sock, &msg);
3133 #else
3134                 err = sock_sendmsg(sock, &msg, sizeof(req));
3135 #endif
3136                 set_fs(oldfs);
3137
3138                 if (err > 0)
3139                         goto restart;
3140         }
3141 #endif
3142
3143 out_sock_pg:
3144         free_page((unsigned long) pg);
3145
3146 out_sock:
3147         sock_release(sock);
3148         return err;
3149 }
3150
3151 static int arp_query(unsigned char *haddr, u32 paddr,
3152              struct net_device *dev)
3153 {
3154         struct neighbour *neighbor_entry;
3155         int     ret = 0;
3156
3157         neighbor_entry = neigh_lookup(&arp_tbl, &paddr, dev);
3158
3159         if (neighbor_entry != NULL) {
3160                 neighbor_entry->used = jiffies;
3161                 if (neighbor_entry->nud_state & NUD_VALID) {
3162                         _rtw_memcpy(haddr, neighbor_entry->ha, dev->addr_len);
3163                         ret = 1;
3164                 }
3165                 neigh_release(neighbor_entry);
3166         }
3167         return ret;
3168 }
3169
3170 static int get_defaultgw(u32 *ip_addr ,char mac[])
3171 {
3172         int gw_index = 0; // oif device index
3173         struct net_device *gw_dev = NULL; //oif device
3174
3175         route_dump(ip_addr, &gw_index);
3176
3177         if( !(*ip_addr) || !gw_index )
3178         {
3179                 //DBG_871X("No default GW \n");
3180                 return -1;
3181         }
3182
3183         gw_dev = dev_get_by_index(&init_net, gw_index);
3184
3185         if(gw_dev == NULL)
3186         {
3187                 //DBG_871X("get Oif Device Fail \n");
3188                 return -1;
3189         }
3190
3191         if(!arp_query(mac, *ip_addr, gw_dev))
3192         {
3193                 //DBG_871X( "arp query failed\n");
3194                 dev_put(gw_dev);
3195                 return -1;
3196
3197         }
3198         dev_put(gw_dev);
3199
3200         return 0;
3201 }
3202
3203 int     rtw_gw_addr_query(_adapter *padapter)
3204 {
3205         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
3206         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
3207         u32 gw_addr = 0; // default gw address
3208         unsigned char gw_mac[32] = {0}; // default gw mac
3209         int i;
3210         int res;
3211
3212         res = get_defaultgw(&gw_addr, gw_mac);
3213         if(!res)
3214         {
3215                 pmlmepriv->gw_ip[0] = gw_addr&0xff;
3216                 pmlmepriv->gw_ip[1] = (gw_addr&0xff00)>>8;
3217                 pmlmepriv->gw_ip[2] = (gw_addr&0xff0000)>>16;
3218                 pmlmepriv->gw_ip[3] = (gw_addr&0xff000000)>>24;
3219                 _rtw_memcpy(pmlmepriv->gw_mac_addr, gw_mac, 6);
3220                 DBG_871X("%s Gateway Mac:\t" MAC_FMT "\n", __FUNCTION__, MAC_ARG(pmlmepriv->gw_mac_addr));
3221                 DBG_871X("%s Gateway IP:\t" IP_FMT "\n", __FUNCTION__, IP_ARG(pmlmepriv->gw_ip));
3222         }
3223         else
3224         {
3225                 DBG_871X("Get Gateway IP/MAC fail!\n");
3226         }
3227
3228         return res;
3229 }
3230 #endif
3231
3232 void rtw_dev_unload(PADAPTER padapter)
3233 {
3234         struct net_device *pnetdev = (struct net_device*)padapter->pnetdev;
3235         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
3236         struct dvobj_priv *pobjpriv = padapter->dvobj;
3237         struct debug_priv *pdbgpriv = &pobjpriv->drv_dbg;
3238         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
3239         u8 cnt = 0;
3240
3241         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+%s\n",__FUNCTION__));
3242
3243         if (padapter->bup == _TRUE)
3244         {
3245                 DBG_871X("===> %s\n",__FUNCTION__);
3246
3247                 rtw_set_drv_stopped(padapter);
3248                 #ifdef CONFIG_XMIT_ACK
3249                 if (padapter->xmitpriv.ack_tx)
3250                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
3251                 #endif
3252
3253                 if (padapter->intf_stop)
3254                         padapter->intf_stop(padapter);
3255
3256                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("@ rtw_dev_unload: stop intf complete!\n"));
3257
3258                 if (!pwrctl->bInternalAutoSuspend)
3259                         rtw_stop_drv_threads(padapter);
3260
3261                 while(ATOMIC_READ(&(pcmdpriv->cmdthd_running)) == _TRUE){
3262                         if (cnt > 5) {
3263                                 DBG_871X("stop cmdthd timeout\n");
3264                                 break;
3265                         } else {
3266                                 cnt ++;
3267                                 DBG_871X("cmdthd is running(%d)\n", cnt);
3268                                 rtw_msleep_os(10);
3269                         }
3270                 }
3271
3272                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("@ %s: stop thread complete!\n",__FUNCTION__));
3273
3274                 //check the status of IPS
3275                 if(rtw_hal_check_ips_status(padapter) == _TRUE || pwrctl->rf_pwrstate == rf_off) { //check HW status and SW state
3276                         DBG_871X_LEVEL(_drv_always_, "%s: driver in IPS-FWLPS\n", __func__);
3277                         pdbgpriv->dbg_dev_unload_inIPS_cnt++;
3278                 } else {
3279                         DBG_871X_LEVEL(_drv_always_, "%s: driver not in IPS\n", __func__);
3280                 }
3281
3282                 if (!rtw_is_surprise_removed(padapter)) {
3283 #ifdef CONFIG_BT_COEXIST
3284                         rtw_btcoex_IpsNotify(padapter, pwrctl->ips_mode_req);
3285 #endif
3286                         {
3287                                 //amy modify 20120221 for power seq is different between driver open and ips
3288                                 rtw_hal_deinit(padapter);
3289                         }
3290                         rtw_set_surprise_removed(padapter);
3291                 }
3292                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("@ %s: deinit hal complelt!\n",__FUNCTION__));
3293
3294                 padapter->bup = _FALSE;
3295
3296                 DBG_871X("<=== %s\n",__FUNCTION__);
3297         }
3298         else {
3299                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("%s: bup==_FALSE\n",__FUNCTION__));
3300                 DBG_871X("%s: bup==_FALSE\n",__FUNCTION__);
3301         }
3302
3303         /* cancel timer after thread stop */
3304         rtw_cancel_all_timer(padapter);
3305         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-%s\n",__FUNCTION__));
3306 }
3307
3308 int rtw_suspend_free_assoc_resource(_adapter *padapter)
3309 {
3310         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3311         struct net_device *pnetdev = padapter->pnetdev;
3312 #ifdef CONFIG_P2P
3313         struct wifidirect_info* pwdinfo = &padapter->wdinfo;
3314 #endif // CONFIG_P2P
3315
3316         DBG_871X("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3317
3318         if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
3319                 if(check_fwstate(pmlmepriv, WIFI_STATION_STATE)
3320                         && check_fwstate(pmlmepriv, _FW_LINKED)
3321 #ifdef CONFIG_P2P
3322                         && rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)
3323 #endif // CONFIG_P2P
3324                         )
3325                 {
3326                         DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n",__FUNCTION__,
3327                                         pmlmepriv->cur_network.network.Ssid.Ssid,
3328                                         MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
3329                                         pmlmepriv->cur_network.network.Ssid.SsidLength,
3330                                         pmlmepriv->assoc_ssid.SsidLength);
3331                         rtw_set_to_roam(padapter, 1);
3332                 }
3333         }
3334
3335         if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED))
3336         {
3337                 rtw_disassoc_cmd(padapter, 0, _FALSE);
3338                 //s2-2.  indicate disconnect to os
3339                 rtw_indicate_disconnect(padapter, 0, _FALSE);
3340         }
3341         #ifdef CONFIG_AP_MODE
3342         else if(check_fwstate(pmlmepriv, WIFI_AP_STATE))
3343         {
3344                 rtw_sta_flush(padapter, _TRUE);
3345         }
3346         #endif
3347
3348         //s2-3.
3349         rtw_free_assoc_resources(padapter, 1);
3350
3351         //s2-4.
3352 #ifdef CONFIG_AUTOSUSPEND
3353         if(is_primary_adapter(padapter) && (!adapter_to_pwrctl(padapter)->bInternalAutoSuspend ))
3354 #endif
3355                 rtw_free_network_queue(padapter, _TRUE);
3356
3357         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
3358                 DBG_871X_LEVEL(_drv_always_, "%s: fw_under_survey\n", __func__);
3359                 rtw_indicate_scan_done(padapter, 1);
3360                 clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
3361         }
3362
3363         if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == _TRUE)
3364         {
3365                 DBG_871X_LEVEL(_drv_always_, "%s: fw_under_linking\n", __FUNCTION__);
3366                 rtw_indicate_disconnect(padapter, 0, _FALSE);
3367         }
3368
3369         DBG_871X("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3370         return _SUCCESS;
3371 }
3372
3373 int rtw_suspend_normal(_adapter *padapter)
3374 {
3375         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3376         struct net_device *pnetdev = padapter->pnetdev;
3377         #ifdef CONFIG_CONCURRENT_MODE
3378         struct net_device *pbuddy_netdev = padapter->pbuddy_adapter->pnetdev;
3379         #endif
3380         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3381         int ret = _SUCCESS;
3382
3383         DBG_871X("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3384         if(pnetdev){
3385                 netif_carrier_off(pnetdev);
3386                 rtw_netif_stop_queue(pnetdev);
3387         }
3388 #ifdef CONFIG_CONCURRENT_MODE
3389         if(rtw_buddy_adapter_up(padapter)){
3390                 pbuddy_netdev = padapter->pbuddy_adapter->pnetdev;
3391                 netif_carrier_off(pbuddy_netdev);
3392                 rtw_netif_stop_queue(pbuddy_netdev);
3393         }
3394 #endif
3395
3396         rtw_suspend_free_assoc_resource(padapter);
3397
3398 #ifdef CONFIG_CONCURRENT_MODE
3399         if(rtw_buddy_adapter_up(padapter)){
3400                 rtw_suspend_free_assoc_resource(padapter->pbuddy_adapter);
3401         }
3402 #endif
3403         rtw_led_control(padapter, LED_CTL_POWER_OFF);
3404
3405         if ((rtw_hal_check_ips_status(padapter) == _TRUE)
3406                 || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off))
3407         {
3408                 DBG_871X_LEVEL(_drv_always_, "%s: ### ERROR #### driver in IPS ####ERROR###!!!\n", __FUNCTION__);
3409
3410         }
3411
3412 #ifdef CONFIG_CONCURRENT_MODE
3413         if(rtw_buddy_adapter_up(padapter)){
3414                 rtw_dev_unload(padapter->pbuddy_adapter);
3415         }
3416 #endif
3417         rtw_dev_unload(padapter);
3418
3419         //sdio_deinit(adapter_to_dvobj(padapter));
3420         if(padapter->intf_deinit)
3421                 padapter->intf_deinit(adapter_to_dvobj(padapter));
3422
3423         DBG_871X("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3424         return ret;
3425 }
3426
3427 int rtw_suspend_common(_adapter *padapter)
3428 {
3429         struct dvobj_priv *psdpriv = padapter->dvobj;
3430         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
3431         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
3432         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3433
3434         int ret = 0;
3435         u32 start_time = rtw_get_current_time();
3436
3437         DBG_871X_LEVEL(_drv_always_, " suspend start\n");
3438         DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
3439
3440         pdbgpriv->dbg_suspend_cnt++;
3441
3442         pwrpriv->bInSuspend = _TRUE;
3443
3444         while (pwrpriv->bips_processing == _TRUE)
3445                 rtw_msleep_os(1);
3446
3447 #ifdef CONFIG_IOL_READ_EFUSE_MAP
3448         if(!padapter->bup){
3449                 u8 bMacPwrCtrlOn = _FALSE;
3450                 rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
3451                 if(bMacPwrCtrlOn)
3452                         rtw_hal_power_off(padapter);
3453         }
3454 #endif
3455
3456         if ((!padapter->bup) || RTW_CANNOT_RUN(padapter)) {
3457                 DBG_871X("%s bup=%d bDriverStopped=%s bSurpriseRemoved = %s\n", __func__
3458                         , padapter->bup
3459                         , rtw_is_drv_stopped(padapter)?"True":"False"
3460                         , rtw_is_surprise_removed(padapter)?"True":"False");
3461                 pdbgpriv->dbg_suspend_error_cnt++;
3462                 goto exit;
3463         }
3464         rtw_ps_deny(padapter, PS_DENY_SUSPEND);
3465
3466         rtw_cancel_all_timer(padapter);
3467 #ifdef CONFIG_CONCURRENT_MODE
3468         if (padapter->pbuddy_adapter){
3469                 rtw_cancel_all_timer(padapter->pbuddy_adapter);
3470         }
3471 #endif // CONFIG_CONCURRENT_MODE
3472
3473         LeaveAllPowerSaveModeDirect(padapter);
3474
3475         rtw_stop_cmd_thread(padapter);
3476
3477 #ifdef CONFIG_BT_COEXIST
3478         // wait for the latest FW to remove this condition.
3479         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) {
3480                 rtw_btcoex_SuspendNotify(padapter, 0);
3481                 DBG_871X("WIFI_AP_STATE\n");
3482 #ifdef CONFIG_CONCURRENT_MODE
3483         } else if (check_buddy_fwstate(padapter, WIFI_AP_STATE)) {
3484                 rtw_btcoex_SuspendNotify(padapter, 0);
3485                 DBG_871X("P2P_ROLE_GO\n");
3486 #endif //CONFIG_CONCURRENT_MODE
3487         } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE) {
3488                 rtw_btcoex_SuspendNotify(padapter, 1);
3489                 DBG_871X("STATION\n");
3490         }
3491 #endif // CONFIG_BT_COEXIST
3492
3493         rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
3494
3495         if (check_fwstate(pmlmepriv,WIFI_STATION_STATE) == _TRUE
3496 #ifdef CONFIG_CONCURRENT_MODE
3497                 && check_buddy_fwstate(padapter, WIFI_AP_STATE) == _FALSE
3498 #endif
3499         ) {
3500                 rtw_suspend_normal(padapter);
3501         } else if (check_fwstate(pmlmepriv,WIFI_AP_STATE) == _TRUE
3502 #ifdef CONFIG_CONCURRENT_MODE
3503                 && check_buddy_fwstate(padapter, WIFI_AP_STATE) == _FALSE
3504 #endif
3505         ) {
3506                 rtw_suspend_normal(padapter);
3507 #ifdef CONFIG_CONCURRENT_MODE
3508         } else if (check_fwstate(pmlmepriv,WIFI_STATION_STATE) == _TRUE
3509                 && check_buddy_fwstate(padapter, WIFI_AP_STATE) == _TRUE) {
3510                 rtw_suspend_normal(padapter);
3511 #endif
3512         } else {
3513                 rtw_suspend_normal(padapter);
3514         }
3515
3516
3517         DBG_871X_LEVEL(_drv_always_, "rtw suspend success in %d ms\n",
3518                 rtw_get_passing_time_ms(start_time));
3519
3520 exit:
3521         DBG_871X("<===  %s return %d.............. in %dms\n", __FUNCTION__
3522                 , ret, rtw_get_passing_time_ms(start_time));
3523
3524         return ret;
3525 }
3526
3527 int rtw_resume_process_normal(_adapter *padapter)
3528 {
3529         struct net_device *pnetdev;
3530         #ifdef CONFIG_CONCURRENT_MODE
3531         struct net_device *pbuddy_netdev;
3532         #endif
3533         struct pwrctrl_priv *pwrpriv;
3534         struct mlme_priv *pmlmepriv;
3535         struct dvobj_priv *psdpriv;
3536         struct debug_priv *pdbgpriv;
3537
3538         int ret = _SUCCESS;
3539 _func_enter_;
3540
3541         if (!padapter) {
3542                 ret = -1;
3543                 goto exit;
3544         }
3545
3546         pnetdev = padapter->pnetdev;
3547         pwrpriv = adapter_to_pwrctl(padapter);
3548         pmlmepriv = &padapter->mlmepriv;
3549         psdpriv = padapter->dvobj;
3550         pdbgpriv = &psdpriv->drv_dbg;
3551
3552         DBG_871X("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3553         // interface init
3554         //if (sdio_init(adapter_to_dvobj(padapter)) != _SUCCESS)
3555         if((padapter->intf_init)&& (padapter->intf_init(adapter_to_dvobj(padapter)) != _SUCCESS))
3556         {
3557                 ret = -1;
3558                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: initialize SDIO Failed!!\n", __FUNCTION__));
3559                 goto exit;
3560         }
3561         rtw_hal_disable_interrupt(padapter);
3562         //if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)
3563         if ((padapter->intf_alloc_irq)&&(padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS))
3564         {
3565                 ret = -1;
3566                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: sdio_alloc_irq Failed!!\n", __FUNCTION__));
3567                 goto exit;
3568         }
3569
3570         rtw_reset_drv_sw(padapter);
3571         #ifdef CONFIG_CONCURRENT_MODE
3572         rtw_reset_drv_sw(padapter->pbuddy_adapter);
3573         #endif
3574
3575         pwrpriv->bkeepfwalive = _FALSE;
3576
3577         DBG_871X("bkeepfwalive(%x)\n",pwrpriv->bkeepfwalive);
3578         if(pm_netdev_open(pnetdev,_TRUE) != 0) {
3579                 ret = -1;
3580                 pdbgpriv->dbg_resume_error_cnt++;
3581                 goto exit;
3582         }
3583
3584         netif_device_attach(pnetdev);
3585         netif_carrier_on(pnetdev);
3586
3587         #ifdef CONFIG_CONCURRENT_MODE
3588         if(rtw_buddy_adapter_up(padapter)){
3589                 pbuddy_netdev = padapter->pbuddy_adapter->pnetdev;
3590
3591                 netif_device_attach(pbuddy_netdev);
3592                 netif_carrier_on(pbuddy_netdev);
3593         }
3594         #endif
3595
3596
3597         if( padapter->pid[1]!=0) {
3598                 DBG_871X("pid[1]:%d\n",padapter->pid[1]);
3599                 rtw_signal_process(padapter->pid[1], SIGUSR2);
3600         }
3601
3602
3603         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
3604                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
3605
3606                 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME))
3607                         rtw_roaming(padapter, NULL);
3608
3609         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
3610                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_AP_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
3611                 rtw_ap_restore_network(padapter);
3612         } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
3613                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
3614         } else {
3615                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
3616         }
3617
3618         #ifdef CONFIG_CONCURRENT_MODE
3619         if(rtw_buddy_adapter_up(padapter))
3620         {
3621                 _adapter *buddy = padapter->pbuddy_adapter;
3622                 struct mlme_priv *buddy_mlme = &padapter->pbuddy_adapter->mlmepriv;
3623                 if (check_fwstate(buddy_mlme, WIFI_STATION_STATE)) {
3624                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(buddy), get_fwstate(buddy_mlme));
3625
3626                         if (rtw_chk_roam_flags(buddy, RTW_ROAM_ON_RESUME))
3627                                 rtw_roaming(buddy, NULL);
3628
3629                 } else if (check_fwstate(buddy_mlme, WIFI_AP_STATE)) {
3630                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_AP_STATE\n", FUNC_ADPT_ARG(buddy), get_fwstate(buddy_mlme));
3631                         rtw_ap_restore_network(buddy);
3632                 } else if (check_fwstate(buddy_mlme, WIFI_ADHOC_STATE)) {
3633                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(buddy), get_fwstate(buddy_mlme));
3634                 } else {
3635                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(buddy), get_fwstate(buddy_mlme));
3636                 }
3637         }
3638         #endif
3639 #ifdef CONFIG_SW_LED
3640         rtw_hal_sw_led_init(padapter);
3641 #endif
3642 #ifdef CONFIG_RESUME_IN_WORKQUEUE
3643         //rtw_unlock_suspend();
3644 #endif //CONFIG_RESUME_IN_WORKQUEUE
3645         DBG_871X("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3646
3647 exit:
3648 _func_exit_;
3649         return ret;
3650 }
3651
3652 int rtw_resume_common(_adapter *padapter)
3653 {
3654         int ret = 0;
3655         u32 start_time = rtw_get_current_time();
3656         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3657         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3658
3659         _func_enter_;
3660
3661         if (pwrpriv->bInSuspend == _FALSE)
3662                 return 0;
3663
3664         DBG_871X_LEVEL(_drv_always_, "resume start\n");
3665         DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
3666
3667         if (check_fwstate(pmlmepriv,WIFI_STATION_STATE) == _TRUE
3668 #ifdef CONFIG_CONCURRENT_MODE
3669                 && check_buddy_fwstate(padapter, WIFI_AP_STATE) == _FALSE
3670 #endif
3671         ) {
3672                 rtw_resume_process_normal(padapter);
3673
3674         } else if (check_fwstate(pmlmepriv,WIFI_AP_STATE) == _TRUE
3675 #ifdef CONFIG_CONCURRENT_MODE
3676                 && check_buddy_fwstate(padapter, WIFI_AP_STATE) == _FALSE
3677 #endif
3678         ) {
3679                 rtw_resume_process_normal(padapter);
3680 #ifdef CONFIG_CONCURRENT_MODE
3681         } else if (check_fwstate(pmlmepriv,WIFI_STATION_STATE) == _TRUE
3682                 && check_buddy_fwstate(padapter, WIFI_AP_STATE) == _TRUE) {
3683                 rtw_resume_process_normal(padapter);
3684 #endif
3685         } else {
3686                 rtw_resume_process_normal(padapter);
3687         }
3688
3689         #ifdef CONFIG_BT_COEXIST
3690         rtw_btcoex_SuspendNotify(padapter, 0);
3691         #endif // CONFIG_BT_COEXIST
3692
3693         if (pwrpriv) {
3694                 pwrpriv->bInSuspend = _FALSE;
3695         }
3696         DBG_871X_LEVEL(_drv_always_, "%s:%d in %d ms\n", __FUNCTION__ ,ret,
3697                 rtw_get_passing_time_ms(start_time));
3698
3699         _func_exit_;
3700
3701         return ret;
3702 }
3703
3704 #ifdef CONFIG_GPIO_API
3705 u8 rtw_get_gpio(struct net_device *netdev, u8 gpio_num)
3706 {
3707         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3708         return rtw_hal_get_gpio(adapter, gpio_num);
3709 }
3710 EXPORT_SYMBOL(rtw_get_gpio);
3711
3712 int  rtw_set_gpio_output_value(struct net_device *netdev, u8 gpio_num, bool isHigh)
3713 {
3714         u8 direction = 0;
3715         u8 res = -1;
3716         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3717         return rtw_hal_set_gpio_output_value(adapter, gpio_num,isHigh);
3718 }
3719 EXPORT_SYMBOL(rtw_set_gpio_output_value);
3720
3721 int rtw_config_gpio(struct net_device *netdev, u8 gpio_num, bool isOutput)
3722 {
3723         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3724         return rtw_hal_config_gpio(adapter,gpio_num,isOutput);
3725 }
3726 EXPORT_SYMBOL(rtw_config_gpio);
3727 int rtw_register_gpio_interrupt(struct net_device *netdev, int gpio_num, void(*callback)(u8 level))
3728 {
3729         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3730         return rtw_hal_register_gpio_interrupt(adapter,gpio_num,callback);
3731 }
3732 EXPORT_SYMBOL(rtw_register_gpio_interrupt);
3733
3734 int rtw_disable_gpio_interrupt(struct net_device *netdev, int gpio_num)
3735 {
3736         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3737         return rtw_hal_disable_gpio_interrupt(adapter,gpio_num);
3738 }
3739 EXPORT_SYMBOL(rtw_disable_gpio_interrupt);
3740
3741 #endif //#ifdef CONFIG_GPIO_API