drivers/net/wireless/rtl8192du/os_dep/linux/os_intfs.c

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