drivers/net/wireless/rockchip_wlan/rtl8189es/os_dep/linux/os_intfs.c

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