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