drivers/net/wireless/rtl8723au/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_conf.h>
  23
  24 #if defined (PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
  25
  26 #error "Shall be Linux or Windows, but not both!\n"
  27
  28 #endif
  29
  30 #include <osdep_service.h>
  31 #include <drv_types.h>
  32 #include <xmit_osdep.h>
  33 #include <recv_osdep.h>
  34 #include <hal_intf.h>
  35 #include <rtw_ioctl.h>
  36 #include <rtw_version.h>
  37
  38 #ifdef CONFIG_USB_HCI
  39 #include <usb_osintf.h>
  40 #endif
  41
  42 #ifdef CONFIG_PCI_HCI
  43 #include <pci_osintf.h>
  44 #endif
  45
  46 #ifdef CONFIG_BR_EXT
  47 #include <rtw_br_ext.h>
  48 #endif //CONFIG_BR_EXT
  49
  50 #ifdef CONFIG_RF_GAIN_OFFSET
  51 #ifdef CONFIG_RTL8723A
  52 #define RF_GAIN_OFFSET_ON                       BIT0
  53 #define         REG_RF_BB_GAIN_OFFSET   0x7f
  54 #define         RF_GAIN_OFFSET_MASK             0xfffff
  55 #else
  56 #define RF_GAIN_OFFSET_ON                       BIT4
  57 #define         REG_RF_BB_GAIN_OFFSET   0x55
  58 #define         RF_GAIN_OFFSET_MASK             0xfffff
  59 #endif  //CONFIG_RTL8723A
  60 #endif //CONFIG_RF_GAIN_OFFSET
  61
  62 MODULE_LICENSE("GPL");
  63 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
  64 MODULE_AUTHOR("Realtek Semiconductor Corp.");
  65 MODULE_VERSION(DRIVERVERSION);
  66
  67 /* module param defaults */
  68 int rtw_chip_version = 0x00;
  69 int rtw_rfintfs = HWPI;
  70 int rtw_lbkmode = 0;//RTL8712_AIR_TRX;
  71
  72
  73 int rtw_network_mode = Ndis802_11IBSS;//Ndis802_11Infrastructure;//infra, ad-hoc, auto
  74 //NDIS_802_11_SSID      ssid;
  75 int rtw_channel = 1;//ad-hoc support requirement
  76 int rtw_wireless_mode = WIRELESS_11BG_24N;
  77 int rtw_vrtl_carrier_sense = AUTO_VCS;
  78 int rtw_vcs_type = RTS_CTS;//*
  79 int rtw_rts_thresh = 2347;//*
  80 int rtw_frag_thresh = 2346;//*
  81 int rtw_preamble = PREAMBLE_LONG;//long, short, auto
  82 int rtw_scan_mode = 1;//active, passive
  83 int rtw_adhoc_tx_pwr = 1;
  84 int rtw_soft_ap = 0;
  85 //int smart_ps = 1;
  86 #ifdef CONFIG_POWER_SAVING
  87 int rtw_power_mgnt = 1;
  88 #ifdef CONFIG_IPS_LEVEL_2
  89 int rtw_ips_mode = IPS_LEVEL_2;
  90 #else
  91 int rtw_ips_mode = IPS_NORMAL;
  92 #endif
  93 #else
  94 int rtw_power_mgnt = PS_MODE_ACTIVE;
  95 int rtw_ips_mode = IPS_NONE;
  96 #endif
  97
  98 int rtw_smart_ps = 2;
  99
 100 #ifdef CONFIG_TX_EARLY_MODE
 101 int rtw_early_mode=1;
 102 #endif
 103 module_param(rtw_ips_mode, int, 0644);
 104 MODULE_PARM_DESC(rtw_ips_mode,"The default IPS mode");
 105
 106 int rtw_radio_enable = 1;
 107 int rtw_long_retry_lmt = 7;
 108 int rtw_short_retry_lmt = 7;
 109 int rtw_busy_thresh = 40;
 110 //int qos_enable = 0; //*
 111 int rtw_ack_policy = NORMAL_ACK;
 112
 113 int rtw_mp_mode = 0;
 114
 115 int rtw_software_encrypt = 0;
 116 int rtw_software_decrypt = 0;
 117
 118 int rtw_acm_method = 0;// 0:By SW 1:By HW.
 119
 120 int rtw_wmm_enable = 1;// default is set to enable the wmm.
 121 int rtw_uapsd_enable = 0;
 122 int rtw_uapsd_max_sp = NO_LIMIT;
 123 int rtw_uapsd_acbk_en = 0;
 124 int rtw_uapsd_acbe_en = 0;
 125 int rtw_uapsd_acvi_en = 0;
 126 int rtw_uapsd_acvo_en = 0;
 127
 128 #ifdef CONFIG_80211N_HT
 129 int rtw_ht_enable = 1;
 130 int rtw_cbw40_enable = 3; // 0 :diable, bit(0): enable 2.4g, bit(1): enable 5g
 131 int rtw_ampdu_enable = 1;//for enable tx_ampdu
 132 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
 133 int rtw_ampdu_amsdu = 0;// 0: disabled, 1:enabled, 2:auto
 134 #endif
 135
 136 int rtw_lowrate_two_xmit = 1;//Use 2 path Tx to transmit MCS0~7 and legacy mode
 137
 138 //int rf_config = RF_1T2R;  // 1T2R
 139 int rtw_rf_config = RF_819X_MAX_TYPE;  //auto
 140 int rtw_low_power = 0;
 141 #ifdef CONFIG_WIFI_TEST
 142 int rtw_wifi_spec = 1;//for wifi test
 143 #else
 144 int rtw_wifi_spec = 0;
 145 #endif
 146 int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
 147
 148 #ifdef CONFIG_BT_COEXIST
 149 int rtw_btcoex_enable = 1;
 150 int rtw_bt_iso = 2;// 0:Low, 1:High, 2:From Efuse
 151 int rtw_bt_sco = 3;// 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter, 4.Busy, 5.OtherBusy
 152 int rtw_bt_ampdu =1 ;// 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU.
 153 #endif
 154
 155 int rtw_AcceptAddbaReq = _TRUE;// 0:Reject AP's Add BA req, 1:Accept AP's Add BA req.
 156
 157 int rtw_antdiv_cfg = 2; // 0:OFF , 1:ON, 2:decide by Efuse config
 158 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)
 159
 160
 161 #ifdef CONFIG_USB_AUTOSUSPEND
 162 int rtw_enusbss = 1;//0:disable,1:enable
 163 #else
 164 int rtw_enusbss = 0;//0:disable,1:enable
 165 #endif
 166
 167 int rtw_hwpdn_mode=2;//0:disable,1:enable,2: by EFUSE config
 168
 169 #ifdef CONFIG_HW_PWRP_DETECTION
 170 int rtw_hwpwrp_detect = 1;
 171 #else
 172 int rtw_hwpwrp_detect = 0; //HW power  ping detect 0:disable , 1:enable
 173 #endif
 174
 175 #ifdef CONFIG_USB_HCI
 176 int rtw_hw_wps_pbc = 1;
 177 #else
 178 int rtw_hw_wps_pbc = 0;
 179 #endif
 180
 181 #ifdef CONFIG_TX_MCAST2UNI
 182 int rtw_mc2u_disable = 0;
 183 #endif  // CONFIG_TX_MCAST2UNI
 184
 185 #ifdef CONFIG_DUALMAC_CONCURRENT
 186 int rtw_dmsp = 0;
 187 #endif  // CONFIG_DUALMAC_CONCURRENT
 188
 189 #ifdef CONFIG_80211D
 190 int rtw_80211d = 0;
 191 #endif
 192
 193 #ifdef CONFIG_REGULATORY_CTRL
 194 int rtw_regulatory_id =2;
 195 #else
 196 int rtw_regulatory_id = 0xff;// Regulatory tab id, 0xff = follow efuse's setting
 197 #endif
 198 module_param(rtw_regulatory_id, int, 0644);
 199
 200
 201 #ifdef CONFIG_SPECIAL_SETTING_FOR_FUNAI_TV
 202 int rtw_force_ant = 2;//0 :normal, 1:Main ant, 2:Aux ant
 203 int rtw_force_igi =0;//0 :normal
 204 module_param(rtw_force_ant, int, 0644);
 205 module_param(rtw_force_igi, int, 0644);
 206 #endif
 207
 208 #ifdef CONFIG_QOS_OPTIMIZATION
 209 int rtw_qos_opt_enable=1;//0: disable,1:enable
 210 #else
 211 int rtw_qos_opt_enable=0;//0: disable,1:enable
 212 #endif
 213 module_param(rtw_qos_opt_enable,int,0644);
 214
 215 char* ifname = "wlan%d";
 216 module_param(ifname, charp, 0644);
 217 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
 218
 219 char* if2name = "p2p0";
 220 module_param(if2name, charp, 0644);
 221 MODULE_PARM_DESC(if2name, "The default name to allocate for second interface");
 222
 223 char* rtw_initmac = 0;  // temp mac address if users want to use instead of the mac address in Efuse
 224
 225 module_param(rtw_initmac, charp, 0644);
 226 module_param(rtw_channel_plan, int, 0644);
 227 module_param(rtw_chip_version, int, 0644);
 228 module_param(rtw_rfintfs, int, 0644);
 229 module_param(rtw_lbkmode, int, 0644);
 230 module_param(rtw_network_mode, int, 0644);
 231 module_param(rtw_channel, int, 0644);
 232 module_param(rtw_mp_mode, int, 0644);
 233 module_param(rtw_wmm_enable, int, 0644);
 234 module_param(rtw_vrtl_carrier_sense, int, 0644);
 235 module_param(rtw_vcs_type, int, 0644);
 236 module_param(rtw_busy_thresh, int, 0644);
 237 #ifdef CONFIG_80211N_HT
 238 module_param(rtw_ht_enable, int, 0644);
 239 module_param(rtw_cbw40_enable, 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
 244
 245 module_param(rtw_lowrate_two_xmit, int, 0644);
 246
 247 module_param(rtw_rf_config, int, 0644);
 248 module_param(rtw_power_mgnt, int, 0644);
 249 module_param(rtw_smart_ps, int, 0644);
 250 module_param(rtw_low_power, int, 0644);
 251 module_param(rtw_wifi_spec, int, 0644);
 252
 253 module_param(rtw_antdiv_cfg, int, 0644);
 254 module_param(rtw_antdiv_type, int, 0644);
 255
 256 module_param(rtw_enusbss, int, 0644);
 257 module_param(rtw_hwpdn_mode, int, 0644);
 258 module_param(rtw_hwpwrp_detect, int, 0644);
 259
 260 module_param(rtw_hw_wps_pbc, int, 0644);
 261
 262 #ifdef CONFIG_TX_EARLY_MODE
 263 module_param(rtw_early_mode, int, 0644);
 264 #endif
 265 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
 266 char *rtw_adaptor_info_caching_file_path= "/data/misc/wifi/rtw_cache";
 267 module_param(rtw_adaptor_info_caching_file_path, charp, 0644);
 268 MODULE_PARM_DESC(rtw_adaptor_info_caching_file_path, "The path of adapter info cache file");
 269 #endif //CONFIG_ADAPTOR_INFO_CACHING_FILE
 270
 271 #ifdef CONFIG_LAYER2_ROAMING
 272 uint rtw_max_roaming_times=2;
 273 module_param(rtw_max_roaming_times, uint, 0644);
 274 MODULE_PARM_DESC(rtw_max_roaming_times,"The max roaming times to try");
 275 #endif //CONFIG_LAYER2_ROAMING
 276
 277 #ifdef CONFIG_IOL
 278 int rtw_fw_iol=1;// 0:Disable, 1:enable, 2:by usb speed
 279 module_param(rtw_fw_iol, int, 0644);
 280 MODULE_PARM_DESC(rtw_fw_iol,"FW IOL");
 281 #endif //CONFIG_IOL
 282
 283 #ifdef CONFIG_FILE_FWIMG
 284 char *rtw_fw_file_path= "";
 285 module_param(rtw_fw_file_path, charp, 0644);
 286 MODULE_PARM_DESC(rtw_fw_file_path, "The path of fw image");
 287 #endif //CONFIG_FILE_FWIMG
 288
 289 #ifdef CONFIG_TX_MCAST2UNI
 290 module_param(rtw_mc2u_disable, int, 0644);
 291 #endif  // CONFIG_TX_MCAST2UNI
 292
 293 #ifdef CONFIG_DUALMAC_CONCURRENT
 294 module_param(rtw_dmsp, int, 0644);
 295 #endif  // CONFIG_DUALMAC_CONCURRENT
 296
 297 #ifdef CONFIG_80211D
 298 module_param(rtw_80211d, int, 0644);
 299 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
 300 #endif
 301
 302 #ifdef CONFIG_BT_COEXIST
 303 module_param(rtw_btcoex_enable, int, 0644);
 304 MODULE_PARM_DESC(rtw_btcoex_enable, "Enable BT co-existence mechanism");
 305 #endif
 306
 307 uint rtw_notch_filter = RTW_NOTCH_FILTER;
 308 module_param(rtw_notch_filter, uint, 0644);
 309 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
 310
 311 static uint loadparam(PADAPTER padapter, _nic_hdl pnetdev);
 312 int _netdev_open(struct net_device *pnetdev);
 313 int netdev_open (struct net_device *pnetdev);
 314 static int netdev_close (struct net_device *pnetdev);
 315
 316 //#ifdef RTK_DMP_PLATFORM
 317 #ifdef CONFIG_PROC_DEBUG
 318 #define RTL8192C_PROC_NAME "rtl819xC"
 319 #define RTL8192D_PROC_NAME "rtl819xD"
 320 static char rtw_proc_name[IFNAMSIZ];
 321 static struct proc_dir_entry *rtw_proc = NULL;
 322 static int      rtw_proc_cnt = 0;
 323
 324 #define RTW_PROC_NAME DRV_NAME
 325
 326 void rtw_proc_init_one(struct net_device *dev)
 327 {
 328         struct proc_dir_entry *dir_dev = NULL;
 329         struct proc_dir_entry *entry=NULL;
 330         _adapter        *padapter = rtw_netdev_priv(dev);
 331         u8 rf_type;
 332
 333         if(rtw_proc == NULL)
 334         {
 335                 if(padapter->chip_type == RTL8188C_8192C)
 336                 {
 337                         _rtw_memcpy(rtw_proc_name, RTL8192C_PROC_NAME, sizeof(RTL8192C_PROC_NAME));
 338                 }
 339                 else if(padapter->chip_type == RTL8192D)
 340                 {
 341                         _rtw_memcpy(rtw_proc_name, RTL8192D_PROC_NAME, sizeof(RTL8192D_PROC_NAME));
 342                 }
 343                 else if(padapter->chip_type == RTL8723A)
 344                 {
 345                         _rtw_memcpy(rtw_proc_name, RTW_PROC_NAME, sizeof(RTW_PROC_NAME));
 346                 }
 347                 else if(padapter->chip_type == RTL8188E)
 348                 {
 349                         _rtw_memcpy(rtw_proc_name, RTW_PROC_NAME, sizeof(RTW_PROC_NAME));
 350                 }
 351                 else
 352                 {
 353                         _rtw_memcpy(rtw_proc_name, RTW_PROC_NAME, sizeof(RTW_PROC_NAME));
 354                 }
 355
 356 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 357                 rtw_proc=create_proc_entry(rtw_proc_name, S_IFDIR, proc_net);
 358 #else
 359                 rtw_proc=create_proc_entry(rtw_proc_name, S_IFDIR, init_net.proc_net);
 360 #endif
 361                 if (rtw_proc == NULL) {
 362                         DBG_871X(KERN_ERR "Unable to create rtw_proc directory\n");
 363                         return;
 364                 }
 365
 366                 entry = create_proc_read_entry("ver_info", S_IFREG | S_IRUGO, rtw_proc, proc_get_drv_version, dev);
 367                 if (!entry) {
 368                         DBG_871X("Unable to create_proc_read_entry!\n");
 369                         return;
 370                 }
 371
 372 #ifdef DBG_MEM_ALLOC
 373                 entry = create_proc_read_entry("mstat", S_IFREG | S_IRUGO,
 374                                    rtw_proc, proc_get_mstat, dev);
 375                 if (!entry) {
 376                         DBG_871X("Unable to create_proc_read_entry!\n");
 377                         return;
 378                 }
 379 #endif /* DBG_MEM_ALLOC */
 380         }
 381
 382
 383
 384         if(padapter->dir_dev == NULL)
 385         {
 386                 padapter->dir_dev = create_proc_entry(dev->name,
 387                                           S_IFDIR | S_IRUGO | S_IXUGO,
 388                                           rtw_proc);
 389
 390                 dir_dev = padapter->dir_dev;
 391
 392                 if(dir_dev==NULL)
 393                 {
 394                         if(rtw_proc_cnt == 0)
 395                         {
 396                                 if(rtw_proc){
 397 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 398                                         remove_proc_entry(rtw_proc_name, proc_net);
 399 #else
 400                                         remove_proc_entry(rtw_proc_name, init_net.proc_net);
 401 #endif
 402                                         rtw_proc = NULL;
 403                                 }
 404                         }
 405
 406                         DBG_871X("Unable to create dir_dev directory\n");
 407                         return;
 408                 }
 409         }
 410         else
 411         {
 412                 return;
 413         }
 414
 415         rtw_proc_cnt++;
 416
 417         entry = create_proc_read_entry("write_reg", S_IFREG | S_IRUGO,
 418                                    dir_dev, proc_get_write_reg, dev);
 419         if (!entry) {
 420                 DBG_871X("Unable to create_proc_read_entry!\n");
 421                 return;
 422         }
 423         entry->write_proc = proc_set_write_reg;
 424
 425         entry = create_proc_read_entry("read_reg", S_IFREG | S_IRUGO,
 426                                    dir_dev, proc_get_read_reg, dev);
 427         if (!entry) {
 428                 DBG_871X("Unable to create_proc_read_entry!\n");
 429                 return;
 430         }
 431         entry->write_proc = proc_set_read_reg;
 432
 433
 434         entry = create_proc_read_entry("fwstate", S_IFREG | S_IRUGO,
 435                                    dir_dev, proc_get_fwstate, dev);
 436         if (!entry) {
 437                 DBG_871X("Unable to create_proc_read_entry!\n");
 438                 return;
 439         }
 440
 441
 442         entry = create_proc_read_entry("sec_info", S_IFREG | S_IRUGO,
 443                                    dir_dev, proc_get_sec_info, dev);
 444         if (!entry) {
 445                 DBG_871X("Unable to create_proc_read_entry!\n");
 446                 return;
 447         }
 448
 449
 450         entry = create_proc_read_entry("mlmext_state", S_IFREG | S_IRUGO,
 451                                    dir_dev, proc_get_mlmext_state, dev);
 452         if (!entry) {
 453                 DBG_871X("Unable to create_proc_read_entry!\n");
 454                 return;
 455         }
 456
 457
 458         entry = create_proc_read_entry("qos_option", S_IFREG | S_IRUGO,
 459                                    dir_dev, proc_get_qos_option, dev);
 460         if (!entry) {
 461                 DBG_871X("Unable to create_proc_read_entry!\n");
 462                 return;
 463         }
 464
 465         entry = create_proc_read_entry("ht_option", S_IFREG | S_IRUGO,
 466                                    dir_dev, proc_get_ht_option, dev);
 467         if (!entry) {
 468                 DBG_871X("Unable to create_proc_read_entry!\n");
 469                 return;
 470         }
 471
 472         entry = create_proc_read_entry("rf_info", S_IFREG | S_IRUGO,
 473                                    dir_dev, proc_get_rf_info, dev);
 474         if (!entry) {
 475                 DBG_871X("Unable to create_proc_read_entry!\n");
 476                 return;
 477         }
 478
 479         entry = create_proc_read_entry("ap_info", S_IFREG | S_IRUGO,
 480                                    dir_dev, proc_get_ap_info, dev);
 481         if (!entry) {
 482                 DBG_871X("Unable to create_proc_read_entry!\n");
 483                 return;
 484         }
 485
 486         entry = create_proc_read_entry("adapter_state", S_IFREG | S_IRUGO,
 487                                    dir_dev, proc_get_adapter_state, dev);
 488         if (!entry) {
 489                 DBG_871X("Unable to create_proc_read_entry!\n");
 490                 return;
 491         }
 492
 493         entry = create_proc_read_entry("trx_info", S_IFREG | S_IRUGO,
 494                                    dir_dev, proc_get_trx_info, dev);
 495         if (!entry) {
 496                 DBG_871X("Unable to create_proc_read_entry!\n");
 497                 return;
 498         }
 499
 500         entry = create_proc_read_entry("mac_reg_dump1", S_IFREG | S_IRUGO,
 501                                    dir_dev, proc_get_mac_reg_dump1, dev);
 502         if (!entry) {
 503                 DBG_871X("Unable to create_proc_read_entry!\n");
 504                 return;
 505         }
 506
 507         entry = create_proc_read_entry("mac_reg_dump2", S_IFREG | S_IRUGO,
 508                                    dir_dev, proc_get_mac_reg_dump2, dev);
 509         if (!entry) {
 510                 DBG_871X("Unable to create_proc_read_entry!\n");
 511                 return;
 512         }
 513
 514         entry = create_proc_read_entry("mac_reg_dump3", S_IFREG | S_IRUGO,
 515                                    dir_dev, proc_get_mac_reg_dump3, dev);
 516         if (!entry) {
 517                 DBG_871X("Unable to create_proc_read_entry!\n");
 518                 return;
 519         }
 520
 521         entry = create_proc_read_entry("bb_reg_dump1", S_IFREG | S_IRUGO,
 522                                    dir_dev, proc_get_bb_reg_dump1, dev);
 523         if (!entry) {
 524                 DBG_871X("Unable to create_proc_read_entry!\n");
 525                 return;
 526         }
 527
 528         entry = create_proc_read_entry("bb_reg_dump2", S_IFREG | S_IRUGO,
 529                                    dir_dev, proc_get_bb_reg_dump2, dev);
 530         if (!entry) {
 531                 DBG_871X("Unable to create_proc_read_entry!\n");
 532                 return;
 533         }
 534
 535         entry = create_proc_read_entry("bb_reg_dump3", S_IFREG | S_IRUGO,
 536                                    dir_dev, proc_get_bb_reg_dump3, dev);
 537         if (!entry) {
 538                 DBG_871X("Unable to create_proc_read_entry!\n");
 539                 return;
 540         }
 541
 542         entry = create_proc_read_entry("rf_reg_dump1", S_IFREG | S_IRUGO,
 543                                    dir_dev, proc_get_rf_reg_dump1, dev);
 544         if (!entry) {
 545                 DBG_871X("Unable to create_proc_read_entry!\n");
 546                 return;
 547         }
 548
 549         entry = create_proc_read_entry("rf_reg_dump2", S_IFREG | S_IRUGO,
 550                                    dir_dev, proc_get_rf_reg_dump2, dev);
 551         if (!entry) {
 552                 DBG_871X("Unable to create_proc_read_entry!\n");
 553                 return;
 554         }
 555
 556         rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 557         if((RF_1T2R == rf_type) ||(RF_1T1R ==rf_type )) {
 558                 entry = create_proc_read_entry("rf_reg_dump3", S_IFREG | S_IRUGO,
 559                                            dir_dev, proc_get_rf_reg_dump3, dev);
 560                 if (!entry) {
 561                         DBG_871X("Unable to create_proc_read_entry!\n");
 562                         return;
 563                 }
 564
 565                 entry = create_proc_read_entry("rf_reg_dump4", S_IFREG | S_IRUGO,
 566                                            dir_dev, proc_get_rf_reg_dump4, dev);
 567                 if (!entry) {
 568                         DBG_871X("Unable to create_proc_read_entry!\n");
 569                         return;
 570                 }
 571         }
 572
 573 #ifdef CONFIG_AP_MODE
 574
 575         entry = create_proc_read_entry("all_sta_info", S_IFREG | S_IRUGO,
 576                                    dir_dev, proc_get_all_sta_info, dev);
 577         if (!entry) {
 578                 DBG_871X("Unable to create_proc_read_entry!\n");
 579                 return;
 580         }
 581 #endif
 582
 583 #ifdef DBG_MEMORY_LEAK
 584         entry = create_proc_read_entry("_malloc_cnt", S_IFREG | S_IRUGO,
 585                                    dir_dev, proc_get_malloc_cnt, dev);
 586         if (!entry) {
 587                 DBG_871X("Unable to create_proc_read_entry!\n");
 588                 return;
 589         }
 590 #endif
 591
 592 #ifdef CONFIG_FIND_BEST_CHANNEL
 593         entry = create_proc_read_entry("best_channel", S_IFREG | S_IRUGO,
 594                                    dir_dev, proc_get_best_channel, dev);
 595         if (!entry) {
 596                 DBG_871X("Unable to create_proc_read_entry!\n");
 597                 return;
 598         }
 599         entry->write_proc = proc_set_best_channel;
 600 #endif
 601
 602         entry = create_proc_read_entry("rx_signal", S_IFREG | S_IRUGO,
 603                                    dir_dev, proc_get_rx_signal, dev);
 604         if (!entry) {
 605                 DBG_871X("Unable to create_proc_read_entry!\n");
 606                 return;
 607         }
 608         entry->write_proc = proc_set_rx_signal;
 609 #ifdef CONFIG_80211N_HT
 610         entry = create_proc_read_entry("ht_enable", S_IFREG | S_IRUGO,
 611                                    dir_dev, proc_get_ht_enable, dev);
 612         if (!entry) {
 613                 DBG_871X("Unable to create_proc_read_entry!\n");
 614                 return;
 615         }
 616         entry->write_proc = proc_set_ht_enable;
 617
 618         entry = create_proc_read_entry("cbw40_enable", S_IFREG | S_IRUGO,
 619                                    dir_dev, proc_get_cbw40_enable, dev);
 620         if (!entry) {
 621                 DBG_871X("Unable to create_proc_read_entry!\n");
 622                 return;
 623         }
 624         entry->write_proc = proc_set_cbw40_enable;
 625
 626         entry = create_proc_read_entry("ampdu_enable", S_IFREG | S_IRUGO,
 627                                    dir_dev, proc_get_ampdu_enable, dev);
 628         if (!entry) {
 629                 DBG_871X("Unable to create_proc_read_entry!\n");
 630                 return;
 631         }
 632         entry->write_proc = proc_set_ampdu_enable;
 633
 634         entry = create_proc_read_entry("rx_stbc", S_IFREG | S_IRUGO,
 635                                    dir_dev, proc_get_rx_stbc, dev);
 636         if (!entry) {
 637                 DBG_871X("Unable to create_proc_read_entry!\n");
 638                 return;
 639         }
 640         entry->write_proc = proc_set_rx_stbc;
 641 #endif //CONFIG_80211N_HT
 642
 643         entry = create_proc_read_entry("path_rssi", S_IFREG | S_IRUGO,
 644                                         dir_dev, proc_get_two_path_rssi, dev);
 645
 646
 647         entry = create_proc_read_entry("rssi_disp", S_IFREG | S_IRUGO,
 648                                    dir_dev, proc_get_rssi_disp, dev);
 649         if (!entry) {
 650                 DBG_871X("Unable to create_proc_read_entry!\n");
 651                 return;
 652         }
 653         entry->write_proc = proc_set_rssi_disp;
 654 #ifdef CONFIG_BT_COEXIST
 655         entry = create_proc_read_entry("btcoex_dbg", S_IFREG | S_IRUGO,
 656                                    dir_dev, proc_get_btcoex_dbg, dev);
 657         if (!entry) {
 658                 DBG_871X("Unable to create_proc_read_entry!\n");
 659                 return;
 660         }
 661         entry->write_proc = proc_set_btcoex_dbg;
 662 #endif /*CONFIG_BT_COEXIST*/
 663
 664 #if defined(DBG_CONFIG_ERROR_DETECT)
 665         entry = create_proc_read_entry("sreset", S_IFREG | S_IRUGO,
 666                                    dir_dev, proc_get_sreset, dev);
 667         if (!entry) {
 668                 DBG_871X("Unable to create_proc_read_entry!\n");
 669                 return;
 670         }
 671         entry->write_proc = proc_set_sreset;
 672 #endif /* DBG_CONFIG_ERROR_DETECT */
 673
 674         /* for odm */
 675         {
 676                 struct proc_dir_entry *dir_odm = NULL;
 677
 678                 if (padapter->dir_odm == NULL) {
 679                         padapter->dir_odm = create_proc_entry(
 680                                 "odm", S_IFDIR | S_IRUGO | S_IXUGO, dir_dev);
 681
 682                         dir_odm = padapter->dir_odm;
 683
 684                         if(dir_odm==NULL) {
 685                                 DBG_871X("Unable to create dir_odm directory\n");
 686                                 return;
 687                         }
 688                 }
 689                 else
 690                 {
 691                         return;
 692                 }
 693
 694                 entry = create_proc_read_entry("dbg_comp", S_IFREG | S_IRUGO,
 695                                            dir_odm, proc_get_odm_dbg_comp, dev);
 696                 if (!entry) {
 697                         rtw_warn_on(1);
 698                         return;
 699                 }
 700                 entry->write_proc = proc_set_odm_dbg_comp;
 701
 702                 entry = create_proc_read_entry("dbg_level", S_IFREG | S_IRUGO,
 703                                            dir_odm, proc_get_odm_dbg_level, dev);
 704                 if (!entry) {
 705                         rtw_warn_on(1);
 706                         return;
 707                 }
 708                 entry->write_proc = proc_set_odm_dbg_level;
 709
 710                 entry = create_proc_read_entry("adaptivity", S_IFREG | S_IRUGO,
 711                                            dir_odm, proc_get_odm_adaptivity, dev);
 712                 if (!entry) {
 713                         rtw_warn_on(1);
 714                         return;
 715                 }
 716                 entry->write_proc = proc_set_odm_adaptivity;
 717         }
 718 }
 719
 720 void rtw_proc_remove_one(struct net_device *dev)
 721 {
 722         struct proc_dir_entry *dir_dev = NULL;
 723         _adapter        *padapter = rtw_netdev_priv(dev);
 724         u8 rf_type;
 725
 726         dir_dev = padapter->dir_dev;
 727         padapter->dir_dev = NULL;
 728
 729         if (dir_dev) {
 730
 731                 remove_proc_entry("write_reg", dir_dev);
 732                 remove_proc_entry("read_reg", dir_dev);
 733                 remove_proc_entry("fwstate", dir_dev);
 734                 remove_proc_entry("sec_info", dir_dev);
 735                 remove_proc_entry("mlmext_state", dir_dev);
 736                 remove_proc_entry("qos_option", dir_dev);
 737                 remove_proc_entry("ht_option", dir_dev);
 738                 remove_proc_entry("rf_info", dir_dev);
 739                 remove_proc_entry("ap_info", dir_dev);
 740                 remove_proc_entry("adapter_state", dir_dev);
 741                 remove_proc_entry("trx_info", dir_dev);
 742
 743                 remove_proc_entry("mac_reg_dump1", dir_dev);
 744                 remove_proc_entry("mac_reg_dump2", dir_dev);
 745                 remove_proc_entry("mac_reg_dump3", dir_dev);
 746                 remove_proc_entry("bb_reg_dump1", dir_dev);
 747                 remove_proc_entry("bb_reg_dump2", dir_dev);
 748                 remove_proc_entry("bb_reg_dump3", dir_dev);
 749                 remove_proc_entry("rf_reg_dump1", dir_dev);
 750                 remove_proc_entry("rf_reg_dump2", dir_dev);
 751                 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
 752                 if((RF_1T2R == rf_type) ||(RF_1T1R ==rf_type )) {
 753                         remove_proc_entry("rf_reg_dump3", dir_dev);
 754                         remove_proc_entry("rf_reg_dump4", dir_dev);
 755                 }
 756 #ifdef CONFIG_AP_MODE
 757                 remove_proc_entry("all_sta_info", dir_dev);
 758 #endif
 759
 760 #ifdef DBG_MEMORY_LEAK
 761                 remove_proc_entry("_malloc_cnt", dir_dev);
 762 #endif
 763
 764 #ifdef CONFIG_FIND_BEST_CHANNEL
 765                 remove_proc_entry("best_channel", dir_dev);
 766 #endif
 767                 remove_proc_entry("rx_signal", dir_dev);
 768 #ifdef CONFIG_80211N_HT
 769                 remove_proc_entry("cbw40_enable", dir_dev);
 770
 771                 remove_proc_entry("ht_enable", dir_dev);
 772
 773                 remove_proc_entry("ampdu_enable", dir_dev);
 774
 775                 remove_proc_entry("rx_stbc", dir_dev);
 776 #endif //CONFIG_80211N_HT
 777                 remove_proc_entry("path_rssi", dir_dev);
 778
 779                 remove_proc_entry("rssi_disp", dir_dev);
 780
 781 #ifdef CONFIG_BT_COEXIST
 782                 remove_proc_entry("btcoex_dbg", dir_dev);
 783 #endif //CONFIG_BT_COEXIST
 784
 785 #if defined(DBG_CONFIG_ERROR_DETECT)
 786         remove_proc_entry("sreset", dir_dev);
 787 #endif /* DBG_CONFIG_ERROR_DETECT */
 788
 789                 /* for odm */
 790                 {
 791                         struct proc_dir_entry *dir_odm = NULL;
 792                         dir_odm = padapter->dir_odm;
 793                         padapter->dir_odm = NULL;
 794
 795                         if (dir_odm) {
 796                                 remove_proc_entry("dbg_comp", dir_odm);
 797                                 remove_proc_entry("dbg_level", dir_odm);
 798                                 remove_proc_entry("adaptivity", dir_odm);
 799
 800                                 remove_proc_entry("odm", dir_dev);
 801                         }
 802                 }
 803
 804                 remove_proc_entry(dev->name, rtw_proc);
 805                 dir_dev = NULL;
 806
 807         }
 808         else
 809         {
 810                 return;
 811         }
 812
 813         rtw_proc_cnt--;
 814
 815         if(rtw_proc_cnt == 0)
 816         {
 817                 if(rtw_proc){
 818                         remove_proc_entry("ver_info", rtw_proc);
 819                         #ifdef DBG_MEM_ALLOC
 820                         remove_proc_entry("mstat", rtw_proc);
 821                         #endif /* DBG_MEM_ALLOC */
 822 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
 823                         remove_proc_entry(rtw_proc_name, proc_net);
 824 #else
 825                         remove_proc_entry(rtw_proc_name, init_net.proc_net);
 826 #endif
 827                         rtw_proc = NULL;
 828                 }
 829         }
 830 }
 831 #endif
 832
 833 uint loadparam( _adapter *padapter,  _nic_hdl   pnetdev);
 834 uint loadparam( _adapter *padapter,  _nic_hdl   pnetdev)
 835 {
 836
 837         uint status = _SUCCESS;
 838         struct registry_priv  *registry_par = &padapter->registrypriv;
 839
 840 _func_enter_;
 841
 842         registry_par->chip_version = (u8)rtw_chip_version;
 843         registry_par->rfintfs = (u8)rtw_rfintfs;
 844         registry_par->lbkmode = (u8)rtw_lbkmode;
 845         //registry_par->hci = (u8)hci;
 846         registry_par->network_mode  = (u8)rtw_network_mode;
 847
 848         _rtw_memcpy(registry_par->ssid.Ssid, "ANY", 3);
 849         registry_par->ssid.SsidLength = 3;
 850
 851         registry_par->channel = (u8)rtw_channel;
 852         registry_par->wireless_mode = (u8)rtw_wireless_mode;
 853         registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense ;
 854         registry_par->vcs_type = (u8)rtw_vcs_type;
 855         registry_par->rts_thresh=(u16)rtw_rts_thresh;
 856         registry_par->frag_thresh=(u16)rtw_frag_thresh;
 857         registry_par->preamble = (u8)rtw_preamble;
 858         registry_par->scan_mode = (u8)rtw_scan_mode;
 859         registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
 860         registry_par->soft_ap=  (u8)rtw_soft_ap;
 861         registry_par->smart_ps =  (u8)rtw_smart_ps;
 862         registry_par->power_mgnt = (u8)rtw_power_mgnt;
 863         registry_par->ips_mode = (u8)rtw_ips_mode;
 864         registry_par->radio_enable = (u8)rtw_radio_enable;
 865         registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
 866         registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
 867         registry_par->busy_thresh = (u16)rtw_busy_thresh;
 868         //registry_par->qos_enable = (u8)rtw_qos_enable;
 869         registry_par->ack_policy = (u8)rtw_ack_policy;
 870         registry_par->mp_mode = (u8)rtw_mp_mode;
 871         registry_par->software_encrypt = (u8)rtw_software_encrypt;
 872         registry_par->software_decrypt = (u8)rtw_software_decrypt;
 873
 874         registry_par->acm_method = (u8)rtw_acm_method;
 875
 876          //UAPSD
 877         registry_par->wmm_enable = (u8)rtw_wmm_enable;
 878         registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
 879         registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
 880         registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
 881         registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
 882         registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
 883         registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
 884
 885 #ifdef CONFIG_80211N_HT
 886         registry_par->ht_enable = (u8)rtw_ht_enable;
 887         registry_par->cbw40_enable = (u8)rtw_cbw40_enable;
 888         registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
 889         registry_par->rx_stbc = (u8)rtw_rx_stbc;
 890         registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
 891 #endif
 892 #ifdef CONFIG_TX_EARLY_MODE
 893         registry_par->early_mode = (u8)rtw_early_mode;
 894 #endif
 895         registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
 896         registry_par->rf_config = (u8)rtw_rf_config;
 897         registry_par->low_power = (u8)rtw_low_power;
 898
 899
 900         registry_par->wifi_spec = (u8)rtw_wifi_spec;
 901
 902         registry_par->channel_plan = (u8)rtw_channel_plan;
 903
 904 #ifdef CONFIG_BT_COEXIST
 905         registry_par->btcoex = (u8)rtw_btcoex_enable;
 906         registry_par->bt_iso = (u8)rtw_bt_iso;
 907         registry_par->bt_sco = (u8)rtw_bt_sco;
 908         registry_par->bt_ampdu = (u8)rtw_bt_ampdu;
 909 #endif
 910
 911         registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq;
 912
 913         registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
 914         registry_par->antdiv_type = (u8)rtw_antdiv_type;
 915
 916 #ifdef CONFIG_AUTOSUSPEND
 917         registry_par->usbss_enable = (u8)rtw_enusbss;//0:disable,1:enable
 918 #endif
 919 #ifdef SUPPORT_HW_RFOFF_DETECTED
 920         registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;//0:disable,1:enable,2:by EFUSE config
 921         registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;//0:disable,1:enable
 922 #endif
 923
 924         registry_par->qos_opt_enable = (u8)rtw_qos_opt_enable;
 925         registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
 926
 927 #ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
 928         snprintf(registry_par->adaptor_info_caching_file_path, PATH_LENGTH_MAX, "%s", rtw_adaptor_info_caching_file_path);
 929         registry_par->adaptor_info_caching_file_path[PATH_LENGTH_MAX-1]=0;
 930 #endif
 931
 932 #ifdef CONFIG_LAYER2_ROAMING
 933         registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
 934 #ifdef CONFIG_INTEL_WIDI
 935         registry_par->max_roaming_times = (u8)rtw_max_roaming_times + 2;
 936 #endif // CONFIG_INTEL_WIDI
 937 #endif
 938
 939 #ifdef CONFIG_IOL
 940         registry_par->fw_iol = rtw_fw_iol;
 941 #endif
 942
 943 #ifdef CONFIG_DUALMAC_CONCURRENT
 944         registry_par->dmsp= (u8)rtw_dmsp;
 945 #endif
 946
 947 #ifdef CONFIG_80211D
 948         registry_par->enable80211d = (u8)rtw_80211d;
 949 #endif
 950
 951         snprintf(registry_par->ifname, 16, "%s", ifname);
 952         snprintf(registry_par->if2name, 16, "%s", if2name);
 953
 954         registry_par->notch_filter = (u8)rtw_notch_filter;
 955
 956 #ifdef CONFIG_SPECIAL_SETTING_FOR_FUNAI_TV
 957         registry_par->force_ant = (u8)rtw_force_ant;
 958         registry_par->force_igi = (u8)rtw_force_igi;
 959 #endif
 960         registry_par->regulatory_tid = (u8)rtw_regulatory_id;
 961
 962
 963 _func_exit_;
 964
 965         return status;
 966 }
 967
 968 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
 969 {
 970         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
 971         struct sockaddr *addr = p;
 972
 973         if(padapter->bup == _FALSE)
 974         {
 975                 //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],
 976                 //addr->sa_data[4], addr->sa_data[5]);
 977                 _rtw_memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
 978                 //_rtw_memcpy(pnetdev->dev_addr, addr->sa_data, ETH_ALEN);
 979                 //padapter->bset_hwaddr = _TRUE;
 980         }
 981
 982         return 0;
 983 }
 984
 985 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
 986 {
 987         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
 988         struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
 989         struct recv_priv *precvpriv = &(padapter->recvpriv);
 990
 991         padapter->stats.tx_packets = pxmitpriv->tx_pkts;//pxmitpriv->tx_pkts++;
 992         padapter->stats.rx_packets = precvpriv->rx_pkts;//precvpriv->rx_pkts++;
 993         padapter->stats.tx_dropped = pxmitpriv->tx_drop;
 994         padapter->stats.rx_dropped = precvpriv->rx_drop;
 995         padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
 996         padapter->stats.rx_bytes = precvpriv->rx_bytes;
 997
 998         return &padapter->stats;
 999 }
1000
1001 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1002 /*
1003  * AC to queue mapping
1004  *
1005  * AC_VO -> queue 0
1006  * AC_VI -> queue 1
1007  * AC_BE -> queue 2
1008  * AC_BK -> queue 3
1009  */
1010 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
1011
1012 /* Given a data frame determine the 802.1p/1d tag to use. */
1013 unsigned int rtw_classify8021d(struct sk_buff *skb)
1014 {
1015         unsigned int dscp;
1016
1017         /* skb->priority values from 256->263 are magic values to
1018          * directly indicate a specific 802.1d priority.  This is used
1019          * to allow 802.1d priority to be passed directly in from VLAN
1020          * tags, etc.
1021          */
1022         if (skb->priority >= 256 && skb->priority <= 263)
1023                 return skb->priority - 256;
1024
1025         switch (skb->protocol) {
1026         case htons(ETH_P_IP):
1027                 dscp = ip_hdr(skb)->tos & 0xfc;
1028                 break;
1029         default:
1030                 return 0;
1031         }
1032
1033         return dscp >> 5;
1034 }
1035
1036 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb)
1037 {
1038         _adapter        *padapter = rtw_netdev_priv(dev);
1039         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1040
1041         skb->priority = rtw_classify8021d(skb);
1042
1043         if(pmlmepriv->acm_mask != 0)
1044         {
1045                 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
1046         }
1047
1048         return rtw_1d_to_queue[skb->priority];
1049 }
1050
1051 u16 rtw_recv_select_queue(struct sk_buff *skb)
1052 {
1053         struct iphdr *piphdr;
1054         unsigned int dscp;
1055         u16     eth_type;
1056         u32 priority;
1057         u8 *pdata = skb->data;
1058
1059         _rtw_memcpy(&eth_type, pdata+(ETH_ALEN<<1), 2);
1060
1061         switch (eth_type) {
1062                 case htons(ETH_P_IP):
1063
1064                         piphdr = (struct iphdr *)(pdata+ETH_HLEN);
1065
1066                         dscp = piphdr->tos & 0xfc;
1067
1068                         priority = dscp >> 5;
1069
1070                         break;
1071                 default:
1072                         priority = 0;
1073         }
1074
1075         return rtw_1d_to_queue[priority];
1076
1077 }
1078
1079 #endif
1080
1081 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1082 static const struct net_device_ops rtw_netdev_ops = {
1083         .ndo_open = netdev_open,
1084         .ndo_stop = netdev_close,
1085         .ndo_start_xmit = rtw_xmit_entry,
1086 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1087         .ndo_select_queue       = rtw_select_queue,
1088 #endif
1089         .ndo_set_mac_address = rtw_net_set_mac_address,
1090         .ndo_get_stats = rtw_net_get_stats,
1091         .ndo_do_ioctl = rtw_ioctl,
1092 };
1093 #endif
1094
1095 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
1096 {
1097         _adapter *padapter = rtw_netdev_priv(pnetdev);
1098
1099 #ifdef CONFIG_EASY_REPLACEMENT
1100         struct net_device       *TargetNetdev = NULL;
1101         _adapter                        *TargetAdapter = NULL;
1102         struct net              *devnet = NULL;
1103
1104         if(padapter->bDongle == 1)
1105         {
1106 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1107                 TargetNetdev = dev_get_by_name("wlan0");
1108 #else
1109         #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
1110                 devnet = pnetdev->nd_net;
1111         #else
1112                 devnet = dev_net(pnetdev);
1113         #endif
1114                 TargetNetdev = dev_get_by_name(devnet, "wlan0");
1115 #endif
1116                 if(TargetNetdev) {
1117                         DBG_871X("Force onboard module driver disappear !!!\n");
1118                         TargetAdapter = rtw_netdev_priv(TargetNetdev);
1119                         TargetAdapter->DriverState = DRIVER_DISAPPEAR;
1120
1121                         padapter->pid[0] = TargetAdapter->pid[0];
1122                         padapter->pid[1] = TargetAdapter->pid[1];
1123                         padapter->pid[2] = TargetAdapter->pid[2];
1124
1125                         dev_put(TargetNetdev);
1126                         unregister_netdev(TargetNetdev);
1127
1128                         if(TargetAdapter->chip_type == padapter->chip_type)
1129                                 rtw_proc_remove_one(TargetNetdev);
1130
1131                         padapter->DriverState = DRIVER_REPLACE_DONGLE;
1132                 }
1133         }
1134 #endif
1135
1136         if(dev_alloc_name(pnetdev, ifname) < 0)
1137         {
1138                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("dev_alloc_name, fail! \n"));
1139         }
1140
1141         netif_carrier_off(pnetdev);
1142         //rtw_netif_stop_queue(pnetdev);
1143
1144         return 0;
1145 }
1146
1147 struct net_device *rtw_init_netdev(_adapter *old_padapter)
1148 {
1149         _adapter *padapter;
1150         struct net_device *pnetdev;
1151
1152         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+init_net_dev\n"));
1153
1154         if(old_padapter != NULL)
1155                 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(_adapter), (void *)old_padapter);
1156         else
1157                 pnetdev = rtw_alloc_etherdev(sizeof(_adapter));
1158
1159         if (!pnetdev)
1160                 return NULL;
1161
1162         padapter = rtw_netdev_priv(pnetdev);
1163         padapter->pnetdev = pnetdev;
1164
1165 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1166         SET_MODULE_OWNER(pnetdev);
1167 #endif
1168
1169         //pnetdev->init = NULL;
1170
1171 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1172         DBG_871X("register rtw_netdev_ops to netdev_ops\n");
1173         pnetdev->netdev_ops = &rtw_netdev_ops;
1174 #else
1175         pnetdev->open = netdev_open;
1176         pnetdev->stop = netdev_close;
1177         pnetdev->hard_start_xmit = rtw_xmit_entry;
1178         pnetdev->set_mac_address = rtw_net_set_mac_address;
1179         pnetdev->get_stats = rtw_net_get_stats;
1180         pnetdev->do_ioctl = rtw_ioctl;
1181 #endif
1182
1183
1184 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
1185         pnetdev->features |= NETIF_F_IP_CSUM;
1186 #endif
1187         //pnetdev->tx_timeout = NULL;
1188         pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */
1189 #ifdef CONFIG_WIRELESS_EXT
1190         pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
1191 #endif
1192
1193 #ifdef WIRELESS_SPY
1194         //priv->wireless_data.spy_data = &priv->spy_data;
1195         //pnetdev->wireless_data = &priv->wireless_data;
1196 #endif
1197
1198         //step 2.
1199         loadparam(padapter, pnetdev);
1200
1201         return pnetdev;
1202
1203 }
1204
1205 u32 rtw_start_drv_threads(_adapter *padapter)
1206 {
1207         u32 _status = _SUCCESS;
1208
1209         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_start_drv_threads\n"));
1210 #ifdef CONFIG_XMIT_THREAD_MODE
1211 #if defined(CONFIG_SDIO_HCI) && defined(CONFIG_CONCURRENT_MODE)
1212         if(padapter->adapter_type == PRIMARY_ADAPTER){
1213 #endif
1214         padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
1215         if(IS_ERR(padapter->xmitThread))
1216                 _status = _FAIL;
1217 #if defined(CONFIG_SDIO_HCI) && defined(CONFIG_CONCURRENT_MODE)
1218         }
1219 #endif          // CONFIG_SDIO_HCI+CONFIG_CONCURRENT_MODE
1220 #endif
1221
1222 #ifdef CONFIG_RECV_THREAD_MODE
1223         padapter->recvThread = kthread_run(rtw_recv_thread, padapter, "RTW_RECV_THREAD");
1224         if(IS_ERR(padapter->recvThread))
1225                 _status = _FAIL;
1226 #endif
1227
1228
1229 #ifdef CONFIG_CONCURRENT_MODE
1230         if(padapter->isprimary == _TRUE)
1231 #endif //CONFIG_CONCURRENT_MODE
1232         {
1233                 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
1234                 if(IS_ERR(padapter->cmdThread))
1235                         _status = _FAIL;
1236                 else
1237                         _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); //wait for cmd_thread to run
1238         }
1239
1240
1241 #ifdef CONFIG_EVENT_THREAD_MODE
1242         padapter->evtThread = kthread_run(event_thread, padapter, "RTW_EVENT_THREAD");
1243         if(IS_ERR(padapter->evtThread))
1244                 _status = _FAIL;
1245 #endif
1246
1247         rtw_hal_start_thread(padapter);
1248         return _status;
1249
1250 }
1251
1252 void rtw_unregister_netdevs(struct dvobj_priv *dvobj)
1253 {
1254         int i;
1255         _adapter *padapter = NULL;
1256
1257         for(i=0;i<dvobj->iface_nums;i++)
1258         {
1259                 struct net_device *pnetdev = NULL;
1260
1261                 padapter = dvobj->padapters[i];
1262
1263                 if (padapter == NULL)
1264                         continue;
1265
1266                 pnetdev = padapter->pnetdev;
1267
1268                 if((padapter->DriverState != DRIVER_DISAPPEAR) && pnetdev) {
1269
1270                         unregister_netdev(pnetdev); //will call netdev_close()
1271                         rtw_proc_remove_one(pnetdev);
1272                 }
1273
1274 #ifdef CONFIG_IOCTL_CFG80211
1275                 rtw_wdev_unregister(padapter->rtw_wdev);
1276 #endif
1277
1278         }
1279
1280 }
1281
1282
1283 void rtw_stop_drv_threads (_adapter *padapter)
1284 {
1285         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_stop_drv_threads\n"));
1286
1287 #ifdef CONFIG_CONCURRENT_MODE
1288         if(padapter->isprimary == _TRUE)
1289 #endif //CONFIG_CONCURRENT_MODE
1290         {
1291                 rtw_stop_cmd_thread(padapter);
1292         }
1293
1294 #ifdef CONFIG_EVENT_THREAD_MODE
1295         _rtw_up_sema(&padapter->evtpriv.evt_notify);
1296         if(padapter->evtThread){
1297                 _rtw_down_sema(&padapter->evtpriv.terminate_evtthread_sema);
1298         }
1299 #endif
1300
1301 #ifdef CONFIG_XMIT_THREAD_MODE
1302         // Below is to termindate tx_thread...
1303 #if defined(CONFIG_SDIO_HCI) && defined(CONFIG_CONCURRENT_MODE)
1304         // Only wake-up primary adapter
1305         if(padapter->adapter_type == PRIMARY_ADAPTER)
1306 #endif  //SDIO_HCI + CONCURRENT
1307         {
1308         _rtw_up_sema(&padapter->xmitpriv.xmit_sema);
1309         _rtw_down_sema(&padapter->xmitpriv.terminate_xmitthread_sema);
1310         }
1311         RT_TRACE(_module_os_intfs_c_,_drv_info_,("\n drv_halt: rtw_xmit_thread can be terminated ! \n"));
1312 #endif
1313
1314 #ifdef CONFIG_RECV_THREAD_MODE
1315         // Below is to termindate rx_thread...
1316         _rtw_up_sema(&padapter->recvpriv.recv_sema);
1317         _rtw_down_sema(&padapter->recvpriv.terminate_recvthread_sema);
1318         RT_TRACE(_module_os_intfs_c_,_drv_info_,("\n drv_halt:recv_thread can be terminated! \n"));
1319 #endif
1320
1321         rtw_hal_stop_thread(padapter);
1322 }
1323
1324 u8 rtw_init_default_value(_adapter *padapter);
1325 u8 rtw_init_default_value(_adapter *padapter)
1326 {
1327         u8 ret  = _SUCCESS;
1328         struct registry_priv* pregistrypriv = &padapter->registrypriv;
1329         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
1330         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1331         struct security_priv *psecuritypriv = &padapter->securitypriv;
1332
1333         //xmit_priv
1334         pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
1335         pxmitpriv->vcs = pregistrypriv->vcs_type;
1336         pxmitpriv->vcs_type = pregistrypriv->vcs_type;
1337         //pxmitpriv->rts_thresh = pregistrypriv->rts_thresh;
1338         pxmitpriv->frag_len = pregistrypriv->frag_thresh;
1339
1340
1341
1342         //recv_priv
1343
1344
1345         //mlme_priv
1346         pmlmepriv->scan_interval = SCAN_INTERVAL;// 30*2 sec = 60sec
1347         pmlmepriv->scan_mode = SCAN_ACTIVE;
1348
1349         //qos_priv
1350         //pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable;
1351
1352         //ht_priv
1353 #ifdef CONFIG_80211N_HT
1354         pmlmepriv->htpriv.ampdu_enable = _FALSE;//set to disabled
1355 #endif
1356
1357         //security_priv
1358         //rtw_get_encrypt_decrypt_from_registrypriv(padapter);
1359         psecuritypriv->binstallGrpkey = _FAIL;
1360         psecuritypriv->sw_encrypt=pregistrypriv->software_encrypt;
1361         psecuritypriv->sw_decrypt=pregistrypriv->software_decrypt;
1362
1363         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; //open system
1364         psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
1365
1366         psecuritypriv->dot11PrivacyKeyIndex = 0;
1367
1368         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
1369         psecuritypriv->dot118021XGrpKeyid = 1;
1370
1371         psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
1372         psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
1373
1374
1375         //pwrctrl_priv
1376
1377
1378         //registry_priv
1379         rtw_init_registrypriv_dev_network(padapter);
1380         rtw_update_registrypriv_dev_network(padapter);
1381
1382
1383         //hal_priv
1384         rtw_hal_def_value_init(padapter);
1385
1386         //misc.
1387         padapter->bReadPortCancel = _FALSE;
1388         padapter->bWritePortCancel = _FALSE;
1389         padapter->bRxRSSIDisplay = 0;
1390         padapter->bNotifyChannelChange = 0;
1391 #ifdef CONFIG_P2P
1392         padapter->bShowGetP2PState = 1;
1393 #endif
1394
1395         return ret;
1396 }
1397
1398 u8 rtw_reset_drv_sw(_adapter *padapter)
1399 {
1400         u8      ret8=_SUCCESS;
1401         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1402         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1403
1404         //hal_priv
1405         rtw_hal_def_value_init(padapter);
1406         padapter->bReadPortCancel = _FALSE;
1407         padapter->bWritePortCancel = _FALSE;
1408         padapter->bRxRSSIDisplay = 0;
1409         pmlmepriv->scan_interval = SCAN_INTERVAL;// 30*2 sec = 60sec
1410
1411         padapter->xmitpriv.tx_pkts = 0;
1412         padapter->recvpriv.rx_pkts = 0;
1413
1414         pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
1415
1416         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY |_FW_UNDER_LINKING);
1417
1418 #ifdef CONFIG_AUTOSUSPEND
1419         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,22) && LINUX_VERSION_CODE<=KERNEL_VERSION(2,6,34))
1420                 adapter_to_dvobj(padapter)->pusbdev->autosuspend_disabled = 1;//autosuspend disabled by the user
1421         #endif
1422 #endif
1423
1424 #ifdef DBG_CONFIG_ERROR_DETECT
1425         rtw_hal_sreset_reset_value(padapter);
1426 #endif
1427         pwrctrlpriv->pwr_state_check_cnts = 0;
1428
1429         //mlmeextpriv
1430         padapter->mlmeextpriv.sitesurvey_res.state= SCAN_DISABLE;
1431
1432 #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
1433         rtw_set_signal_stat_timer(&padapter->recvpriv);
1434 #endif
1435
1436         return ret8;
1437 }
1438
1439
1440 u8 rtw_init_drv_sw(_adapter *padapter)
1441 {
1442
1443         u8      ret8=_SUCCESS;
1444
1445 _func_enter_;
1446
1447         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_init_drv_sw\n"));
1448
1449         if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL)
1450         {
1451                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init cmd_priv\n"));
1452                 ret8=_FAIL;
1453                 goto exit;
1454         }
1455
1456         padapter->cmdpriv.padapter=padapter;
1457
1458         if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL)
1459         {
1460                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init evt_priv\n"));
1461                 ret8=_FAIL;
1462                 goto exit;
1463         }
1464
1465
1466         if (rtw_init_mlme_priv(padapter) == _FAIL)
1467         {
1468                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init mlme_priv\n"));
1469                 ret8=_FAIL;
1470                 goto exit;
1471         }
1472
1473 #ifdef CONFIG_P2P
1474         rtw_init_wifidirect_timers(padapter);
1475         init_wifidirect_info(padapter, P2P_ROLE_DISABLE);
1476         reset_global_wifidirect_info(padapter);
1477         #ifdef CONFIG_IOCTL_CFG80211
1478         rtw_init_cfg80211_wifidirect_info(padapter);
1479         #endif
1480 #ifdef CONFIG_WFD
1481         if(rtw_init_wifi_display_info(padapter) == _FAIL)
1482                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init init_wifi_display_info\n"));
1483 #endif
1484 #endif /* CONFIG_P2P */
1485
1486         if(init_mlme_ext_priv(padapter) == _FAIL)
1487         {
1488                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init mlme_ext_priv\n"));
1489                 ret8=_FAIL;
1490                 goto exit;
1491         }
1492
1493 #ifdef CONFIG_TDLS
1494         if(rtw_init_tdls_info(padapter) == _FAIL)
1495         {
1496                 DBG_871X("Can't rtw_init_tdls_info\n");
1497                 ret8=_FAIL;
1498                 goto exit;
1499         }
1500 #endif //CONFIG_TDLS
1501
1502         if(_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL)
1503         {
1504                 DBG_871X("Can't _rtw_init_xmit_priv\n");
1505                 ret8=_FAIL;
1506                 goto exit;
1507         }
1508
1509         if(_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL)
1510         {
1511                 DBG_871X("Can't _rtw_init_recv_priv\n");
1512                 ret8=_FAIL;
1513                 goto exit;
1514         }
1515         // add for CONFIG_IEEE80211W, none 11w also can use
1516         _rtw_spinlock_init(&padapter->security_key_mutex);
1517
1518         // We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc().
1519         //_rtw_memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv));
1520
1521         //_init_timer(&(padapter->securitypriv.tkip_timer), padapter->pifp, rtw_use_tkipkey_handler, padapter);
1522
1523         if(_rtw_init_sta_priv(&padapter->stapriv) == _FAIL)
1524         {
1525                 DBG_871X("Can't _rtw_init_sta_priv\n");
1526                 ret8=_FAIL;
1527                 goto exit;
1528         }
1529
1530         padapter->stapriv.padapter = padapter;
1531         padapter->setband = GHZ24_50;
1532         padapter->fix_rate = 0xFF;
1533         rtw_init_bcmc_stainfo(padapter);
1534
1535         rtw_init_pwrctrl_priv(padapter);
1536
1537         //_rtw_memset((u8 *)&padapter->qospriv, 0, sizeof (struct qos_priv));//move to mlme_priv
1538
1539 #ifdef CONFIG_MP_INCLUDED
1540         if (init_mp_priv(padapter) == _FAIL) {
1541                 DBG_871X("%s: initialize MP private data Fail!\n", __func__);
1542         }
1543 #endif
1544
1545         ret8 = rtw_init_default_value(padapter);
1546
1547         rtw_hal_dm_init(padapter);
1548         rtw_hal_sw_led_init(padapter);
1549
1550 #ifdef DBG_CONFIG_ERROR_DETECT
1551         rtw_hal_sreset_init(padapter);
1552 #endif
1553
1554 #ifdef CONFIG_INTEL_WIDI
1555         if(rtw_init_intel_widi(padapter) == _FAIL)
1556         {
1557                 DBG_871X("Can't rtw_init_intel_widi\n");
1558                 ret8=_FAIL;
1559                 goto exit;
1560         }
1561 #endif //CONFIG_INTEL_WIDI
1562
1563 #ifdef CONFIG_WAPI_SUPPORT
1564         padapter->WapiSupport = true; //set true temp, will revise according to Efuse or Registry value later.
1565         rtw_wapi_init(padapter);
1566 #endif
1567
1568 #ifdef CONFIG_BR_EXT
1569         _rtw_spinlock_init(&padapter->br_ext_lock);
1570 #endif  // CONFIG_BR_EXT
1571
1572 exit:
1573
1574         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-rtw_init_drv_sw\n"));
1575
1576         _func_exit_;
1577
1578         return ret8;
1579
1580 }
1581
1582 #ifdef CONFIG_WOWLAN
1583 void rtw_cancel_dynamic_chk_timer(_adapter *padapter)
1584 {
1585         _cancel_timer_ex(&padapter->mlmepriv.dynamic_chk_timer);
1586         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel dynamic_chk_timer! \n"));
1587 }
1588 #endif
1589
1590 void rtw_cancel_all_timer(_adapter *padapter)
1591 {
1592         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_cancel_all_timer\n"));
1593
1594         _cancel_timer_ex(&padapter->mlmepriv.assoc_timer);
1595         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel association timer complete! \n"));
1596
1597         //_cancel_timer_ex(&padapter->securitypriv.tkip_timer);
1598         //RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel tkip_timer! \n"));
1599
1600         _cancel_timer_ex(&padapter->mlmepriv.scan_to_timer);
1601         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel scan_to_timer! \n"));
1602
1603         _cancel_timer_ex(&padapter->mlmepriv.dynamic_chk_timer);
1604         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel dynamic_chk_timer! \n"));
1605
1606         // cancel sw led timer
1607         rtw_hal_sw_led_deinit(padapter);
1608         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel DeInitSwLeds! \n"));
1609
1610         _cancel_timer_ex(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
1611
1612 #ifdef CONFIG_IOCTL_CFG80211
1613 #ifdef CONFIG_P2P
1614         _cancel_timer_ex(&padapter->cfg80211_wdinfo.remain_on_ch_timer);
1615 #endif //CONFIG_P2P
1616 #endif //CONFIG_IOCTL_CFG80211
1617
1618 #ifdef CONFIG_SET_SCAN_DENY_TIMER
1619         _cancel_timer_ex(&padapter->mlmepriv.set_scan_deny_timer);
1620         rtw_clear_scan_deny(padapter);
1621         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel set_scan_deny_timer! \n"));
1622 #endif
1623
1624 #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
1625         _cancel_timer_ex(&padapter->recvpriv.signal_stat_timer);
1626 #endif
1627
1628 #ifdef CONFIG_DETECT_C2H_BY_POLLING
1629         _cancel_timer_ex(&padapter->mlmepriv.event_polling_timer);
1630 #endif
1631
1632 #if defined(CONFIG_CHECK_BT_HANG) && defined(CONFIG_BT_COEXIST)
1633         if (padapter->HalFunc.hal_cancel_checkbthang_workqueue)
1634                 padapter->HalFunc.hal_cancel_checkbthang_workqueue(padapter);
1635 #endif
1636         //cancel dm timer
1637         rtw_hal_dm_deinit(padapter);
1638
1639 }
1640
1641 u8 rtw_free_drv_sw(_adapter *padapter)
1642 {
1643         struct net_device *pnetdev = (struct net_device*)padapter->pnetdev;
1644
1645         RT_TRACE(_module_os_intfs_c_,_drv_info_,("==>rtw_free_drv_sw"));
1646
1647 #ifdef CONFIG_WAPI_SUPPORT
1648         rtw_wapi_free(padapter);
1649 #endif
1650
1651         //we can call rtw_p2p_enable here, but:
1652         // 1. rtw_p2p_enable may have IO operation
1653         // 2. rtw_p2p_enable is bundled with wext interface
1654         #ifdef CONFIG_P2P
1655         {
1656                 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
1657                 if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1658                 {
1659                         _cancel_timer_ex( &pwdinfo->find_phase_timer );
1660                         _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
1661                         _cancel_timer_ex( &pwdinfo->pre_tx_scan_timer);
1662 #ifdef CONFIG_CONCURRENT_MODE
1663                         _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer );
1664 #endif // CONFIG_CONCURRENT_MODE
1665                         rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
1666                 }
1667         }
1668         #endif
1669         // add for CONFIG_IEEE80211W, none 11w also can use
1670         _rtw_spinlock_free(&padapter->security_key_mutex);
1671
1672 #ifdef CONFIG_BR_EXT
1673         _rtw_spinlock_free(&padapter->br_ext_lock);
1674 #endif  // CONFIG_BR_EXT
1675
1676 #ifdef CONFIG_INTEL_WIDI
1677         rtw_free_intel_widi(padapter);
1678 #endif //CONFIG_INTEL_WIDI
1679
1680         free_mlme_ext_priv(&padapter->mlmeextpriv);
1681
1682 #ifdef CONFIG_TDLS
1683         //rtw_free_tdls_info(&padapter->tdlsinfo);
1684 #endif //CONFIG_TDLS
1685
1686         rtw_free_cmd_priv(&padapter->cmdpriv);
1687
1688         rtw_free_evt_priv(&padapter->evtpriv);
1689
1690         rtw_free_mlme_priv(&padapter->mlmepriv);
1691 #if defined(CONFIG_CHECK_BT_HANG) && defined(CONFIG_BT_COEXIST)
1692         if (padapter->HalFunc.hal_free_checkbthang_workqueue)
1693                 padapter->HalFunc.hal_free_checkbthang_workqueue(padapter);
1694 #endif
1695         //free_io_queue(padapter);
1696
1697         _rtw_free_xmit_priv(&padapter->xmitpriv);
1698
1699         _rtw_free_sta_priv(&padapter->stapriv); //will free bcmc_stainfo here
1700
1701         _rtw_free_recv_priv(&padapter->recvpriv);
1702
1703         rtw_free_pwrctrl_priv(padapter);
1704
1705         //rtw_mfree((void *)padapter, sizeof (padapter));
1706
1707 #ifdef CONFIG_DRVEXT_MODULE
1708         free_drvext(&padapter->drvextpriv);
1709 #endif
1710
1711         rtw_hal_free_data(padapter);
1712
1713         RT_TRACE(_module_os_intfs_c_,_drv_info_,("<==rtw_free_drv_sw\n"));
1714
1715         //free the old_pnetdev
1716         if(padapter->rereg_nd_name_priv.old_pnetdev) {
1717                 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
1718                 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
1719         }
1720
1721         // clear pbuddy_adapter to avoid access wrong pointer.
1722         if(padapter->pbuddy_adapter != NULL) {
1723                 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
1724         }
1725
1726         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-rtw_free_drv_sw\n"));
1727
1728         return _SUCCESS;
1729
1730 }
1731
1732 #ifdef CONFIG_CONCURRENT_MODE
1733 int _netdev_if2_open(struct net_device *pnetdev)
1734 {
1735         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1736         _adapter *primary_padapter = padapter->pbuddy_adapter;
1737
1738         DBG_871X("+871x_drv - if2_open, bup=%d\n", padapter->bup);
1739
1740         if(primary_padapter->bup == _FALSE || primary_padapter->hw_init_completed == _FALSE)
1741         {
1742                 _netdev_open(primary_padapter->pnetdev);
1743         }
1744
1745         if(padapter->bup == _FALSE && primary_padapter->bup == _TRUE &&
1746                 primary_padapter->hw_init_completed == _TRUE)
1747         {
1748                 int i;
1749
1750                 padapter->bDriverStopped = _FALSE;
1751                 padapter->bSurpriseRemoved = _FALSE;
1752                 padapter->bCardDisableWOHSM = _FALSE;
1753
1754                 padapter->bFWReady = primary_padapter->bFWReady;
1755
1756                 //if (init_mlme_ext_priv(padapter) == _FAIL)
1757                 //      goto netdev_if2_open_error;
1758
1759
1760                 if(rtw_start_drv_threads(padapter) == _FAIL)
1761                 {
1762                         goto netdev_if2_open_error;
1763                 }
1764
1765
1766                 if(padapter->intf_start)
1767                 {
1768                         padapter->intf_start(padapter);
1769                 }
1770
1771                 rtw_proc_init_one(pnetdev);
1772
1773
1774 #ifdef CONFIG_IOCTL_CFG80211
1775                 rtw_cfg80211_init_wiphy(padapter);
1776 #endif
1777
1778                 padapter->bup = _TRUE;
1779
1780         }
1781
1782         padapter->net_closed = _FALSE;
1783
1784         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
1785
1786         if(!rtw_netif_queue_stopped(pnetdev))
1787                 rtw_netif_start_queue(pnetdev);
1788         else
1789                 rtw_netif_wake_queue(pnetdev);
1790
1791         DBG_871X("-871x_drv - if2_open, bup=%d\n", padapter->bup);
1792         return 0;
1793
1794 netdev_if2_open_error:
1795
1796         padapter->bup = _FALSE;
1797
1798         netif_carrier_off(pnetdev);
1799         rtw_netif_stop_queue(pnetdev);
1800
1801         return (-1);
1802
1803 }
1804
1805 int netdev_if2_open(struct net_device *pnetdev)
1806 {
1807         int ret;
1808         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1809
1810         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
1811         ret = _netdev_if2_open(pnetdev);
1812         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
1813         return ret;
1814 }
1815
1816 static int netdev_if2_close(struct net_device *pnetdev)
1817 {
1818         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1819
1820         padapter->net_closed = _TRUE;
1821
1822         if(pnetdev)
1823         {
1824                 if (!rtw_netif_queue_stopped(pnetdev))
1825                         rtw_netif_stop_queue(pnetdev);
1826         }
1827
1828 #ifdef CONFIG_IOCTL_CFG80211
1829         rtw_scan_abort(padapter);
1830         wdev_to_priv(padapter->rtw_wdev)->bandroid_scan = _FALSE;
1831 #endif
1832
1833         return 0;
1834 }
1835
1836 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1837 static const struct net_device_ops rtw_netdev_if2_ops = {
1838         .ndo_open = netdev_if2_open,
1839         .ndo_stop = netdev_if2_close,
1840         .ndo_start_xmit = rtw_xmit_entry,
1841         .ndo_set_mac_address = rtw_net_set_mac_address,
1842         .ndo_get_stats = rtw_net_get_stats,
1843         .ndo_do_ioctl = rtw_ioctl,
1844 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1845         .ndo_select_queue       = rtw_select_queue,
1846 #endif
1847 };
1848 #endif
1849
1850
1851 #ifdef CONFIG_USB_HCI
1852         #include <usb_hal.h>
1853 #endif
1854 #ifdef CONFIG_SDIO_HCI
1855         #include <sdio_hal.h>
1856 #endif
1857 _adapter *rtw_drv_if2_init(_adapter *primary_padapter, void (*set_intf_ops)(struct _io_ops *pops))
1858 {
1859         int res = _FAIL;
1860         struct net_device *pnetdev = NULL;
1861         _adapter *padapter = NULL;
1862         struct dvobj_priv *pdvobjpriv;
1863         u8 mac[ETH_ALEN];
1864
1865         /****** init netdev ******/
1866         pnetdev = rtw_init_netdev(NULL);
1867         if (!pnetdev)
1868                 goto error_rtw_drv_if2_init;
1869
1870 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1871         DBG_871X("register rtw_netdev_if2_ops to netdev_ops\n");
1872         pnetdev->netdev_ops = &rtw_netdev_if2_ops;
1873 #else
1874         pnetdev->open = netdev_if2_open;
1875         pnetdev->stop = netdev_if2_close;
1876 #endif
1877
1878 #ifdef CONFIG_NO_WIRELESS_HANDLERS
1879         pnetdev->wireless_handlers = NULL;
1880 #endif
1881
1882         /****** init adapter ******/
1883         padapter = rtw_netdev_priv(pnetdev);
1884         _rtw_memcpy(padapter, primary_padapter, sizeof(_adapter));
1885
1886         //
1887         padapter->bup = _FALSE;
1888         padapter->net_closed = _TRUE;
1889         padapter->hw_init_completed = _FALSE;
1890         padapter->dir_dev = NULL;
1891         padapter->dir_odm = NULL;
1892
1893         //set adapter_type/iface type
1894         padapter->isprimary = _FALSE;
1895         padapter->adapter_type = SECONDARY_ADAPTER;
1896         padapter->pbuddy_adapter = primary_padapter;
1897         padapter->iface_id = IFACE_ID1;
1898 #ifndef CONFIG_HWPORT_SWAP                      //Port0 -> Pri , Port1 -> Sec
1899         padapter->iface_type = IFACE_PORT1;
1900 #else
1901         padapter->iface_type = IFACE_PORT0;
1902 #endif  //CONFIG_HWPORT_SWAP
1903         //
1904         padapter->pnetdev = pnetdev;
1905
1906         /****** setup dvobj ******/
1907         pdvobjpriv = adapter_to_dvobj(padapter);
1908         pdvobjpriv->if2 = padapter;
1909         pdvobjpriv->padapters[pdvobjpriv->iface_nums++] = padapter;
1910
1911         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(pdvobjpriv));
1912         #ifdef CONFIG_IOCTL_CFG80211
1913         rtw_wdev_alloc(padapter, dvobj_to_dev(pdvobjpriv));
1914         #endif //CONFIG_IOCTL_CFG80211
1915
1916         //set interface_type/chip_type/HardwareType
1917         padapter->interface_type = primary_padapter->interface_type;
1918         padapter->chip_type = primary_padapter->chip_type;
1919         padapter->HardwareType = primary_padapter->HardwareType;
1920
1921         //step 2. hook HalFunc, allocate HalData
1922         hal_set_hal_ops(padapter);
1923
1924         padapter->HalFunc.inirp_init = NULL;
1925         padapter->HalFunc.inirp_deinit = NULL;
1926
1927         //
1928         padapter->intf_start = primary_padapter->intf_start;
1929         padapter->intf_stop = primary_padapter->intf_stop;
1930
1931         //step init_io_priv
1932         if ((rtw_init_io_priv(padapter, set_intf_ops)) == _FAIL) {
1933                 RT_TRACE(_module_hci_intfs_c_,_drv_err_,(" \n Can't init io_reqs\n"));
1934         }
1935
1936         //step read_chip_version
1937         rtw_hal_read_chip_version(padapter);
1938
1939         //step usb endpoint mapping
1940         rtw_hal_chip_configure(padapter);
1941
1942
1943         //init drv data
1944         if(rtw_init_drv_sw(padapter)!= _SUCCESS)
1945                 goto error_rtw_drv_if2_init;
1946
1947         //get mac address from primary_padapter
1948         _rtw_memcpy(mac, primary_padapter->eeprompriv.mac_addr, ETH_ALEN);
1949
1950         if (((mac[0]==0xff) &&(mac[1]==0xff) && (mac[2]==0xff) &&
1951              (mac[3]==0xff) && (mac[4]==0xff) &&(mac[5]==0xff)) ||
1952             ((mac[0]==0x0) && (mac[1]==0x0) && (mac[2]==0x0) &&
1953              (mac[3]==0x0) && (mac[4]==0x0) &&(mac[5]==0x0)))
1954         {
1955                 mac[0] = 0x00;
1956                 mac[1] = 0xe0;
1957                 mac[2] = 0x4c;
1958                 mac[3] = 0x87;
1959                 mac[4] = 0x11;
1960                 mac[5] = 0x22;
1961         }
1962         else
1963         {
1964                 //If the BIT1 is 0, the address is universally administered.
1965                 //If it is 1, the address is locally administered
1966                 mac[0] |= BIT(1); // locally administered
1967
1968         }
1969
1970         _rtw_memcpy(padapter->eeprompriv.mac_addr, mac, ETH_ALEN);
1971         rtw_init_wifidirect_addrs(padapter, padapter->eeprompriv.mac_addr, padapter->eeprompriv.mac_addr);
1972
1973         primary_padapter->pbuddy_adapter = padapter;
1974
1975         res = _SUCCESS;
1976
1977         return padapter;
1978
1979
1980 error_rtw_drv_if2_init:
1981
1982         if(padapter)
1983                 rtw_free_drv_sw(padapter);
1984
1985         if (pnetdev)
1986                 rtw_free_netdev(pnetdev);
1987
1988         return NULL;
1989
1990 }
1991
1992 void rtw_drv_if2_free(_adapter *if2)
1993 {
1994         _adapter *padapter = if2;
1995         struct net_device *pnetdev = NULL;
1996
1997         if (padapter == NULL)
1998                 return;
1999
2000         pnetdev = padapter->pnetdev;
2001
2002 #ifdef CONFIG_IOCTL_CFG80211
2003         rtw_wdev_free(padapter->rtw_wdev);
2004 #endif /* CONFIG_IOCTL_CFG80211 */
2005
2006
2007         rtw_free_drv_sw(padapter);
2008
2009         rtw_free_netdev(pnetdev);
2010
2011 }
2012
2013 void rtw_drv_if2_stop(_adapter *if2)
2014 {
2015         _adapter *padapter = if2;
2016         //struct net_device *pnetdev = NULL;
2017
2018         if (padapter == NULL)
2019                 return;
2020 /*
2021         pnetdev = padapter->pnetdev;
2022
2023         if (pnetdev) {
2024                 unregister_netdev(pnetdev); //will call netdev_close()
2025                 rtw_proc_remove_one(pnetdev);
2026         }
2027 */
2028         rtw_cancel_all_timer(padapter);
2029
2030         if (padapter->bup == _TRUE) {
2031                 padapter->bDriverStopped = _TRUE;
2032                 #ifdef CONFIG_XMIT_ACK
2033                 if (padapter->xmitpriv.ack_tx)
2034                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
2035                 #endif
2036
2037                 if(padapter->intf_stop)
2038                 {
2039                         padapter->intf_stop(padapter);
2040                 }
2041
2042                 rtw_stop_drv_threads(padapter);
2043
2044                 padapter->bup = _FALSE;
2045         }
2046 /*
2047         #ifdef CONFIG_IOCTL_CFG80211
2048         rtw_wdev_unregister(padapter->rtw_wdev);
2049         #endif
2050 */
2051 }
2052 #endif //end of CONFIG_CONCURRENT_MODE
2053
2054 #ifdef CONFIG_BR_EXT
2055 void netdev_br_init(struct net_device *netdev)
2056 {
2057         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
2058
2059 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2060         rcu_read_lock();
2061 #endif  // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2062
2063         //if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE)
2064         {
2065                 //struct net_bridge     *br = netdev->br_port->br;//->dev->dev_addr;
2066 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2067                 if (netdev->br_port)
2068 #else   // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2069                 if (rcu_dereference(adapter->pnetdev->rx_handler_data))
2070 #endif  // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2071                 {
2072                         struct net_device *br_netdev;
2073 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2074                         br_netdev = dev_get_by_name(CONFIG_BR_EXT_BRNAME);
2075 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2076                         struct net *devnet = NULL;
2077
2078 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2079                         devnet = netdev->nd_net;
2080 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2081                         devnet = dev_net(netdev);
2082 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2083
2084                         br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME);
2085 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2086
2087                         if (br_netdev) {
2088                                 memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN);
2089                                 dev_put(br_netdev);
2090                         } else
2091                                 DBG_871X("%s()-%d: dev_get_by_name(%s) failed!", __FUNCTION__, __LINE__, CONFIG_BR_EXT_BRNAME);
2092                 }
2093
2094                 adapter->ethBrExtInfo.addPPPoETag = 1;
2095         }
2096
2097 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2098         rcu_read_unlock();
2099 #endif  // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2100 }
2101 #endif //CONFIG_BR_EXT
2102
2103 static int _rtw_drv_register_netdev(_adapter *padapter, char *name)
2104 {
2105         int ret = _SUCCESS;
2106         struct net_device *pnetdev = padapter->pnetdev;
2107
2108         /* alloc netdev name */
2109         rtw_init_netdev_name(pnetdev, name);
2110
2111         _rtw_memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
2112
2113         /* Tell the network stack we exist */
2114         if (register_netdev(pnetdev) != 0) {
2115                 DBG_871X(FUNC_NDEV_FMT "Failed!\n", FUNC_NDEV_ARG(pnetdev));
2116                 ret = _FAIL;
2117                 goto error_register_netdev;
2118         }
2119
2120         DBG_871X("%s, MAC Address (if%d) = " MAC_FMT "\n", __FUNCTION__, (padapter->iface_id+1), MAC_ARG(pnetdev->dev_addr));
2121
2122         return ret;
2123
2124 error_register_netdev:
2125
2126         if(padapter->iface_id > IFACE_ID0)
2127         {
2128                 rtw_free_drv_sw(padapter);
2129
2130                 rtw_free_netdev(pnetdev);
2131         }
2132
2133         return ret;
2134 }
2135
2136 int rtw_drv_register_netdev(_adapter *if1)
2137 {
2138         int i, status = _SUCCESS;
2139         struct dvobj_priv *dvobj = if1->dvobj;
2140
2141         if(dvobj->iface_nums < IFACE_ID_MAX)
2142         {
2143                 for(i=0; i<dvobj->iface_nums; i++)
2144                 {
2145                         _adapter *padapter = dvobj->padapters[i];
2146
2147                         if(padapter)
2148                         {
2149                                 char *name;
2150
2151                                 if(padapter->iface_id == IFACE_ID0)
2152                                         name = if1->registrypriv.ifname;
2153                                 else if(padapter->iface_id == IFACE_ID1)
2154                                         name = if1->registrypriv.if2name;
2155                                 else
2156                                         name = "wlan%d";
2157
2158                                 if((status = _rtw_drv_register_netdev(padapter, name)) != _SUCCESS) {
2159                                         break;
2160                                 }
2161                         }
2162                 }
2163         }
2164
2165         return status;
2166 }
2167
2168 int _netdev_open(struct net_device *pnetdev)
2169 {
2170         uint status;
2171         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2172         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
2173
2174         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - dev_open\n"));
2175         DBG_871X("+871x_drv - drv_open, bup=%d\n", padapter->bup);
2176
2177         if(pwrctrlpriv->ps_flag == _TRUE){
2178                 padapter->net_closed = _FALSE;
2179                 goto netdev_open_normal_process;
2180         }
2181
2182         if(padapter->bup == _FALSE)
2183         {
2184                 padapter->bDriverStopped = _FALSE;
2185                 padapter->bSurpriseRemoved = _FALSE;
2186                 padapter->bCardDisableWOHSM = _FALSE;
2187
2188                 status = rtw_hal_init(padapter);
2189                 if (status ==_FAIL)
2190                 {
2191                         RT_TRACE(_module_os_intfs_c_,_drv_err_,("rtl871x_hal_init(): Can't init h/w!\n"));
2192                         goto netdev_open_error;
2193                 }
2194
2195                 DBG_871X("MAC Address = "MAC_FMT"\n", MAC_ARG(pnetdev->dev_addr));
2196
2197 #ifdef CONFIG_RF_GAIN_OFFSET
2198                 rtw_bb_rf_gain_offset(padapter);
2199 #endif //CONFIG_RF_GAIN_OFFSET
2200
2201                 status=rtw_start_drv_threads(padapter);
2202                 if(status ==_FAIL)
2203                 {
2204                         DBG_871X("Initialize driver software resource Failed!\n");
2205                         goto netdev_open_error;
2206                 }
2207
2208 #ifdef CONFIG_DRVEXT_MODULE
2209                 init_drvext(padapter);
2210 #endif
2211
2212                 if(padapter->intf_start)
2213                 {
2214                         padapter->intf_start(padapter);
2215                 }
2216
2217 #ifndef RTK_DMP_PLATFORM
2218                 rtw_proc_init_one(pnetdev);
2219 #endif
2220
2221 #ifdef CONFIG_IOCTL_CFG80211
2222                 rtw_cfg80211_init_wiphy(padapter);
2223 #endif
2224
2225                 rtw_led_control(padapter, LED_CTL_NO_LINK);
2226
2227                 padapter->bup = _TRUE;
2228
2229                 pwrctrlpriv->bips_processing = _FALSE;
2230         }
2231         padapter->net_closed = _FALSE;
2232
2233         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
2234
2235 #ifdef CONFIG_DETECT_C2H_BY_POLLING
2236         _set_timer(&padapter->mlmepriv.event_polling_timer, 200);
2237 #endif
2238
2239         rtw_set_pwr_state_check_timer(pwrctrlpriv);
2240
2241         //netif_carrier_on(pnetdev);//call this func when rtw_joinbss_event_callback return success
2242         if(!rtw_netif_queue_stopped(pnetdev))
2243                 rtw_netif_start_queue(pnetdev);
2244         else
2245                 rtw_netif_wake_queue(pnetdev);
2246
2247 #ifdef CONFIG_BR_EXT
2248         netdev_br_init(pnetdev);
2249 #endif  // CONFIG_BR_EXT
2250
2251 netdev_open_normal_process:
2252
2253         #ifdef CONFIG_CONCURRENT_MODE
2254         {
2255                 _adapter *sec_adapter = padapter->pbuddy_adapter;
2256                 if(sec_adapter && (sec_adapter->bup == _FALSE))
2257                         _netdev_if2_open(sec_adapter->pnetdev);
2258         }
2259         #endif
2260
2261         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - dev_open\n"));
2262         DBG_871X("-871x_drv - drv_open, bup=%d\n", padapter->bup);
2263
2264         return 0;
2265
2266 netdev_open_error:
2267
2268         padapter->bup = _FALSE;
2269
2270         netif_carrier_off(pnetdev);
2271         rtw_netif_stop_queue(pnetdev);
2272
2273         RT_TRACE(_module_os_intfs_c_,_drv_err_,("-871x_drv - dev_open, fail!\n"));
2274         DBG_871X("-871x_drv - drv_open fail, bup=%d\n", padapter->bup);
2275
2276         return (-1);
2277
2278 }
2279
2280 int netdev_open(struct net_device *pnetdev)
2281 {
2282         int ret;
2283         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2284
2285         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2286         ret = _netdev_open(pnetdev);
2287         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2288
2289         return ret;
2290 }
2291
2292 #ifdef CONFIG_IPS
2293 int  ips_netdrv_open(_adapter *padapter)
2294 {
2295         int status = _SUCCESS;
2296         padapter->net_closed = _FALSE;
2297         DBG_871X("===> %s.........\n",__FUNCTION__);
2298
2299
2300         padapter->bDriverStopped = _FALSE;
2301         padapter->bCardDisableWOHSM = _FALSE;
2302         //padapter->bup = _TRUE;
2303
2304         status = rtw_hal_init(padapter);
2305         if (status ==_FAIL)
2306         {
2307                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("ips_netdrv_open(): Can't init h/w!\n"));
2308                 goto netdev_open_error;
2309         }
2310
2311 #ifdef CONFIG_RF_GAIN_OFFSET
2312         rtw_bb_rf_gain_offset(padapter);
2313 #endif //CONFIG_RF_GAIN_OFFSET
2314
2315         if(padapter->intf_start)
2316         {
2317                 padapter->intf_start(padapter);
2318         }
2319
2320         rtw_set_pwr_state_check_timer(adapter_to_pwrctl(padapter));
2321         _set_timer(&padapter->mlmepriv.dynamic_chk_timer,5000);
2322
2323          return _SUCCESS;
2324
2325 netdev_open_error:
2326         //padapter->bup = _FALSE;
2327         DBG_871X("-ips_netdrv_open - drv_open failure, bup=%d\n", padapter->bup);
2328
2329         return _FAIL;
2330 }
2331
2332
2333 int rtw_ips_pwr_up(_adapter *padapter)
2334 {
2335         int result;
2336         u32 start_time = rtw_get_current_time();
2337         DBG_871X("===>  rtw_ips_pwr_up..............\n");
2338         rtw_reset_drv_sw(padapter);
2339
2340         result = ips_netdrv_open(padapter);
2341
2342         rtw_led_control(padapter, LED_CTL_NO_LINK);
2343
2344         DBG_871X("<===  rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time));
2345         return result;
2346
2347 }
2348
2349 void rtw_ips_pwr_down(_adapter *padapter)
2350 {
2351         u32 start_time = rtw_get_current_time();
2352         DBG_871X("===> rtw_ips_pwr_down...................\n");
2353
2354         padapter->bCardDisableWOHSM = _TRUE;
2355         padapter->net_closed = _TRUE;
2356
2357         rtw_led_control(padapter, LED_CTL_POWER_OFF);
2358
2359         rtw_ips_dev_unload(padapter);
2360         padapter->bCardDisableWOHSM = _FALSE;
2361         DBG_871X("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time));
2362 }
2363 #endif
2364 void rtw_ips_dev_unload(_adapter *padapter)
2365 {
2366         struct net_device *pnetdev= (struct net_device*)padapter->pnetdev;
2367         struct xmit_priv        *pxmitpriv = &(padapter->xmitpriv);
2368         DBG_871X("====> %s...\n",__FUNCTION__);
2369
2370         rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, 0);
2371
2372         if(padapter->intf_stop)
2373         {
2374                 padapter->intf_stop(padapter);
2375         }
2376
2377         //s5.
2378         if(padapter->bSurpriseRemoved == _FALSE)
2379         {
2380                 rtw_hal_deinit(padapter);
2381         }
2382
2383 }
2384
2385 #ifdef CONFIG_RF_GAIN_OFFSET
2386 void rtw_bb_rf_gain_offset(_adapter *padapter)
2387 {
2388         u8      value = padapter->eeprompriv.EEPROMRFGainOffset;
2389         u8      tmp = 0x3e;
2390         u32     res;
2391
2392         DBG_871X("+%s value: 0x%02x+\n", __func__, value);
2393
2394         if (value & RF_GAIN_OFFSET_ON) {
2395                 //DBG_871X("Offset RF Gain.\n");
2396                 //DBG_871X("Offset RF Gain.  padapter->eeprompriv.EEPROMRFGainVal=0x%x\n",padapter->eeprompriv.EEPROMRFGainVal);
2397                 if(padapter->eeprompriv.EEPROMRFGainVal != 0xff){
2398 #ifdef CONFIG_RTL8723A
2399                         res = rtw_hal_read_rfreg(padapter, RF_PATH_A, 0xd, 0xffffffff);
2400                         //DBG_871X("Offset RF Gain. reg 0xd=0x%x\n",res);
2401                         res &= 0xfff87fff;
2402
2403                         res |= (padapter->eeprompriv.EEPROMRFGainVal & 0x0f)<< 15;
2404                         //DBG_871X("Offset RF Gain.    reg 0xd=0x%x\n",res);
2405
2406                         rtw_hal_write_rfreg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, RF_GAIN_OFFSET_MASK, res);
2407
2408                         res = rtw_hal_read_rfreg(padapter, RF_PATH_A, 0xe, 0xffffffff);
2409                         DBG_871X("Offset RF Gain. reg 0xe=0x%x\n",res);
2410                         res &= 0xfffffff0;
2411
2412                         res |= (padapter->eeprompriv.EEPROMRFGainVal & 0x0f);
2413                         //DBG_871X("Offset RF Gain.    reg 0xe=0x%x\n",res);
2414
2415                         rtw_hal_write_rfreg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, RF_GAIN_OFFSET_MASK, res);
2416 #else
2417                         res = rtw_hal_read_rfreg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, 0xffffffff);
2418                         DBG_871X("REG_RF_BB_GAIN_OFFSET=%x \n",res);
2419                         res &= 0xfff87fff;
2420                         res |= (padapter->eeprompriv.EEPROMRFGainVal & 0x0f)<< 15;
2421                         DBG_871X("write REG_RF_BB_GAIN_OFFSET=%x \n",res);
2422                         rtw_hal_write_rfreg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, RF_GAIN_OFFSET_MASK, res);
2423 #endif
2424                 }
2425                 else
2426                 {
2427                         //DBG_871X("Offset RF Gain.  padapter->eeprompriv.EEPROMRFGainVal=0x%x  != 0xff, didn't run Kfree\n",padapter->eeprompriv.EEPROMRFGainVal);
2428                 }
2429         } else {
2430                 //DBG_871X("Using the default RF gain.\n");
2431         }
2432
2433 }
2434 #endif //CONFIG_RF_GAIN_OFFSET
2435
2436 int pm_netdev_open(struct net_device *pnetdev,u8 bnormal)
2437 {
2438         int status;
2439
2440
2441         if (_TRUE == bnormal)
2442                 status = netdev_open(pnetdev);
2443 #ifdef CONFIG_IPS
2444         else
2445                 status =  (_SUCCESS == ips_netdrv_open((_adapter *)rtw_netdev_priv(pnetdev)))?(0):(-1);
2446 #endif
2447
2448         return status;
2449 }
2450
2451 static int netdev_close(struct net_device *pnetdev)
2452 {
2453         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2454
2455         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - drv_close\n"));
2456
2457         if(adapter_to_pwrctl(padapter)->bInternalAutoSuspend == _TRUE)
2458         {
2459                 //rtw_pwr_wakeup(padapter);
2460                 if(adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off)
2461                         adapter_to_pwrctl(padapter)->ps_flag = _TRUE;
2462         }
2463         padapter->net_closed = _TRUE;
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(adapter_to_pwrctl(padapter)->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         wdev_to_priv(padapter->rtw_wdev)->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 void rtw_ndev_destructor(struct net_device *ndev)
2529 {
2530         DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2531
2532 #ifdef CONFIG_IOCTL_CFG80211
2533         if (ndev->ieee80211_ptr)
2534                 rtw_mfree((u8 *)ndev->ieee80211_ptr, sizeof(struct wireless_dev));
2535 #endif
2536         free_netdev(ndev);
2537 }
2538
2539 #ifdef CONFIG_ARP_KEEP_ALIVE
2540 struct route_info {
2541     struct in_addr dst_addr;
2542     struct in_addr src_addr;
2543     struct in_addr gateway;
2544     unsigned int dev_index;
2545 };
2546
2547 static void parse_routes(struct nlmsghdr *nl_hdr, struct route_info *rt_info)
2548 {
2549     struct rtmsg *rt_msg;
2550     struct rtattr *rt_attr;
2551     int rt_len;
2552
2553     rt_msg = (struct rtmsg *) NLMSG_DATA(nl_hdr);
2554     if ((rt_msg->rtm_family != AF_INET) || (rt_msg->rtm_table != RT_TABLE_MAIN))
2555         return;
2556
2557     rt_attr = (struct rtattr *) RTM_RTA(rt_msg);
2558     rt_len = RTM_PAYLOAD(nl_hdr);
2559
2560     for (; RTA_OK(rt_attr, rt_len); rt_attr = RTA_NEXT(rt_attr, rt_len))
2561         {
2562         switch (rt_attr->rta_type) {
2563         case RTA_OIF:
2564                 rt_info->dev_index = *(int *) RTA_DATA(rt_attr);
2565             break;
2566         case RTA_GATEWAY:
2567             rt_info->gateway.s_addr = *(u_int *) RTA_DATA(rt_attr);
2568             break;
2569         case RTA_PREFSRC:
2570             rt_info->src_addr.s_addr = *(u_int *) RTA_DATA(rt_attr);
2571             break;
2572         case RTA_DST:
2573             rt_info->dst_addr.s_addr = *(u_int *) RTA_DATA(rt_attr);
2574             break;
2575         }
2576     }
2577 }
2578
2579 static int route_dump(u32 *gw_addr ,int* gw_index)
2580 {
2581         int err = 0;
2582         struct socket *sock;
2583         struct {
2584                 struct nlmsghdr nlh;
2585                 struct rtgenmsg g;
2586         } req;
2587         struct msghdr msg;
2588         struct iovec iov;
2589         struct sockaddr_nl nladdr;
2590         mm_segment_t oldfs;
2591         char *pg;
2592         int size = 0;
2593
2594         err = sock_create(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE, &sock);
2595         if (err)
2596         {
2597                 printk( ": Could not create a datagram socket, error = %d\n", -ENXIO);
2598                 return err;
2599         }
2600
2601         memset(&nladdr, 0, sizeof(nladdr));
2602         nladdr.nl_family = AF_NETLINK;
2603
2604         req.nlh.nlmsg_len = sizeof(req);
2605         req.nlh.nlmsg_type = RTM_GETROUTE;
2606         req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
2607         req.nlh.nlmsg_pid = 0;
2608         req.g.rtgen_family = AF_INET;
2609
2610         iov.iov_base = &req;
2611         iov.iov_len = sizeof(req);
2612
2613         msg.msg_name = &nladdr;
2614         msg.msg_namelen = sizeof(nladdr);
2615         msg.msg_iov = &iov;
2616         msg.msg_iovlen = 1;
2617         msg.msg_control = NULL;
2618         msg.msg_controllen = 0;
2619         msg.msg_flags = MSG_DONTWAIT;
2620
2621         oldfs = get_fs(); set_fs(KERNEL_DS);
2622         err = sock_sendmsg(sock, &msg, sizeof(req));
2623         set_fs(oldfs);
2624
2625         if (size < 0)
2626                 goto out_sock;
2627
2628         pg = (char *) __get_free_page(GFP_KERNEL);
2629         if (pg == NULL) {
2630                 err = -ENOMEM;
2631                 goto out_sock;
2632         }
2633
2634 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
2635 restart:
2636 #endif
2637
2638         for (;;)
2639         {
2640                 struct nlmsghdr *h;
2641
2642                 iov.iov_base = pg;
2643                 iov.iov_len = PAGE_SIZE;
2644
2645                 oldfs = get_fs(); set_fs(KERNEL_DS);
2646                 err = sock_recvmsg(sock, &msg, PAGE_SIZE, MSG_DONTWAIT);
2647                 set_fs(oldfs);
2648
2649                 if (err < 0)
2650                         goto out_sock_pg;
2651
2652                 if (msg.msg_flags & MSG_TRUNC) {
2653                         err = -ENOBUFS;
2654                         goto out_sock_pg;
2655                 }
2656
2657                 h = (struct nlmsghdr*) pg;
2658
2659                 while (NLMSG_OK(h, err))
2660                 {
2661                         struct route_info rt_info;
2662                         if (h->nlmsg_type == NLMSG_DONE) {
2663                                 err = 0;
2664                                 goto done;
2665                         }
2666
2667                         if (h->nlmsg_type == NLMSG_ERROR) {
2668                                 struct nlmsgerr *errm = (struct nlmsgerr*) NLMSG_DATA(h);
2669                                 err = errm->error;
2670                                 printk( "NLMSG error: %d\n", errm->error);
2671                                 goto done;
2672                         }
2673
2674                         if (h->nlmsg_type == RTM_GETROUTE)
2675                         {
2676                                 printk( "RTM_GETROUTE: NLMSG: %d\n", h->nlmsg_type);
2677                         }
2678                         if (h->nlmsg_type != RTM_NEWROUTE) {
2679                                 printk( "NLMSG: %d\n", h->nlmsg_type);
2680                                 err = -EINVAL;
2681                                 goto done;
2682                         }
2683
2684                         memset(&rt_info, 0, sizeof(struct route_info));
2685                         parse_routes(h, &rt_info);
2686                         if(!rt_info.dst_addr.s_addr && rt_info.gateway.s_addr && rt_info.dev_index)
2687                         {
2688                                 *gw_addr = rt_info.gateway.s_addr;
2689                                 *gw_index = rt_info.dev_index;
2690
2691                         }
2692                         h = NLMSG_NEXT(h, err);
2693                 }
2694
2695                 if (err)
2696                 {
2697                         printk( "!!!Remnant of size %d %d %d\n", err, h->nlmsg_len, h->nlmsg_type);
2698                         err = -EINVAL;
2699                         break;
2700                 }
2701         }
2702
2703 done:
2704 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
2705         if (!err && req.g.rtgen_family == AF_INET) {
2706                 req.g.rtgen_family = AF_INET6;
2707
2708                 iov.iov_base = &req;
2709                 iov.iov_len = sizeof(req);
2710
2711                 msg.msg_name = &nladdr;
2712                 msg.msg_namelen = sizeof(nladdr);
2713                 msg.msg_iov = &iov;
2714                 msg.msg_iovlen = 1;
2715                 msg.msg_control = NULL;
2716                 msg.msg_controllen = 0;
2717                 msg.msg_flags=MSG_DONTWAIT;
2718
2719                 oldfs = get_fs(); set_fs(KERNEL_DS);
2720                 err = sock_sendmsg(sock, &msg, sizeof(req));
2721                 set_fs(oldfs);
2722
2723                 if (err > 0)
2724                         goto restart;
2725         }
2726 #endif
2727
2728 out_sock_pg:
2729         free_page((unsigned long) pg);
2730
2731 out_sock:
2732         sock_release(sock);
2733         return err;
2734 }
2735
2736 static int arp_query(unsigned char *haddr, u32 paddr,
2737              struct net_device *dev)
2738 {
2739         struct neighbour *neighbor_entry;
2740         int     ret = 0;
2741
2742         neighbor_entry = neigh_lookup(&arp_tbl, &paddr, dev);
2743
2744         if (neighbor_entry != NULL) {
2745                 neighbor_entry->used = jiffies;
2746                 if (neighbor_entry->nud_state & NUD_VALID) {
2747                         _rtw_memcpy(haddr, neighbor_entry->ha, dev->addr_len);
2748                         ret = 1;
2749                 }
2750                 neigh_release(neighbor_entry);
2751         }
2752         return ret;
2753 }
2754
2755 static int get_defaultgw(u32 *ip_addr ,char mac[])
2756 {
2757         int gw_index = 0; // oif device index
2758         struct net_device *gw_dev = NULL; //oif device
2759
2760         route_dump(ip_addr, &gw_index);
2761
2762         if( !(*ip_addr) || !gw_index )
2763         {
2764                 //DBG_871X("No default GW \n");
2765                 return -1;
2766         }
2767
2768         gw_dev = dev_get_by_index(&init_net, gw_index);
2769
2770         if(gw_dev == NULL)
2771         {
2772                 //DBG_871X("get Oif Device Fail \n");
2773                 return -1;
2774         }
2775
2776         if(!arp_query(mac, *ip_addr, gw_dev))
2777         {
2778                 //DBG_871X( "arp query failed\n");
2779                 dev_put(gw_dev);
2780                 return -1;
2781
2782         }
2783         dev_put(gw_dev);
2784
2785         return 0;
2786 }
2787
2788 int     rtw_gw_addr_query(_adapter *padapter)
2789 {
2790         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2791         u32 gw_addr = 0; // default gw address
2792         unsigned char gw_mac[32] = {0}; // default gw mac
2793         int i;
2794         int res;
2795
2796         res = get_defaultgw(&gw_addr, gw_mac);
2797         if(!res)
2798         {
2799                 pmlmepriv->gw_ip[0] = gw_addr&0xff;
2800                 pmlmepriv->gw_ip[1] = (gw_addr&0xff00)>>8;
2801                 pmlmepriv->gw_ip[2] = (gw_addr&0xff0000)>>16;
2802                 pmlmepriv->gw_ip[3] = (gw_addr&0xff000000)>>24;
2803                 _rtw_memcpy(pmlmepriv->gw_mac_addr, gw_mac, 6);
2804                 DBG_871X("%s Gateway Mac:\t" MAC_FMT "\n", __FUNCTION__, MAC_ARG(pmlmepriv->gw_mac_addr));
2805                 DBG_871X("%s Gateway IP:\t" IP_FMT "\n", __FUNCTION__, IP_ARG(pmlmepriv->gw_ip));
2806         }
2807         else
2808         {
2809                 //DBG_871X("Get Gateway IP/MAC fail!\n");
2810         }
2811
2812         return res;
2813 }
2814 #endif
2815
2816 int rtw_suspend_free_assoc_resource(_adapter *padapter)
2817 {
2818         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2819         struct net_device *pnetdev = padapter->pnetdev;
2820         struct wifidirect_info* pwdinfo = &padapter->wdinfo;
2821
2822         DBG_871X("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
2823
2824         rtw_cancel_all_timer(padapter);
2825         if(pnetdev){
2826                 netif_carrier_off(pnetdev);
2827                 rtw_netif_stop_queue(pnetdev);
2828         }
2829
2830         #ifdef CONFIG_LAYER2_ROAMING_RESUME
2831         if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED) && rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
2832         {
2833                 DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n",__FUNCTION__,
2834                                 pmlmepriv->cur_network.network.Ssid.Ssid,
2835                                 MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
2836                                 pmlmepriv->cur_network.network.Ssid.SsidLength,
2837                                 pmlmepriv->assoc_ssid.SsidLength);
2838                 rtw_set_roaming(padapter, 1);
2839         }
2840         #endif //CONFIG_LAYER2_ROAMING_RESUME
2841
2842         if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED))
2843         {
2844                 rtw_disassoc_cmd(padapter, 0, _FALSE);
2845         }
2846         #ifdef CONFIG_AP_MODE
2847         else if(check_fwstate(pmlmepriv, WIFI_AP_STATE))
2848         {
2849                 rtw_sta_flush(padapter);
2850         }
2851         #endif
2852         if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) ){
2853                 //s2-2.  indicate disconnect to os
2854                 rtw_indicate_disconnect(padapter);
2855         }
2856
2857         //s2-3.
2858         rtw_free_assoc_resources(padapter, 1);
2859
2860         //s2-4.
2861 #ifdef CONFIG_AUTOSUSPEND
2862         if(is_primary_adapter(padapter) && (!adapter_to_pwrctl(padapter)->bInternalAutoSuspend ))
2863 #endif
2864         rtw_free_network_queue(padapter, _TRUE);
2865
2866         if(check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
2867                 rtw_indicate_scan_done(padapter, 1);
2868
2869         DBG_871X("==> "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
2870         return 0;
2871 }
2872 extern void rtw_dev_unload(_adapter *padapter);
2873 int rtw_suspend_common(_adapter *padapter)
2874 {
2875         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2876         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2877
2878         int ret = 0;
2879         _func_enter_;
2880
2881         rtw_suspend_free_assoc_resource(padapter);
2882
2883 #ifdef CONFIG_CONCURRENT_MODE
2884         if(rtw_buddy_adapter_up(padapter)){
2885                 rtw_suspend_free_assoc_resource(padapter->pbuddy_adapter);
2886         }
2887 #endif
2888         rtw_led_control(padapter, LED_CTL_POWER_OFF);
2889
2890 #ifdef CONFIG_CONCURRENT_MODE
2891         if(rtw_buddy_adapter_up(padapter)){
2892                 rtw_dev_unload(padapter->pbuddy_adapter);
2893         }
2894 #endif
2895         rtw_dev_unload(padapter);
2896
2897 exit:
2898
2899         _func_exit_;
2900         return ret;
2901 }
2902
2903 int rtw_resume_common(_adapter *padapter)
2904 {
2905         int ret = 0;
2906         struct net_device *pnetdev= padapter->pnetdev;
2907         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2908         struct mlme_priv *mlmepriv = &padapter->mlmepriv;
2909
2910         _func_enter_;
2911
2912         #ifdef CONFIG_CONCURRENT_MODE
2913         rtw_reset_drv_sw(padapter->pbuddy_adapter);
2914         #endif
2915
2916         rtw_reset_drv_sw(padapter);
2917         pwrpriv->bkeepfwalive = _FALSE;
2918
2919         DBG_871X("bkeepfwalive(%x)\n",pwrpriv->bkeepfwalive);
2920         if(pm_netdev_open(pnetdev,_TRUE) != 0) {
2921                 DBG_871X("%s ==> pm_netdev_open failed \n",__FUNCTION__);
2922                 ret = -1;
2923                 return ret;
2924         }
2925
2926         netif_device_attach(pnetdev);
2927         netif_carrier_on(pnetdev);
2928
2929
2930         #ifdef CONFIG_CONCURRENT_MODE
2931         if(rtw_buddy_adapter_up(padapter)){
2932                 pnetdev = padapter->pbuddy_adapter->pnetdev;
2933
2934                 netif_device_attach(pnetdev);
2935                 netif_carrier_on(pnetdev);
2936         }
2937         #endif
2938
2939         if (check_fwstate(mlmepriv, WIFI_STATION_STATE)) {
2940                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2941
2942                 #ifdef CONFIG_LAYER2_ROAMING_RESUME
2943                 rtw_roaming(padapter, NULL);
2944                 #endif //CONFIG_LAYER2_ROAMING_RESUME
2945
2946         } else if (check_fwstate(mlmepriv, WIFI_AP_STATE)) {
2947                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_AP_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2948                 rtw_ap_restore_network(padapter);
2949         } else if (check_fwstate(mlmepriv, WIFI_ADHOC_STATE)) {
2950                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2951         } else {
2952                 DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2953         }
2954
2955         #ifdef CONFIG_CONCURRENT_MODE
2956         if(rtw_buddy_adapter_up(padapter))
2957         {
2958                 padapter = padapter->pbuddy_adapter;
2959                 mlmepriv = &padapter->mlmepriv;
2960                 if (check_fwstate(mlmepriv, WIFI_STATION_STATE)) {
2961                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2962
2963                         #ifdef CONFIG_LAYER2_ROAMING_RESUME
2964                         rtw_roaming(padapter, NULL);
2965                         #endif //CONFIG_LAYER2_ROAMING_RESUME
2966
2967                 } else if (check_fwstate(mlmepriv, WIFI_AP_STATE)) {
2968                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_AP_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2969                         rtw_ap_restore_network(padapter);
2970                 } else if (check_fwstate(mlmepriv, WIFI_ADHOC_STATE)) {
2971                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2972                 } else {
2973                         DBG_871X(FUNC_ADPT_FMT" fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(padapter), get_fwstate(mlmepriv));
2974                 }
2975         }
2976         #endif
2977
2978         _func_exit_;
2979         return ret;
2980 }