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