drivers/net/wireless/realtek/rtl8192cu/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 = "wlan%d";
 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 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 13, 0)
 950                                 , void *accel_priv
 951 #endif
 952 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,14,0))
 953                             , select_queue_fallback_t fallback
 954 #endif
 955 )
 956 {
 957         _adapter        *padapter = rtw_netdev_priv(dev);
 958         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 959
 960         skb->priority = rtw_classify8021d(skb);
 961
 962         if(pmlmepriv->acm_mask != 0)
 963         {
 964                 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
 965         }
 966
 967         return rtw_1d_to_queue[skb->priority];
 968 }
 969
 970 u16 rtw_recv_select_queue(struct sk_buff *skb)
 971 {
 972         struct iphdr *piphdr;
 973         unsigned int dscp;
 974         u16     eth_type;
 975         u32 priority;
 976         u8 *pdata = skb->data;
 977
 978         _rtw_memcpy(&eth_type, pdata+(ETH_ALEN<<1), 2);
 979
 980         switch (eth_type) {
 981                 case htons(ETH_P_IP):
 982
 983                         piphdr = (struct iphdr *)(pdata+ETH_HLEN);
 984
 985                         dscp = piphdr->tos & 0xfc;
 986
 987                         priority = dscp >> 5;
 988
 989                         break;
 990                 default:
 991                         priority = 0;
 992         }
 993
 994         return rtw_1d_to_queue[priority];
 995
 996 }
 997
 998 #endif
 999
1000 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1001 static const struct net_device_ops rtw_netdev_ops = {
1002         .ndo_open = netdev_open,
1003         .ndo_stop = netdev_close,
1004         .ndo_start_xmit = rtw_xmit_entry,
1005 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1006         .ndo_select_queue       = rtw_select_queue,
1007 #endif
1008         .ndo_set_mac_address = rtw_net_set_mac_address,
1009         .ndo_get_stats = rtw_net_get_stats,
1010         .ndo_do_ioctl = rtw_ioctl,
1011 };
1012 #endif
1013
1014 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
1015 {
1016         _adapter *padapter = rtw_netdev_priv(pnetdev);
1017
1018 #ifdef CONFIG_EASY_REPLACEMENT
1019         struct net_device       *TargetNetdev = NULL;
1020         _adapter                        *TargetAdapter = NULL;
1021         struct net              *devnet = NULL;
1022
1023         if(padapter->bDongle == 1)
1024         {
1025 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1026                 TargetNetdev = dev_get_by_name("wlan0");
1027 #else
1028         #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
1029                 devnet = pnetdev->nd_net;
1030         #else
1031                 devnet = dev_net(pnetdev);
1032         #endif
1033                 TargetNetdev = dev_get_by_name(devnet, "wlan0");
1034 #endif
1035                 if(TargetNetdev) {
1036                         DBG_871X("Force onboard module driver disappear !!!\n");
1037                         TargetAdapter = rtw_netdev_priv(TargetNetdev);
1038                         TargetAdapter->DriverState = DRIVER_DISAPPEAR;
1039
1040                         padapter->pid[0] = TargetAdapter->pid[0];
1041                         padapter->pid[1] = TargetAdapter->pid[1];
1042                         padapter->pid[2] = TargetAdapter->pid[2];
1043
1044                         dev_put(TargetNetdev);
1045                         unregister_netdev(TargetNetdev);
1046
1047                         if(TargetAdapter->chip_type == padapter->chip_type)
1048                                 rtw_proc_remove_one(TargetNetdev);
1049
1050                         padapter->DriverState = DRIVER_REPLACE_DONGLE;
1051                 }
1052         }
1053 #endif //CONFIG_EASY_REPLACEMENT
1054
1055         if(dev_alloc_name(pnetdev, ifname) < 0)
1056         {
1057                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("dev_alloc_name, fail! \n"));
1058         }
1059
1060         netif_carrier_off(pnetdev);
1061         //rtw_netif_stop_queue(pnetdev);
1062
1063         return 0;
1064 }
1065
1066 static const struct device_type wlan_type = {
1067         .name = "wlan",
1068 };
1069
1070 struct net_device *rtw_init_netdev(_adapter *old_padapter)
1071 {
1072         _adapter *padapter;
1073         struct net_device *pnetdev;
1074
1075         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+init_net_dev\n"));
1076
1077         if(old_padapter != NULL)
1078                 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(_adapter), (void *)old_padapter);
1079         else
1080                 pnetdev = rtw_alloc_etherdev(sizeof(_adapter));
1081
1082         if (!pnetdev)
1083                 return NULL;
1084
1085         pnetdev->dev.type = &wlan_type;
1086         padapter = rtw_netdev_priv(pnetdev);
1087         padapter->pnetdev = pnetdev;
1088
1089 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1090         SET_MODULE_OWNER(pnetdev);
1091 #endif
1092
1093         //pnetdev->init = NULL;
1094
1095 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1096         DBG_871X("register rtw_netdev_ops to netdev_ops\n");
1097         pnetdev->netdev_ops = &rtw_netdev_ops;
1098 #else
1099         pnetdev->open = netdev_open;
1100         pnetdev->stop = netdev_close;
1101         pnetdev->hard_start_xmit = rtw_xmit_entry;
1102         pnetdev->set_mac_address = rtw_net_set_mac_address;
1103         pnetdev->get_stats = rtw_net_get_stats;
1104         pnetdev->do_ioctl = rtw_ioctl;
1105 #endif
1106
1107
1108 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
1109         pnetdev->features |= NETIF_F_IP_CSUM;
1110 #endif
1111         //pnetdev->tx_timeout = NULL;
1112         pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */
1113 #ifdef CONFIG_WIRELESS_EXT
1114         pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
1115 #endif
1116
1117 #ifdef WIRELESS_SPY
1118         //priv->wireless_data.spy_data = &priv->spy_data;
1119         //pnetdev->wireless_data = &priv->wireless_data;
1120 #endif
1121
1122         //step 2.
1123         loadparam(padapter, pnetdev);
1124
1125         return pnetdev;
1126
1127 }
1128
1129 void rtw_unregister_netdevs(struct dvobj_priv *dvobj)
1130 {
1131         int i;
1132         _adapter *padapter = NULL;
1133
1134         for (i=0;i<dvobj->iface_nums;i++) {
1135                 struct net_device *pnetdev = NULL;
1136
1137                 padapter = dvobj->padapters[i];
1138
1139                 if (padapter == NULL)
1140                         continue;
1141
1142                 pnetdev = padapter->pnetdev;
1143
1144                 if((padapter->DriverState != DRIVER_DISAPPEAR) && pnetdev) {
1145                         unregister_netdev(pnetdev); //will call netdev_close()
1146                         rtw_proc_remove_one(pnetdev);
1147                 }
1148
1149                 #ifdef CONFIG_IOCTL_CFG80211
1150                 rtw_wdev_unregister(padapter->rtw_wdev);
1151                 #endif
1152         }
1153
1154 }
1155
1156 u32 rtw_start_drv_threads(_adapter *padapter)
1157 {
1158
1159         u32 _status = _SUCCESS;
1160
1161         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_start_drv_threads\n"));
1162 #ifdef CONFIG_XMIT_THREAD_MODE
1163         padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
1164         if(IS_ERR(padapter->xmitThread))
1165                 _status = _FAIL;
1166 #endif
1167
1168 #ifdef CONFIG_RECV_THREAD_MODE
1169         padapter->recvThread = kthread_run(rtw_recv_thread, padapter, "RTW_RECV_THREAD");
1170         if(IS_ERR(padapter->recvThread))
1171                 _status = _FAIL;
1172 #endif
1173
1174 #ifdef CONFIG_CONCURRENT_MODE
1175         if(padapter->isprimary == _TRUE)
1176 #endif //CONFIG_CONCURRENT_MODE
1177         {
1178                 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
1179                 if(IS_ERR(padapter->cmdThread))
1180                         _status = _FAIL;
1181                 else
1182                         _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); //wait for cmd_thread to run
1183         }
1184
1185
1186 #ifdef CONFIG_EVENT_THREAD_MODE
1187         padapter->evtThread = kthread_run(event_thread, padapter, "RTW_EVENT_THREAD");
1188         if(IS_ERR(padapter->evtThread))
1189                 _status = _FAIL;
1190 #endif
1191
1192         return _status;
1193
1194 }
1195
1196 void rtw_stop_drv_threads (_adapter *padapter)
1197 {
1198         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_stop_drv_threads\n"));
1199
1200 #ifdef CONFIG_CONCURRENT_MODE
1201         if(padapter->isprimary == _TRUE)
1202 #endif //CONFIG_CONCURRENT_MODE
1203         {
1204                 rtw_stop_cmd_thread(padapter);
1205         }
1206
1207 #ifdef CONFIG_EVENT_THREAD_MODE
1208         _rtw_up_sema(&padapter->evtpriv.evt_notify);
1209         if(padapter->evtThread){
1210                 _rtw_down_sema(&padapter->evtpriv.terminate_evtthread_sema);
1211         }
1212 #endif
1213
1214 #ifdef CONFIG_XMIT_THREAD_MODE
1215         // Below is to termindate tx_thread...
1216         _rtw_up_sema(&padapter->xmitpriv.xmit_sema);
1217         _rtw_down_sema(&padapter->xmitpriv.terminate_xmitthread_sema);
1218         RT_TRACE(_module_os_intfs_c_,_drv_info_,("\n drv_halt: rtw_xmit_thread can be terminated ! \n"));
1219 #endif
1220
1221 #ifdef CONFIG_RECV_THREAD_MODE
1222         // Below is to termindate rx_thread...
1223         _rtw_up_sema(&padapter->recvpriv.recv_sema);
1224         _rtw_down_sema(&padapter->recvpriv.terminate_recvthread_sema);
1225         RT_TRACE(_module_os_intfs_c_,_drv_info_,("\n drv_halt:recv_thread can be terminated! \n"));
1226 #endif
1227
1228
1229 }
1230
1231 u8 rtw_init_default_value(_adapter *padapter);
1232 u8 rtw_init_default_value(_adapter *padapter)
1233 {
1234         u8 ret  = _SUCCESS;
1235         struct registry_priv* pregistrypriv = &padapter->registrypriv;
1236         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
1237         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1238         struct security_priv *psecuritypriv = &padapter->securitypriv;
1239
1240         //xmit_priv
1241         pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
1242         pxmitpriv->vcs = pregistrypriv->vcs_type;
1243         pxmitpriv->vcs_type = pregistrypriv->vcs_type;
1244         //pxmitpriv->rts_thresh = pregistrypriv->rts_thresh;
1245         pxmitpriv->frag_len = pregistrypriv->frag_thresh;
1246
1247
1248
1249         //recv_priv
1250
1251
1252         //mlme_priv
1253         pmlmepriv->scan_interval = SCAN_INTERVAL;// 30*2 sec = 60sec
1254         pmlmepriv->scan_mode = SCAN_ACTIVE;
1255
1256         //qos_priv
1257         //pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable;
1258
1259         //ht_priv
1260 #ifdef CONFIG_80211N_HT
1261         pmlmepriv->htpriv.ampdu_enable = _FALSE;//set to disabled
1262 #endif
1263
1264         //security_priv
1265         //rtw_get_encrypt_decrypt_from_registrypriv(padapter);
1266         psecuritypriv->binstallGrpkey = _FAIL;
1267         psecuritypriv->sw_encrypt=pregistrypriv->software_encrypt;
1268         psecuritypriv->sw_decrypt=pregistrypriv->software_decrypt;
1269
1270         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; //open system
1271         psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
1272
1273         psecuritypriv->dot11PrivacyKeyIndex = 0;
1274
1275         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
1276         psecuritypriv->dot118021XGrpKeyid = 1;
1277
1278         psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
1279         psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
1280
1281
1282         //pwrctrl_priv
1283
1284
1285         //registry_priv
1286         rtw_init_registrypriv_dev_network(padapter);
1287         rtw_update_registrypriv_dev_network(padapter);
1288
1289
1290         //hal_priv
1291         rtw_hal_def_value_init(padapter);
1292
1293         //misc.
1294         padapter->bReadPortCancel = _FALSE;
1295         padapter->bWritePortCancel = _FALSE;
1296         padapter->bRxRSSIDisplay = 0;
1297         padapter->bForceWriteInitGain = 1;
1298         padapter->bNotifyChannelChange = 0;
1299 #ifdef CONFIG_P2P
1300         padapter->bShowGetP2PState = 1;
1301 #endif
1302         return ret;
1303 }
1304
1305 struct dvobj_priv *devobj_init(void)
1306 {
1307         struct dvobj_priv *pdvobj = NULL;
1308
1309         if ((pdvobj = (struct dvobj_priv*)rtw_zmalloc(sizeof(*pdvobj))) == NULL)
1310                 return NULL;
1311
1312         _rtw_mutex_init(&pdvobj->hw_init_mutex);
1313         _rtw_mutex_init(&pdvobj->h2c_fwcmd_mutex);
1314         _rtw_mutex_init(&pdvobj->setch_mutex);
1315         _rtw_mutex_init(&pdvobj->setbw_mutex);
1316
1317         pdvobj->processing_dev_remove = _FALSE;
1318
1319         return pdvobj;
1320 }
1321
1322 void devobj_deinit(struct dvobj_priv *pdvobj)
1323 {
1324         if(!pdvobj)
1325                 return;
1326
1327         _rtw_mutex_free(&pdvobj->hw_init_mutex);
1328         _rtw_mutex_free(&pdvobj->h2c_fwcmd_mutex);
1329         _rtw_mutex_free(&pdvobj->setch_mutex);
1330         _rtw_mutex_free(&pdvobj->setbw_mutex);
1331
1332         rtw_mfree((u8*)pdvobj, sizeof(*pdvobj));
1333 }
1334
1335 u8 rtw_reset_drv_sw(_adapter *padapter)
1336 {
1337         u8      ret8=_SUCCESS;
1338         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1339         struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
1340
1341         //hal_priv
1342         rtw_hal_def_value_init(padapter);
1343         padapter->bReadPortCancel = _FALSE;
1344         padapter->bWritePortCancel = _FALSE;
1345         padapter->bRxRSSIDisplay = 0;
1346         pmlmepriv->scan_interval = SCAN_INTERVAL;// 30*2 sec = 60sec
1347
1348         pwrctrlpriv->bips_processing = _FALSE;
1349         pwrctrlpriv->rf_pwrstate = rf_on;
1350
1351         padapter->xmitpriv.tx_pkts = 0;
1352         padapter->recvpriv.rx_pkts = 0;
1353
1354         pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
1355
1356         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY |_FW_UNDER_LINKING);
1357
1358 #ifdef CONFIG_AUTOSUSPEND
1359         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,22) && LINUX_VERSION_CODE<=KERNEL_VERSION(2,6,34))
1360                 adapter_to_dvobj(padapter)->pusbdev->autosuspend_disabled = 1;//autosuspend disabled by the user
1361         #endif
1362 #endif
1363
1364 #ifdef DBG_CONFIG_ERROR_DETECT
1365         rtw_hal_sreset_reset_value(padapter);
1366 #endif
1367         pwrctrlpriv->pwr_state_check_cnts = 0;
1368
1369         //mlmeextpriv
1370         padapter->mlmeextpriv.sitesurvey_res.state= SCAN_DISABLE;
1371
1372 #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
1373         rtw_set_signal_stat_timer(&padapter->recvpriv);
1374 #endif
1375
1376         return ret8;
1377 }
1378
1379
1380 u8 rtw_init_drv_sw(_adapter *padapter)
1381 {
1382
1383         u8      ret8=_SUCCESS;
1384
1385 _func_enter_;
1386
1387         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_init_drv_sw\n"));
1388
1389         if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL)
1390         {
1391                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init cmd_priv\n"));
1392                 ret8=_FAIL;
1393                 goto exit;
1394         }
1395
1396         padapter->cmdpriv.padapter=padapter;
1397
1398         if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL)
1399         {
1400                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init evt_priv\n"));
1401                 ret8=_FAIL;
1402                 goto exit;
1403         }
1404
1405
1406         if (rtw_init_mlme_priv(padapter) == _FAIL)
1407         {
1408                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init mlme_priv\n"));
1409                 ret8=_FAIL;
1410                 goto exit;
1411         }
1412
1413 #ifdef CONFIG_P2P
1414         rtw_init_wifidirect_timers(padapter);
1415         init_wifidirect_info(padapter, P2P_ROLE_DISABLE);
1416         reset_global_wifidirect_info(padapter);
1417         #ifdef CONFIG_IOCTL_CFG80211
1418         rtw_init_cfg80211_wifidirect_info(padapter);
1419         #endif
1420 #ifdef CONFIG_WFD
1421         if(rtw_init_wifi_display_info(padapter) == _FAIL)
1422                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init init_wifi_display_info\n"));
1423 #endif
1424 #endif /* CONFIG_P2P */
1425
1426         if(init_mlme_ext_priv(padapter) == _FAIL)
1427         {
1428                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't init mlme_ext_priv\n"));
1429                 ret8=_FAIL;
1430                 goto exit;
1431         }
1432
1433 #ifdef CONFIG_TDLS
1434         if(rtw_init_tdls_info(padapter) == _FAIL)
1435         {
1436                 DBG_871X("Can't rtw_init_tdls_info\n");
1437                 ret8=_FAIL;
1438                 goto exit;
1439         }
1440 #endif //CONFIG_TDLS
1441
1442         if(_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL)
1443         {
1444                 DBG_871X("Can't _rtw_init_xmit_priv\n");
1445                 ret8=_FAIL;
1446                 goto exit;
1447         }
1448
1449         if(_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL)
1450         {
1451                 DBG_871X("Can't _rtw_init_recv_priv\n");
1452                 ret8=_FAIL;
1453                 goto exit;
1454         }
1455         // add for CONFIG_IEEE80211W, none 11w also can use
1456         _rtw_spinlock_init(&padapter->security_key_mutex);
1457
1458         // We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc().
1459         //_rtw_memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv));
1460
1461         //_init_timer(&(padapter->securitypriv.tkip_timer), padapter->pifp, rtw_use_tkipkey_handler, padapter);
1462
1463         if(_rtw_init_sta_priv(&padapter->stapriv) == _FAIL)
1464         {
1465                 DBG_871X("Can't _rtw_init_sta_priv\n");
1466                 ret8=_FAIL;
1467                 goto exit;
1468         }
1469
1470         padapter->stapriv.padapter = padapter;
1471         padapter->setband = GHZ24_50;
1472         rtw_init_bcmc_stainfo(padapter);
1473
1474         rtw_init_pwrctrl_priv(padapter);
1475
1476         //_rtw_memset((u8 *)&padapter->qospriv, 0, sizeof (struct qos_priv));//move to mlme_priv
1477
1478 #ifdef CONFIG_MP_INCLUDED
1479         if (init_mp_priv(padapter) == _FAIL) {
1480                 DBG_871X("%s: initialize MP private data Fail!\n", __func__);
1481         }
1482 #endif
1483
1484         ret8 = rtw_init_default_value(padapter);
1485
1486         rtw_hal_dm_init(padapter);
1487         rtw_hal_sw_led_init(padapter);
1488
1489 #ifdef DBG_CONFIG_ERROR_DETECT
1490         rtw_hal_sreset_init(padapter);
1491 #endif
1492
1493 #ifdef CONFIG_INTEL_WIDI
1494         if(rtw_init_intel_widi(padapter) == _FAIL)
1495         {
1496                 DBG_871X("Can't rtw_init_intel_widi\n");
1497                 ret8=_FAIL;
1498                 goto exit;
1499         }
1500 #endif //CONFIG_INTEL_WIDI
1501
1502 #ifdef CONFIG_BR_EXT
1503         _rtw_spinlock_init(&padapter->br_ext_lock);
1504 #endif  // CONFIG_BR_EXT
1505
1506 exit:
1507
1508         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-rtw_init_drv_sw\n"));
1509
1510         _func_exit_;
1511
1512         return ret8;
1513
1514 }
1515
1516 void rtw_cancel_all_timer(_adapter *padapter)
1517 {
1518         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_cancel_all_timer\n"));
1519
1520         _cancel_timer_ex(&padapter->mlmepriv.assoc_timer);
1521         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel association timer complete! \n"));
1522
1523         //_cancel_timer_ex(&padapter->securitypriv.tkip_timer);
1524         //RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel tkip_timer! \n"));
1525
1526         _cancel_timer_ex(&padapter->mlmepriv.scan_to_timer);
1527         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel scan_to_timer! \n"));
1528
1529         _cancel_timer_ex(&padapter->mlmepriv.dynamic_chk_timer);
1530         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel dynamic_chk_timer! \n"));
1531
1532         // cancel sw led timer
1533         rtw_hal_sw_led_deinit(padapter);
1534         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel DeInitSwLeds! \n"));
1535
1536         _cancel_timer_ex(&padapter->pwrctrlpriv.pwr_state_check_timer);
1537
1538 #ifdef CONFIG_IOCTL_CFG80211
1539 #ifdef CONFIG_P2P
1540         _cancel_timer_ex(&padapter->cfg80211_wdinfo.remain_on_ch_timer);
1541 #endif //CONFIG_P2P
1542 #endif //CONFIG_IOCTL_CFG80211
1543
1544 #ifdef CONFIG_SET_SCAN_DENY_TIMER
1545         _cancel_timer_ex(&padapter->mlmepriv.set_scan_deny_timer);
1546         rtw_clear_scan_deny(padapter);
1547         RT_TRACE(_module_os_intfs_c_,_drv_info_,("rtw_cancel_all_timer:cancel set_scan_deny_timer! \n"));
1548 #endif
1549
1550 #ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
1551         _cancel_timer_ex(&padapter->recvpriv.signal_stat_timer);
1552 #endif
1553
1554         // cancel dm  timer
1555         rtw_hal_dm_deinit(padapter);
1556
1557 #ifdef CONFIG_PLATFORM_FS_MX61
1558         msleep(50);
1559 #endif
1560 }
1561
1562 u8 rtw_free_drv_sw(_adapter *padapter)
1563 {
1564         RT_TRACE(_module_os_intfs_c_,_drv_info_,("==>rtw_free_drv_sw"));
1565
1566
1567         //we can call rtw_p2p_enable here, but:
1568         // 1. rtw_p2p_enable may have IO operation
1569         // 2. rtw_p2p_enable is bundled with wext interface
1570         #ifdef CONFIG_P2P
1571         {
1572                 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
1573                 if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1574                 {
1575                         _cancel_timer_ex( &pwdinfo->find_phase_timer );
1576                         _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
1577                         _cancel_timer_ex( &pwdinfo->pre_tx_scan_timer);
1578 #ifdef CONFIG_CONCURRENT_MODE
1579                         _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer );
1580 #endif // CONFIG_CONCURRENT_MODE
1581                         rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
1582                 }
1583         }
1584         #endif
1585         // add for CONFIG_IEEE80211W, none 11w also can use
1586         _rtw_spinlock_free(&padapter->security_key_mutex);
1587
1588 #ifdef CONFIG_BR_EXT
1589         _rtw_spinlock_free(&padapter->br_ext_lock);
1590 #endif  // CONFIG_BR_EXT
1591
1592 #ifdef CONFIG_INTEL_WIDI
1593         rtw_free_intel_widi(padapter);
1594 #endif //CONFIG_INTEL_WIDI
1595
1596         free_mlme_ext_priv(&padapter->mlmeextpriv);
1597
1598 #ifdef CONFIG_TDLS
1599         //rtw_free_tdls_info(&padapter->tdlsinfo);
1600 #endif //CONFIG_TDLS
1601
1602         rtw_free_cmd_priv(&padapter->cmdpriv);
1603
1604         rtw_free_evt_priv(&padapter->evtpriv);
1605
1606         rtw_free_mlme_priv(&padapter->mlmepriv);
1607
1608         //free_io_queue(padapter);
1609
1610         _rtw_free_xmit_priv(&padapter->xmitpriv);
1611
1612         _rtw_free_sta_priv(&padapter->stapriv); //will free bcmc_stainfo here
1613
1614         _rtw_free_recv_priv(&padapter->recvpriv);
1615
1616         rtw_free_pwrctrl_priv(padapter);
1617
1618         //rtw_mfree((void *)padapter, sizeof (padapter));
1619
1620 #ifdef CONFIG_DRVEXT_MODULE
1621         free_drvext(&padapter->drvextpriv);
1622 #endif
1623
1624         rtw_hal_free_data(padapter);
1625
1626         RT_TRACE(_module_os_intfs_c_,_drv_info_,("<==rtw_free_drv_sw\n"));
1627
1628         //free the old_pnetdev
1629         if(padapter->rereg_nd_name_priv.old_pnetdev) {
1630                 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
1631                 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
1632         }
1633
1634         // clear pbuddy_adapter to avoid access wrong pointer.
1635         if(padapter->pbuddy_adapter != NULL)
1636         {
1637                 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
1638         }
1639
1640         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-rtw_free_drv_sw\n"));
1641
1642         return _SUCCESS;
1643
1644 }
1645
1646 #ifdef CONFIG_CONCURRENT_MODE
1647
1648 #ifdef CONFIG_USB_HCI
1649         #include <usb_hal.h>
1650 #endif
1651
1652 #ifdef CONFIG_MULTI_VIR_IFACES
1653 int _netdev_vir_if_open(struct net_device *pnetdev)
1654 {
1655         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1656         _adapter *primary_padapter = GET_PRIMARY_ADAPTER(padapter);
1657
1658         DBG_871X(FUNC_NDEV_FMT" enter\n", FUNC_NDEV_ARG(pnetdev));
1659
1660         if(!primary_padapter)
1661                 goto _netdev_virtual_iface_open_error;
1662
1663         if(primary_padapter->bup == _FALSE || primary_padapter->hw_init_completed == _FALSE)
1664         {
1665                 _netdev_open(primary_padapter->pnetdev);
1666         }
1667
1668         if(padapter->bup == _FALSE && primary_padapter->bup == _TRUE &&
1669                 primary_padapter->hw_init_completed == _TRUE)
1670         {
1671                 int i;
1672
1673                 padapter->bDriverStopped = _FALSE;
1674                 padapter->bSurpriseRemoved = _FALSE;
1675                 padapter->bCardDisableWOHSM = _FALSE;
1676
1677                 _rtw_memcpy(padapter->HalData, primary_padapter->HalData, padapter->hal_data_sz);
1678
1679                 padapter->bFWReady = primary_padapter->bFWReady;
1680
1681                 if(rtw_start_drv_threads(padapter) == _FAIL)
1682                 {
1683                         goto _netdev_virtual_iface_open_error;
1684                 }
1685
1686                 padapter->dir_dev = NULL;
1687                 rtw_proc_init_one(pnetdev);
1688
1689 #ifdef CONFIG_IOCTL_CFG80211
1690                 rtw_cfg80211_init_wiphy(padapter);
1691 #endif
1692
1693                 padapter->bup = _TRUE;
1694                 padapter->hw_init_completed = _TRUE;
1695         }
1696
1697         padapter->net_closed = _FALSE;
1698
1699         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
1700
1701         if(!rtw_netif_queue_stopped(pnetdev))
1702                 rtw_netif_start_queue(pnetdev);
1703         else
1704                 rtw_netif_wake_queue(pnetdev);
1705
1706
1707         DBG_871X(FUNC_NDEV_FMT" exit\n", FUNC_NDEV_ARG(pnetdev));
1708         return 0;
1709
1710 _netdev_virtual_iface_open_error:
1711
1712         padapter->bup = _FALSE;
1713
1714         netif_carrier_off(pnetdev);
1715         rtw_netif_stop_queue(pnetdev);
1716
1717         return (-1);
1718
1719 }
1720
1721 int netdev_vir_if_open(struct net_device *pnetdev)
1722 {
1723         int ret;
1724         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1725
1726         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
1727         ret = _netdev_vir_if_open(pnetdev);
1728         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
1729         return ret;
1730 }
1731
1732 static int netdev_vir_if_close(struct net_device *pnetdev)
1733 {
1734         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
1735
1736         padapter->net_closed = _TRUE;
1737
1738         if(pnetdev)
1739         {
1740                 if (!rtw_netif_queue_stopped(pnetdev))
1741                         rtw_netif_stop_queue(pnetdev);
1742         }
1743
1744 #ifdef CONFIG_IOCTL_CFG80211
1745         rtw_scan_abort(padapter);
1746         wdev_to_priv(padapter->rtw_wdev)->bandroid_scan = _FALSE;
1747 #endif
1748
1749         return 0;
1750 }
1751
1752 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1753 static const struct net_device_ops rtw_netdev_vir_if_ops = {
1754          .ndo_open = netdev_vir_if_open,
1755         .ndo_stop = netdev_vir_if_close,
1756         .ndo_start_xmit = rtw_xmit_entry,
1757         .ndo_set_mac_address = rtw_net_set_mac_address,
1758         .ndo_get_stats = rtw_net_get_stats,
1759         .ndo_do_ioctl = rtw_ioctl,
1760 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1761         .ndo_select_queue       = rtw_select_queue,
1762 #endif
1763 };
1764 #endif
1765
1766 _adapter *rtw_drv_add_vir_if(_adapter *primary_padapter, void (*set_intf_ops)(struct _io_ops *pops))
1767 {
1768
1769         int res = _FAIL;
1770         struct net_device *pnetdev=NULL;
1771         _adapter *padapter = NULL;
1772         struct dvobj_priv *pdvobjpriv;
1773         u8 mac[ETH_ALEN];
1774
1775 /*
1776         if((primary_padapter->bup == _FALSE) ||
1777                 (rtw_buddy_adapter_up(primary_padapter) == _FALSE))
1778         {
1779                 goto error_rtw_drv_add_iface;
1780         }
1781
1782 */
1783         /****** init netdev ******/
1784         pnetdev = rtw_init_netdev(NULL);
1785         if (!pnetdev)
1786                 goto error_rtw_drv_add_iface;
1787
1788 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
1789         DBG_871X("register rtw_netdev_virtual_iface_ops to netdev_ops\n");
1790         pnetdev->netdev_ops = &rtw_netdev_vir_if_ops;
1791 #else
1792         pnetdev->open = netdev_vir_if_open;
1793         pnetdev->stop = netdev_vir_if_close;
1794 #endif
1795
1796 #ifdef CONFIG_NO_WIRELESS_HANDLERS
1797         pnetdev->wireless_handlers = NULL;
1798 #endif
1799
1800         /****** init adapter ******/
1801         padapter = rtw_netdev_priv(pnetdev);
1802         _rtw_memcpy(padapter, primary_padapter, sizeof(_adapter));
1803
1804         //
1805         padapter->bup = _FALSE;
1806         padapter->net_closed = _TRUE;
1807         padapter->hw_init_completed = _FALSE;
1808
1809
1810         //set adapter_type/iface type
1811         padapter->isprimary = _FALSE;
1812         padapter->adapter_type = MAX_ADAPTER;
1813         padapter->pbuddy_adapter = primary_padapter;
1814 #if 0
1815 #ifndef CONFIG_HWPORT_SWAP      //Port0 -> Pri , Port1 -> Sec
1816         padapter->iface_type = IFACE_PORT1;
1817 #else
1818         padapter->iface_type = IFACE_PORT0;
1819 #endif  //CONFIG_HWPORT_SWAP
1820 #else
1821         //extended virtual interfaces always are set to port0
1822         padapter->iface_type = IFACE_PORT0;
1823 #endif
1824         //
1825         padapter->pnetdev = pnetdev;
1826
1827         /****** setup dvobj ******/
1828         pdvobjpriv = adapter_to_dvobj(padapter);
1829         padapter->iface_id = pdvobjpriv->iface_nums;
1830         pdvobjpriv->padapters[pdvobjpriv->iface_nums++] = padapter;
1831
1832         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(pdvobjpriv));
1833 #ifdef CONFIG_IOCTL_CFG80211
1834         rtw_wdev_alloc(padapter, dvobj_to_dev(pdvobjpriv));
1835 #endif //CONFIG_IOCTL_CFG80211
1836
1837         //set interface_type/chip_type/HardwareType
1838         padapter->interface_type = primary_padapter->interface_type;
1839         padapter->chip_type = primary_padapter->chip_type;
1840         padapter->HardwareType = primary_padapter->HardwareType;
1841
1842         //set hal data & hal ops
1843 #if defined(CONFIG_RTL8192C)
1844         #if defined(CONFIG_PCI_HCI)
1845                 rtl8192ce_set_hal_ops(padapter);
1846         #elif defined(CONFIG_USB_HCI)
1847                 rtl8192cu_set_hal_ops(padapter);
1848         #endif
1849 #elif defined(CONFIG_RTL8192D)
1850         #if defined(CONFIG_PCI_HCI)
1851                 rtl8192de_set_hal_ops(padapter);
1852         #elif defined(CONFIG_USB_HCI)
1853                 rtl8192du_set_hal_ops(padapter);
1854         #endif
1855 #endif
1856
1857         padapter->HalFunc.inirp_init = NULL;
1858         padapter->HalFunc.inirp_deinit = NULL;
1859         padapter->intf_start = NULL;
1860         padapter->intf_stop = NULL;
1861
1862         //step init_io_priv
1863         if ((rtw_init_io_priv(padapter, set_intf_ops)) == _FAIL) {
1864                 RT_TRACE(_module_hci_intfs_c_,_drv_err_,(" \n Can't init io_reqs\n"));
1865         }
1866
1867         //step read_chip_version
1868         rtw_hal_read_chip_version(padapter);
1869
1870         //step usb endpoint mapping
1871         rtw_hal_chip_configure(padapter);
1872
1873
1874         //init drv data
1875         if(rtw_init_drv_sw(padapter)!= _SUCCESS)
1876                 goto error_rtw_drv_add_iface;
1877
1878
1879         //get mac address from primary_padapter
1880         _rtw_memcpy(mac, primary_padapter->eeprompriv.mac_addr, ETH_ALEN);
1881
1882         if (((mac[0]==0xff) &&(mac[1]==0xff) && (mac[2]==0xff) &&
1883              (mac[3]==0xff) && (mac[4]==0xff) &&(mac[5]==0xff)) ||
1884             ((mac[0]==0x0) && (mac[1]==0x0) && (mac[2]==0x0) &&
1885              (mac[3]==0x0) && (mac[4]==0x0) &&(mac[5]==0x0)))
1886         {
1887                 mac[0] = 0x00;
1888                 mac[1] = 0xe0;
1889                 mac[2] = 0x4c;
1890                 mac[3] = 0x87;
1891                 mac[4] = 0x11;
1892                 mac[5] = 0x22;
1893         }
1894         else
1895         {
1896                 //If the BIT1 is 0, the address is universally administered.
1897                 //If it is 1, the address is locally administered
1898 #if 1 //needs enable MBSSID CAM
1899                 mac[0] |= BIT(1); // locally administered
1900                 mac[0] |= (padapter->iface_id-1)<<4;
1901 #endif
1902         }
1903
1904         _rtw_memcpy(padapter->eeprompriv.mac_addr, mac, ETH_ALEN);
1905
1906         padapter->dir_dev = NULL;
1907
1908         res = _SUCCESS;
1909
1910         return padapter;
1911
1912
1913 error_rtw_drv_add_iface:
1914
1915         if(padapter)
1916                 rtw_free_drv_sw(padapter);
1917
1918         if (pnetdev)
1919                 rtw_free_netdev(pnetdev);
1920
1921         return NULL;
1922
1923 }
1924
1925 void rtw_drv_stop_vir_if(_adapter *padapter)
1926 {
1927         struct net_device *pnetdev=NULL;
1928
1929         if (padapter == NULL)
1930                 return;
1931
1932         pnetdev = padapter->pnetdev;
1933
1934         rtw_cancel_all_timer(padapter);
1935
1936         if(padapter->bup == _TRUE)
1937         {
1938                 padapter->bDriverStopped = _TRUE;
1939
1940                 #ifdef CONFIG_XMIT_ACK
1941                 if (padapter->xmitpriv.ack_tx)
1942                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
1943                 #endif
1944
1945                 if(padapter->intf_stop)
1946                 {
1947                         padapter->intf_stop(padapter);
1948                 }
1949
1950                 rtw_stop_drv_threads(padapter);
1951
1952                 padapter->bup = _FALSE;
1953         }
1954 }
1955
1956 void rtw_drv_free_vir_if(_adapter *padapter)
1957 {
1958         struct net_device *pnetdev=NULL;
1959
1960         if (padapter == NULL)
1961                 return;
1962
1963         padapter->pbuddy_adapter = NULL;
1964
1965         pnetdev = padapter->pnetdev;
1966
1967 #ifdef CONFIG_IOCTL_CFG80211
1968         rtw_wdev_free(padapter->rtw_wdev);
1969 #endif //CONFIG_IOCTL_CFG80211
1970
1971         rtw_free_drv_sw(padapter);
1972
1973         rtw_free_netdev(pnetdev);
1974 }
1975
1976 void rtw_drv_stop_vir_ifaces(struct dvobj_priv *dvobj)
1977 {
1978         int i;
1979         //struct dvobj_priv *dvobj = primary_padapter->dvobj;
1980
1981         for(i=2;i<dvobj->iface_nums;i++)
1982         {
1983                 rtw_drv_stop_vir_if(dvobj->padapters[i]);
1984         }
1985 }
1986
1987 void rtw_drv_free_vir_ifaces(struct dvobj_priv *dvobj)
1988 {
1989         int i;
1990         //struct dvobj_priv *dvobj = primary_padapter->dvobj;
1991
1992         for(i=2;i<dvobj->iface_nums;i++)
1993         {
1994                 rtw_drv_free_vir_if(dvobj->padapters[i]);
1995         }
1996 }
1997
1998 void rtw_drv_del_vir_if(_adapter *padapter)
1999 {
2000         rtw_drv_stop_vir_if(padapter);
2001         rtw_drv_free_vir_if(padapter);
2002 }
2003
2004 void rtw_drv_del_vir_ifaces(_adapter *primary_padapter)
2005 {
2006         int i;
2007         struct dvobj_priv *dvobj = primary_padapter->dvobj;
2008
2009         for(i=2;i<dvobj->iface_nums;i++)
2010         {
2011                 rtw_drv_del_vir_if(dvobj->padapters[i]);
2012         }
2013 }
2014 #endif //CONFIG_MULTI_VIR_IFACES
2015
2016 int _netdev_if2_open(struct net_device *pnetdev)
2017 {
2018         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2019         _adapter *primary_padapter = padapter->pbuddy_adapter;
2020
2021         DBG_871X("+871x_drv - if2_open, bup=%d\n", padapter->bup);
2022
2023         if(primary_padapter->bup == _FALSE || primary_padapter->hw_init_completed == _FALSE)
2024         {
2025                 _netdev_open(primary_padapter->pnetdev);
2026         }
2027
2028         if(padapter->bup == _FALSE && primary_padapter->bup == _TRUE &&
2029                 primary_padapter->hw_init_completed == _TRUE)
2030         {
2031                 int i;
2032
2033                 padapter->bDriverStopped = _FALSE;
2034                 padapter->bSurpriseRemoved = _FALSE;
2035                 padapter->bCardDisableWOHSM = _FALSE;
2036
2037                 _rtw_memcpy(padapter->HalData, primary_padapter->HalData, padapter->hal_data_sz);
2038
2039                 padapter->bFWReady = primary_padapter->bFWReady;
2040
2041                 rtw_hal_set_hwreg(padapter, HW_VAR_DM_INIT_PWDB, NULL);
2042
2043                 //if (init_mlme_ext_priv(padapter) == _FAIL)
2044                 //      goto netdev_if2_open_error;
2045
2046
2047                 if(rtw_start_drv_threads(padapter) == _FAIL)
2048                 {
2049                         goto netdev_if2_open_error;
2050                 }
2051
2052
2053                 if(padapter->intf_start)
2054                 {
2055                         padapter->intf_start(padapter);
2056                 }
2057
2058
2059                 padapter->hw_init_completed = _TRUE;
2060
2061                 padapter->dir_dev = NULL;
2062                 rtw_proc_init_one(pnetdev);
2063
2064
2065 #ifdef CONFIG_IOCTL_CFG80211
2066                 rtw_cfg80211_init_wiphy(padapter);
2067 #endif
2068
2069                 padapter->bup = _TRUE;
2070
2071         }
2072
2073         padapter->net_closed = _FALSE;
2074
2075         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
2076
2077         if(!rtw_netif_queue_stopped(pnetdev))
2078                 rtw_netif_start_queue(pnetdev);
2079         else
2080                 rtw_netif_wake_queue(pnetdev);
2081
2082         DBG_871X("-871x_drv - if2_open, bup=%d\n", padapter->bup);
2083         return 0;
2084
2085 netdev_if2_open_error:
2086
2087         padapter->bup = _FALSE;
2088
2089         netif_carrier_off(pnetdev);
2090         rtw_netif_stop_queue(pnetdev);
2091
2092         return (-1);
2093
2094 }
2095
2096 int netdev_if2_open(struct net_device *pnetdev)
2097 {
2098         int ret;
2099         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2100
2101         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2102         ret = _netdev_if2_open(pnetdev);
2103         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2104         return ret;
2105 }
2106
2107 static int netdev_if2_close(struct net_device *pnetdev)
2108 {
2109         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2110
2111         padapter->net_closed = _TRUE;
2112
2113         if(pnetdev)
2114         {
2115                 if (!rtw_netif_queue_stopped(pnetdev))
2116                         rtw_netif_stop_queue(pnetdev);
2117         }
2118
2119 #ifdef CONFIG_IOCTL_CFG80211
2120         rtw_scan_abort(padapter);
2121         wdev_to_priv(padapter->rtw_wdev)->bandroid_scan = _FALSE;
2122 #endif
2123
2124         return 0;
2125 }
2126
2127 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
2128 static const struct net_device_ops rtw_netdev_if2_ops = {
2129         .ndo_open = netdev_if2_open,
2130         .ndo_stop = netdev_if2_close,
2131         .ndo_start_xmit = rtw_xmit_entry,
2132         .ndo_set_mac_address = rtw_net_set_mac_address,
2133         .ndo_get_stats = rtw_net_get_stats,
2134         .ndo_do_ioctl = rtw_ioctl,
2135 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
2136         .ndo_select_queue       = rtw_select_queue,
2137 #endif
2138 };
2139 #endif
2140
2141 _adapter *rtw_drv_if2_init(_adapter *primary_padapter, void (*set_intf_ops)(struct _io_ops *pops))
2142 {
2143         int res = _FAIL;
2144         struct net_device *pnetdev =  NULL;
2145         _adapter *padapter = NULL;
2146         struct dvobj_priv *pdvobjpriv;
2147         u8 mac[ETH_ALEN];
2148
2149         /****** init netdev ******/
2150         pnetdev = rtw_init_netdev(NULL);
2151         if (!pnetdev)
2152                 goto error_rtw_drv_if2_init;
2153
2154 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,29))
2155         DBG_871X("register rtw_netdev_if2_ops to netdev_ops\n");
2156         pnetdev->netdev_ops = &rtw_netdev_if2_ops;
2157 #else
2158         pnetdev->open = netdev_if2_open;
2159         pnetdev->stop = netdev_if2_close;
2160 #endif
2161
2162 #ifdef CONFIG_NO_WIRELESS_HANDLERS
2163         pnetdev->wireless_handlers = NULL;
2164 #endif
2165
2166         /****** init adapter ******/
2167         padapter = rtw_netdev_priv(pnetdev);
2168         _rtw_memcpy(padapter, primary_padapter, sizeof(_adapter));
2169
2170         //
2171         padapter->bup = _FALSE;
2172         padapter->net_closed = _TRUE;
2173         padapter->hw_init_completed = _FALSE;
2174
2175         //set adapter_type/iface type
2176         padapter->isprimary = _FALSE;
2177         padapter->adapter_type = SECONDARY_ADAPTER;
2178         padapter->pbuddy_adapter = primary_padapter;
2179         padapter->iface_id = IFACE_ID1;
2180 #ifndef CONFIG_HWPORT_SWAP                      //Port0 -> Pri , Port1 -> Sec
2181         padapter->iface_type = IFACE_PORT1;
2182 #else
2183         padapter->iface_type = IFACE_PORT0;
2184 #endif  //CONFIG_HWPORT_SWAP
2185         //
2186         padapter->pnetdev = pnetdev;
2187
2188         /****** setup dvobj ******/
2189         pdvobjpriv = adapter_to_dvobj(padapter);
2190         pdvobjpriv->if2 = padapter;
2191         pdvobjpriv->padapters[pdvobjpriv->iface_nums++] = padapter;
2192
2193         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(pdvobjpriv));
2194         #ifdef CONFIG_IOCTL_CFG80211
2195         rtw_wdev_alloc(padapter, dvobj_to_dev(pdvobjpriv));
2196         #endif //CONFIG_IOCTL_CFG80211
2197
2198         //set interface_type/chip_type/HardwareType
2199         padapter->interface_type = primary_padapter->interface_type;
2200         padapter->chip_type = primary_padapter->chip_type;
2201         padapter->HardwareType = primary_padapter->HardwareType;
2202
2203         //set hal data & hal ops
2204 #if defined(CONFIG_RTL8192C)
2205         #if defined(CONFIG_PCI_HCI)
2206                 rtl8192ce_set_hal_ops(padapter);
2207         #elif defined(CONFIG_USB_HCI)
2208                 rtl8192cu_set_hal_ops(padapter);
2209         #endif
2210 #elif defined(CONFIG_RTL8192D)
2211         #if defined(CONFIG_PCI_HCI)
2212                 rtl8192de_set_hal_ops(padapter);
2213         #elif defined(CONFIG_USB_HCI)
2214                 rtl8192du_set_hal_ops(padapter);
2215         #endif
2216 #endif
2217
2218         padapter->HalFunc.inirp_init = NULL;
2219         padapter->HalFunc.inirp_deinit = NULL;
2220
2221         //
2222         padapter->intf_start = primary_padapter->intf_start;
2223         padapter->intf_stop = primary_padapter->intf_stop;
2224
2225         //step init_io_priv
2226         if ((rtw_init_io_priv(padapter, set_intf_ops)) == _FAIL) {
2227                 RT_TRACE(_module_hci_intfs_c_,_drv_err_,(" \n Can't init io_reqs\n"));
2228         }
2229
2230         //step read_chip_version
2231         rtw_hal_read_chip_version(padapter);
2232
2233         //step usb endpoint mapping
2234         rtw_hal_chip_configure(padapter);
2235
2236
2237         //init drv data
2238         if(rtw_init_drv_sw(padapter)!= _SUCCESS)
2239                 goto error_rtw_drv_if2_init;
2240
2241         //get mac address from primary_padapter
2242         _rtw_memcpy(mac, primary_padapter->eeprompriv.mac_addr, ETH_ALEN);
2243
2244         if (((mac[0]==0xff) &&(mac[1]==0xff) && (mac[2]==0xff) &&
2245              (mac[3]==0xff) && (mac[4]==0xff) &&(mac[5]==0xff)) ||
2246             ((mac[0]==0x0) && (mac[1]==0x0) && (mac[2]==0x0) &&
2247              (mac[3]==0x0) && (mac[4]==0x0) &&(mac[5]==0x0)))
2248         {
2249                 mac[0] = 0x00;
2250                 mac[1] = 0xe0;
2251                 mac[2] = 0x4c;
2252                 mac[3] = 0x87;
2253                 mac[4] = 0x11;
2254                 mac[5] = 0x22;
2255         }
2256         else
2257         {
2258                 //If the BIT1 is 0, the address is universally administered.
2259                 //If it is 1, the address is locally administered
2260                 mac[0] |= BIT(1); // locally administered
2261
2262         }
2263
2264         _rtw_memcpy(padapter->eeprompriv.mac_addr, mac, ETH_ALEN);
2265         rtw_init_wifidirect_addrs(padapter, padapter->eeprompriv.mac_addr, padapter->eeprompriv.mac_addr);
2266
2267         primary_padapter->pbuddy_adapter = padapter;
2268
2269         padapter->dir_dev = NULL;
2270
2271         res = _SUCCESS;
2272
2273         return padapter;
2274
2275
2276 error_rtw_drv_if2_init:
2277
2278         if(padapter)
2279                 rtw_free_drv_sw(padapter);
2280
2281         if (pnetdev)
2282                 rtw_free_netdev(pnetdev);
2283
2284         return NULL;
2285
2286 }
2287
2288 void rtw_drv_if2_free(_adapter *if2)
2289 {
2290         _adapter *padapter = if2;
2291         struct net_device *pnetdev = NULL;
2292
2293         if (padapter == NULL)
2294                 return;
2295
2296         pnetdev = padapter->pnetdev;
2297
2298 #ifdef CONFIG_IOCTL_CFG80211
2299         rtw_wdev_free(padapter->rtw_wdev);
2300 #endif /* CONFIG_IOCTL_CFG80211 */
2301
2302
2303         rtw_free_drv_sw(padapter);
2304
2305         rtw_free_netdev(pnetdev);
2306
2307 }
2308
2309 void rtw_drv_if2_stop(_adapter *if2)
2310 {
2311         _adapter *padapter = if2;
2312
2313         if (padapter == NULL)
2314                 return;
2315
2316         rtw_cancel_all_timer(padapter);
2317
2318         if (padapter->bup == _TRUE) {
2319                 padapter->bDriverStopped = _TRUE;
2320                 #ifdef CONFIG_XMIT_ACK
2321                 if (padapter->xmitpriv.ack_tx)
2322                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
2323                 #endif
2324
2325                 if(padapter->intf_stop)
2326                 {
2327                         padapter->intf_stop(padapter);
2328                 }
2329
2330                 rtw_stop_drv_threads(padapter);
2331
2332                 padapter->bup = _FALSE;
2333         }
2334 }
2335 #endif //end of CONFIG_CONCURRENT_MODE
2336
2337 #ifdef CONFIG_BR_EXT
2338 void netdev_br_init(struct net_device *netdev)
2339 {
2340         _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
2341
2342 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2343         rcu_read_lock();
2344 #endif  // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2345
2346         //if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE)
2347         {
2348                 //struct net_bridge     *br = netdev->br_port->br;//->dev->dev_addr;
2349 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2350                 if (netdev->br_port)
2351 #else   // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2352                 if (rcu_dereference(adapter->pnetdev->rx_handler_data))
2353 #endif  // (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2354                 {
2355                         struct net_device *br_netdev;
2356 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2357                         br_netdev = dev_get_by_name(CONFIG_BR_EXT_BRNAME);
2358 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2359                         struct net *devnet = NULL;
2360
2361 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2362                         devnet = netdev->nd_net;
2363 #else   // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2364                         devnet = dev_net(netdev);
2365 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
2366
2367                         br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME);
2368 #endif  // (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
2369
2370                         if (br_netdev) {
2371                                 memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN);
2372                                 dev_put(br_netdev);
2373                         } else
2374                                 printk("%s()-%d: dev_get_by_name(%s) failed!", __FUNCTION__, __LINE__, CONFIG_BR_EXT_BRNAME);
2375                 }
2376
2377                 adapter->ethBrExtInfo.addPPPoETag = 1;
2378         }
2379
2380 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2381         rcu_read_unlock();
2382 #endif  // (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2383 }
2384 #endif //CONFIG_BR_EXT
2385
2386 static int _rtw_drv_register_netdev(_adapter *padapter, char *name)
2387 {
2388         int ret = _SUCCESS;
2389         struct net_device *pnetdev = padapter->pnetdev;
2390
2391         /* alloc netdev name */
2392         rtw_init_netdev_name(pnetdev, name);
2393
2394         _rtw_memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
2395
2396         /* Tell the network stack we exist */
2397         if (register_netdev(pnetdev) != 0) {
2398                 DBG_871X(FUNC_NDEV_FMT "Failed!\n", FUNC_NDEV_ARG(pnetdev));
2399                 ret = _FAIL;
2400                 goto error_register_netdev;
2401         }
2402
2403         DBG_871X("%s, MAC Address (if%d) = " MAC_FMT "\n", __FUNCTION__, (padapter->iface_id+1), MAC_ARG(pnetdev->dev_addr));
2404
2405         return ret;
2406
2407 error_register_netdev:
2408
2409         if(padapter->iface_id > IFACE_ID0)
2410         {
2411                 rtw_free_drv_sw(padapter);
2412
2413                 rtw_free_netdev(pnetdev);
2414         }
2415
2416         return ret;
2417 }
2418
2419 int rtw_drv_register_netdev(_adapter *if1)
2420 {
2421         int i, status = _SUCCESS;
2422         struct dvobj_priv *dvobj = if1->dvobj;
2423
2424         if(dvobj->iface_nums < IFACE_ID_MAX)
2425         {
2426                 for(i=0; i<dvobj->iface_nums; i++)
2427                 {
2428                         _adapter *padapter = dvobj->padapters[i];
2429
2430                         if(padapter)
2431                         {
2432                                 char *name;
2433
2434                                 if(padapter->iface_id == IFACE_ID0)
2435                                         name = if1->registrypriv.ifname;
2436                                 else if(padapter->iface_id == IFACE_ID1)
2437                                         name = if1->registrypriv.if2name;
2438                                 else
2439                                         name = "wlan%d";
2440
2441                                 if((status = _rtw_drv_register_netdev(padapter, name)) != _SUCCESS) {
2442                                         break;
2443                                 }
2444                         }
2445                 }
2446         }
2447
2448         return status;
2449 }
2450
2451 int _netdev_open(struct net_device *pnetdev)
2452 {
2453         uint status;
2454         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2455         struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
2456
2457         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - dev_open\n"));
2458         DBG_871X("+871x_drv - drv_open, bup=%d\n", padapter->bup);
2459
2460         if(pwrctrlpriv->ps_flag == _TRUE){
2461                 padapter->net_closed = _FALSE;
2462                 goto netdev_open_normal_process;
2463         }
2464
2465         if(padapter->bup == _FALSE)
2466         {
2467                 padapter->bDriverStopped = _FALSE;
2468                 padapter->bSurpriseRemoved = _FALSE;
2469                 padapter->bCardDisableWOHSM = _FALSE;
2470
2471                 status = rtw_hal_init(padapter);
2472                 if (status ==_FAIL)
2473                 {
2474                         RT_TRACE(_module_os_intfs_c_,_drv_err_,("rtl871x_hal_init(): Can't init h/w!\n"));
2475                         goto netdev_open_error;
2476                 }
2477
2478                 DBG_871X("MAC Address = "MAC_FMT"\n", MAC_ARG(pnetdev->dev_addr));
2479
2480
2481                 status=rtw_start_drv_threads(padapter);
2482                 if(status ==_FAIL)
2483                 {
2484                         RT_TRACE(_module_os_intfs_c_,_drv_err_,("Initialize driver software resource Failed!\n"));
2485                         goto netdev_open_error;
2486                 }
2487
2488 #ifdef CONFIG_DRVEXT_MODULE
2489                 init_drvext(padapter);
2490 #endif
2491
2492                 if(padapter->intf_start)
2493                 {
2494                         padapter->intf_start(padapter);
2495                 }
2496
2497 #ifndef RTK_DMP_PLATFORM
2498                 rtw_proc_init_one(pnetdev);
2499 #endif
2500
2501 #ifdef CONFIG_IOCTL_CFG80211
2502                 rtw_cfg80211_init_wiphy(padapter);
2503 #endif
2504
2505                 rtw_led_control(padapter, LED_CTL_NO_LINK);
2506
2507                 padapter->bup = _TRUE;
2508         }
2509         padapter->net_closed = _FALSE;
2510
2511         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
2512
2513         padapter->pwrctrlpriv.bips_processing = _FALSE;
2514         rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
2515
2516         //netif_carrier_on(pnetdev);//call this func when rtw_joinbss_event_callback return success
2517         if(!rtw_netif_queue_stopped(pnetdev))
2518                 rtw_netif_start_queue(pnetdev);
2519         else
2520                 rtw_netif_wake_queue(pnetdev);
2521
2522 #ifdef CONFIG_BR_EXT
2523         netdev_br_init(pnetdev);
2524 #endif  // CONFIG_BR_EXT
2525
2526 netdev_open_normal_process:
2527
2528         #ifdef CONFIG_CONCURRENT_MODE
2529         {
2530                 _adapter *sec_adapter = padapter->pbuddy_adapter;
2531                 if(sec_adapter && (sec_adapter->bup == _FALSE || sec_adapter->hw_init_completed == _FALSE))
2532                         _netdev_if2_open(sec_adapter->pnetdev);
2533         }
2534         #endif
2535
2536         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - dev_open\n"));
2537         DBG_871X("-871x_drv - drv_open, bup=%d\n", padapter->bup);
2538
2539         return 0;
2540
2541 netdev_open_error:
2542
2543         padapter->bup = _FALSE;
2544
2545         netif_carrier_off(pnetdev);
2546         rtw_netif_stop_queue(pnetdev);
2547
2548         RT_TRACE(_module_os_intfs_c_,_drv_err_,("-871x_drv - dev_open, fail!\n"));
2549         DBG_871X("-871x_drv - drv_open fail, bup=%d\n", padapter->bup);
2550
2551         return (-1);
2552
2553 }
2554
2555 int netdev_open(struct net_device *pnetdev)
2556 {
2557         int ret;
2558         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2559
2560         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2561         ret = _netdev_open(pnetdev);
2562         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->hw_init_mutex), NULL);
2563
2564         return ret;
2565 }
2566
2567 #ifdef CONFIG_IPS
2568 int  ips_netdrv_open(_adapter *padapter)
2569 {
2570         int status = _SUCCESS;
2571         padapter->net_closed = _FALSE;
2572         DBG_871X("===> %s.........\n",__FUNCTION__);
2573
2574
2575         padapter->bDriverStopped = _FALSE;
2576         padapter->bCardDisableWOHSM = _FALSE;
2577         //padapter->bup = _TRUE;
2578
2579         status = rtw_hal_init(padapter);
2580         if (status ==_FAIL)
2581         {
2582                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("ips_netdrv_open(): Can't init h/w!\n"));
2583                 goto netdev_open_error;
2584         }
2585
2586         if(padapter->intf_start)
2587         {
2588                 padapter->intf_start(padapter);
2589         }
2590
2591         rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
2592         _set_timer(&padapter->mlmepriv.dynamic_chk_timer,5000);
2593
2594          return _SUCCESS;
2595
2596 netdev_open_error:
2597         //padapter->bup = _FALSE;
2598         DBG_871X("-ips_netdrv_open - drv_open failure, bup=%d\n", padapter->bup);
2599
2600         return _FAIL;
2601 }
2602
2603
2604 int rtw_ips_pwr_up(_adapter *padapter)
2605 {
2606         int result;
2607         u32 start_time = rtw_get_current_time();
2608         DBG_871X("===>  rtw_ips_pwr_up..............\n");
2609         rtw_reset_drv_sw(padapter);
2610
2611         result = ips_netdrv_open(padapter);
2612
2613         rtw_led_control(padapter, LED_CTL_NO_LINK);
2614
2615         DBG_871X("<===  rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time));
2616         return result;
2617
2618 }
2619
2620 void rtw_ips_pwr_down(_adapter *padapter)
2621 {
2622         u32 start_time = rtw_get_current_time();
2623         DBG_871X("===> rtw_ips_pwr_down...................\n");
2624
2625         padapter->bCardDisableWOHSM = _TRUE;
2626         padapter->net_closed = _TRUE;
2627
2628         rtw_led_control(padapter, LED_CTL_POWER_OFF);
2629
2630         rtw_ips_dev_unload(padapter);
2631         padapter->bCardDisableWOHSM = _FALSE;
2632         DBG_871X("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time));
2633 }
2634 #endif
2635 void rtw_ips_dev_unload(_adapter *padapter)
2636 {
2637         struct net_device *pnetdev= (struct net_device*)padapter->pnetdev;
2638         struct xmit_priv        *pxmitpriv = &(padapter->xmitpriv);
2639         DBG_871X("====> %s...\n",__FUNCTION__);
2640
2641         rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, 0);
2642
2643         if(padapter->intf_stop)
2644         {
2645                 padapter->intf_stop(padapter);
2646         }
2647
2648         //s5.
2649         if(padapter->bSurpriseRemoved == _FALSE)
2650         {
2651                 rtw_hal_deinit(padapter);
2652         }
2653
2654 }
2655
2656 int pm_netdev_open(struct net_device *pnetdev,u8 bnormal)
2657 {
2658         int status;
2659         if(bnormal)
2660                 status = netdev_open(pnetdev);
2661 #ifdef CONFIG_IPS
2662         else
2663                 status =  (_SUCCESS == ips_netdrv_open((_adapter *)rtw_netdev_priv(pnetdev)))?(0):(-1);
2664 #endif
2665
2666         return status;
2667 }
2668
2669 static int netdev_close(struct net_device *pnetdev)
2670 {
2671         _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2672
2673         RT_TRACE(_module_os_intfs_c_,_drv_info_,("+871x_drv - drv_close\n"));
2674
2675         if(padapter->pwrctrlpriv.bInternalAutoSuspend == _TRUE)
2676         {
2677                 //rtw_pwr_wakeup(padapter);
2678                 if(padapter->pwrctrlpriv.rf_pwrstate == rf_off)
2679                         padapter->pwrctrlpriv.ps_flag = _TRUE;
2680         }
2681         padapter->net_closed = _TRUE;
2682
2683 /*      if(!padapter->hw_init_completed)
2684         {
2685                 DBG_871X("(1)871x_drv - drv_close, bup=%d, hw_init_completed=%d\n", padapter->bup, padapter->hw_init_completed);
2686
2687                 padapter->bDriverStopped = _TRUE;
2688
2689                 rtw_dev_unload(padapter);
2690         }
2691         else*/
2692         if(padapter->pwrctrlpriv.rf_pwrstate == rf_on){
2693                 DBG_871X("(2)871x_drv - drv_close, bup=%d, hw_init_completed=%d\n", padapter->bup, padapter->hw_init_completed);
2694
2695                 //s1.
2696                 if(pnetdev)
2697                 {
2698                         if (!rtw_netif_queue_stopped(pnetdev))
2699                                 rtw_netif_stop_queue(pnetdev);
2700                 }
2701
2702 #ifndef CONFIG_ANDROID
2703                 //s2.
2704                 LeaveAllPowerSaveMode(padapter);
2705                 rtw_disassoc_cmd(padapter, 500, _FALSE);
2706                 //s2-2.  indicate disconnect to os
2707                 rtw_indicate_disconnect(padapter);
2708                 //s2-3.
2709                 rtw_free_assoc_resources(padapter, 1);
2710                 //s2-4.
2711                 rtw_free_network_queue(padapter,_TRUE);
2712 #endif
2713                 // Close LED
2714                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
2715         }
2716
2717 #ifdef CONFIG_BR_EXT
2718         //if (OPMODE & (WIFI_STATION_STATE | WIFI_ADHOC_STATE))
2719         {
2720                 //void nat25_db_cleanup(_adapter *priv);
2721                 nat25_db_cleanup(padapter);
2722         }
2723 #endif  // CONFIG_BR_EXT
2724
2725 #ifdef CONFIG_P2P
2726 #ifdef CONFIG_IOCTL_CFG80211
2727         if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 )
2728         {
2729                 if(wdev_to_priv(padapter->rtw_wdev)->p2p_enabled == _TRUE)
2730                         wdev_to_priv(padapter->rtw_wdev)->p2p_enabled = _FALSE;
2731         }
2732 #endif //CONFIG_IOCTL_CFG80211
2733         rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
2734 #endif //CONFIG_P2P
2735
2736 #ifdef CONFIG_IOCTL_CFG80211
2737         rtw_scan_abort(padapter);
2738         wdev_to_priv(padapter->rtw_wdev)->bandroid_scan = _FALSE;
2739         padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR; //set this at the end
2740 #endif //CONFIG_IOCTL_CFG80211
2741
2742         RT_TRACE(_module_os_intfs_c_,_drv_info_,("-871x_drv - drv_close\n"));
2743         DBG_871X("-871x_drv - drv_close, bup=%d\n", padapter->bup);
2744
2745         return 0;
2746 }
2747
2748 void rtw_ndev_destructor(struct net_device *ndev)
2749 {
2750         DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2751
2752 #ifdef CONFIG_IOCTL_CFG80211
2753         if (ndev->ieee80211_ptr)
2754                 rtw_mfree((u8 *)ndev->ieee80211_ptr, sizeof(struct wireless_dev));
2755 #endif
2756         free_netdev(ndev);
2757 }