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