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