]> Pileus Git - ~andy/linux/commitdiff
staging: r8188eu: Add files for new driver - part 19
authorLarry Finger <Larry.Finger@lwfinger.net>
Thu, 22 Aug 2013 03:34:01 +0000 (22:34 -0500)
committerGreg Kroah-Hartman <gregkh@linuxfoundation.org>
Thu, 22 Aug 2013 17:20:11 +0000 (10:20 -0700)
This commit adds files os_dep/os_intfs.c, os_dep/recv_linux.c,
and os_dep/rtw_android.c.

Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/staging/rtl8188eu/os_dep/os_intfs.c [new file with mode: 0644]
drivers/staging/rtl8188eu/os_dep/recv_linux.c [new file with mode: 0644]
drivers/staging/rtl8188eu/os_dep/rtw_android.c [new file with mode: 0644]

diff --git a/drivers/staging/rtl8188eu/os_dep/os_intfs.c b/drivers/staging/rtl8188eu/os_dep/os_intfs.c
new file mode 100644 (file)
index 0000000..63bc913
--- /dev/null
@@ -0,0 +1,1251 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _OS_INTFS_C_
+
+#include <osdep_service.h>
+#include <drv_types.h>
+#include <xmit_osdep.h>
+#include <recv_osdep.h>
+#include <hal_intf.h>
+#include <rtw_ioctl.h>
+#include <rtw_version.h>
+
+#include <usb_osintf.h>
+#include <usb_hal.h>
+#include <rtw_br_ext.h>
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
+MODULE_AUTHOR("Realtek Semiconductor Corp.");
+MODULE_VERSION(DRIVERVERSION);
+
+#define CONFIG_BR_EXT_BRNAME "br0"
+#define RTW_NOTCH_FILTER 0 /* 0:Disable, 1:Enable, */
+
+/* module param defaults */
+static int rtw_chip_version = 0x00;
+static int rtw_rfintfs = HWPI;
+static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
+static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure; infra, ad-hoc, auto */
+static int rtw_channel = 1;/* ad-hoc support requirement */
+static int rtw_wireless_mode = WIRELESS_11BG_24N;
+static int rtw_vrtl_carrier_sense = AUTO_VCS;
+static int rtw_vcs_type = RTS_CTS;/*  */
+static int rtw_rts_thresh = 2347;/*  */
+static int rtw_frag_thresh = 2346;/*  */
+static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
+static int rtw_scan_mode = 1;/* active, passive */
+static int rtw_adhoc_tx_pwr = 1;
+static int rtw_soft_ap;
+static int rtw_power_mgnt = 1;
+static int rtw_ips_mode = IPS_NORMAL;
+
+static int rtw_smart_ps = 2;
+
+module_param(rtw_ips_mode, int, 0644);
+MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
+
+static int rtw_debug = 1;
+static int rtw_radio_enable = 1;
+static int rtw_long_retry_lmt = 7;
+static int rtw_short_retry_lmt = 7;
+static int rtw_busy_thresh = 40;
+static int rtw_ack_policy = NORMAL_ACK;
+
+static int rtw_mp_mode;
+
+static int rtw_software_encrypt;
+static int rtw_software_decrypt;
+
+static int rtw_acm_method;/*  0:By SW 1:By HW. */
+
+static int rtw_wmm_enable = 1;/*  default is set to enable the wmm. */
+static int rtw_uapsd_enable;
+static int rtw_uapsd_max_sp = NO_LIMIT;
+static int rtw_uapsd_acbk_en;
+static int rtw_uapsd_acbe_en;
+static int rtw_uapsd_acvi_en;
+static int rtw_uapsd_acvo_en;
+
+int rtw_ht_enable = 1;
+int rtw_cbw40_enable = 3; /*  0 :diable, bit(0): enable 2.4g, bit(1): enable 5g */
+int rtw_ampdu_enable = 1;/* for enable tx_ampdu */
+static 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 */
+static int rtw_ampdu_amsdu;/*  0: disabled, 1:enabled, 2:auto */
+
+static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
+
+static int rtw_rf_config = RF_819X_MAX_TYPE;  /* auto */
+static int rtw_low_power;
+static int rtw_wifi_spec;
+static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
+static int rtw_AcceptAddbaReq = true;/*  0:Reject AP's Add BA req, 1:Accept AP's Add BA req. */
+
+static int rtw_antdiv_cfg = 2; /*  0:OFF , 1:ON, 2:decide by Efuse config */
+static int rtw_antdiv_type; /* 0:decide by efuse  1: for 88EE, 1Tx and 1RxCG are diversity.(2 Ant with SPDT), 2:  for 88EE, 1Tx and 2Rx are diversity.(2 Ant, Tx and RxCG are both on aux port, RxCS is on main port), 3: for 88EE, 1Tx and 1RxCG are fixed.(1Ant, Tx and RxCG are both on aux port) */
+
+static int rtw_enusbss;/* 0:disable, 1:enable */
+
+static int rtw_hwpdn_mode = 2;/* 0:disable, 1:enable, 2: by EFUSE config */
+
+static int rtw_hwpwrp_detect; /* HW power  ping detect 0:disable , 1:enable */
+
+static int rtw_hw_wps_pbc = 1;
+
+int rtw_mc2u_disable;
+
+static int rtw_80211d;
+
+static char *ifname = "wlan%d";
+module_param(ifname, charp, 0644);
+MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
+
+static char *if2name = "wlan%d";
+module_param(if2name, charp, 0644);
+MODULE_PARM_DESC(if2name, "The default name to allocate for second interface");
+
+char *rtw_initmac;  /*  temp mac address if users want to use instead of the mac address in Efuse */
+
+module_param(rtw_initmac, charp, 0644);
+module_param(rtw_channel_plan, int, 0644);
+module_param(rtw_chip_version, int, 0644);
+module_param(rtw_rfintfs, int, 0644);
+module_param(rtw_lbkmode, int, 0644);
+module_param(rtw_network_mode, int, 0644);
+module_param(rtw_channel, int, 0644);
+module_param(rtw_mp_mode, int, 0644);
+module_param(rtw_wmm_enable, int, 0644);
+module_param(rtw_vrtl_carrier_sense, int, 0644);
+module_param(rtw_vcs_type, int, 0644);
+module_param(rtw_busy_thresh, int, 0644);
+module_param(rtw_ht_enable, int, 0644);
+module_param(rtw_cbw40_enable, int, 0644);
+module_param(rtw_ampdu_enable, int, 0644);
+module_param(rtw_rx_stbc, int, 0644);
+module_param(rtw_ampdu_amsdu, int, 0644);
+module_param(rtw_lowrate_two_xmit, int, 0644);
+module_param(rtw_rf_config, int, 0644);
+module_param(rtw_power_mgnt, int, 0644);
+module_param(rtw_smart_ps, int, 0644);
+module_param(rtw_low_power, int, 0644);
+module_param(rtw_wifi_spec, int, 0644);
+module_param(rtw_antdiv_cfg, int, 0644);
+module_param(rtw_antdiv_type, int, 0644);
+module_param(rtw_enusbss, int, 0644);
+module_param(rtw_hwpdn_mode, int, 0644);
+module_param(rtw_hwpwrp_detect, int, 0644);
+module_param(rtw_hw_wps_pbc, int, 0644);
+
+static uint rtw_max_roaming_times = 2;
+module_param(rtw_max_roaming_times, uint, 0644);
+MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
+
+static int rtw_fw_iol = 1;/*  0:Disable, 1:enable, 2:by usb speed */
+module_param(rtw_fw_iol, int, 0644);
+MODULE_PARM_DESC(rtw_fw_iol, "FW IOL");
+
+module_param(rtw_mc2u_disable, int, 0644);
+
+module_param(rtw_80211d, int, 0644);
+MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
+
+static uint rtw_notch_filter = RTW_NOTCH_FILTER;
+module_param(rtw_notch_filter, uint, 0644);
+MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
+module_param_named(debug, rtw_debug, int, 0444);
+MODULE_PARM_DESC(debug, "Set debug level (1-9) (default 1)");
+
+/* dummy routines */
+void rtw_proc_remove_one(struct net_device *dev)
+{
+}
+
+void rtw_proc_init_one(struct net_device *dev)
+{
+}
+
+#if 0  /* TODO: Convert these to /sys */
+void rtw_proc_init_one(struct net_device *dev)
+{
+       struct proc_dir_entry *dir_dev = NULL;
+       struct proc_dir_entry *entry = NULL;
+       struct adapter  *padapter = rtw_netdev_priv(dev);
+       u8 rf_type;
+
+       if (rtw_proc == NULL) {
+               memcpy(rtw_proc_name, DRV_NAME, sizeof(DRV_NAME));
+
+               rtw_proc = create_proc_entry(rtw_proc_name, S_IFDIR, init_net.proc_net);
+               if (rtw_proc == NULL) {
+                       DBG_88E(KERN_ERR "Unable to create rtw_proc directory\n");
+                       return;
+               }
+
+               entry = create_proc_read_entry("ver_info", S_IFREG | S_IRUGO, rtw_proc, proc_get_drv_version, dev);
+               if (!entry) {
+                       pr_info("Unable to create_proc_read_entry!\n");
+                       return;
+               }
+       }
+
+       if (padapter->dir_dev == NULL) {
+               padapter->dir_dev = create_proc_entry(dev->name,
+                                         S_IFDIR | S_IRUGO | S_IXUGO,
+                                         rtw_proc);
+               dir_dev = padapter->dir_dev;
+               if (dir_dev == NULL) {
+                       if (rtw_proc_cnt == 0) {
+                               if (rtw_proc) {
+                                       remove_proc_entry(rtw_proc_name, init_net.proc_net);
+                                       rtw_proc = NULL;
+                               }
+                       }
+
+                       pr_info("Unable to create dir_dev directory\n");
+                       return;
+               }
+       } else {
+               return;
+       }
+
+       rtw_proc_cnt++;
+
+       entry = create_proc_read_entry("write_reg", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_write_reg, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_write_reg;
+
+       entry = create_proc_read_entry("read_reg", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_read_reg, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_read_reg;
+
+
+       entry = create_proc_read_entry("fwstate", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_fwstate, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("sec_info", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_sec_info, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("mlmext_state", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_mlmext_state, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("qos_option", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_qos_option, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("ht_option", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_ht_option, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("rf_info", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_rf_info, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("ap_info", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_ap_info, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("adapter_state", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_getstruct adapter_state, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("trx_info", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_trx_info, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("mac_reg_dump1", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_mac_reg_dump1, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("mac_reg_dump2", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_mac_reg_dump2, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("mac_reg_dump3", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_mac_reg_dump3, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("bb_reg_dump1", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_bb_reg_dump1, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("bb_reg_dump2", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_bb_reg_dump2, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("bb_reg_dump3", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_bb_reg_dump3, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("rf_reg_dump1", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_rf_reg_dump1, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("rf_reg_dump2", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_rf_reg_dump2, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
+       if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) {
+               entry = create_proc_read_entry("rf_reg_dump3", S_IFREG | S_IRUGO,
+                                          dir_dev, proc_get_rf_reg_dump3, dev);
+               if (!entry) {
+                       pr_info("Unable to create_proc_read_entry!\n");
+                       return;
+               }
+
+               entry = create_proc_read_entry("rf_reg_dump4", S_IFREG | S_IRUGO,
+                                          dir_dev, proc_get_rf_reg_dump4, dev);
+               if (!entry) {
+                       pr_info("Unable to create_proc_read_entry!\n");
+                       return;
+               }
+       }
+
+#ifdef CONFIG_88EU_AP_MODE
+
+       entry = create_proc_read_entry("all_sta_info", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_all_sta_info, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+#endif
+
+       entry = create_proc_read_entry("best_channel", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_best_channel, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+
+       entry = create_proc_read_entry("rx_signal", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_rx_signal, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_rx_signal;
+       entry = create_proc_read_entry("ht_enable", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_ht_enable, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_ht_enable;
+
+       entry = create_proc_read_entry("cbw40_enable", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_cbw40_enable, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_cbw40_enable;
+
+       entry = create_proc_read_entry("ampdu_enable", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_ampdu_enable, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_ampdu_enable;
+
+       entry = create_proc_read_entry("rx_stbc", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_rx_stbc, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_rx_stbc;
+
+       entry = create_proc_read_entry("path_rssi", S_IFREG | S_IRUGO,
+                                       dir_dev, proc_get_two_path_rssi, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry = create_proc_read_entry("rssi_disp", S_IFREG | S_IRUGO,
+                                  dir_dev, proc_get_rssi_disp, dev);
+       if (!entry) {
+               pr_info("Unable to create_proc_read_entry!\n");
+               return;
+       }
+       entry->write_proc = proc_set_rssi_disp;
+}
+
+void rtw_proc_remove_one(struct net_device *dev)
+{
+       struct proc_dir_entry *dir_dev = NULL;
+       struct adapter  *padapter = rtw_netdev_priv(dev);
+       u8 rf_type;
+
+       dir_dev = padapter->dir_dev;
+       padapter->dir_dev = NULL;
+
+       if (dir_dev) {
+               remove_proc_entry("write_reg", dir_dev);
+               remove_proc_entry("read_reg", dir_dev);
+               remove_proc_entry("fwstate", dir_dev);
+               remove_proc_entry("sec_info", dir_dev);
+               remove_proc_entry("mlmext_state", dir_dev);
+               remove_proc_entry("qos_option", dir_dev);
+               remove_proc_entry("ht_option", dir_dev);
+               remove_proc_entry("rf_info", dir_dev);
+               remove_proc_entry("ap_info", dir_dev);
+               remove_proc_entry("adapter_state", dir_dev);
+               remove_proc_entry("trx_info", dir_dev);
+               remove_proc_entry("mac_reg_dump1", dir_dev);
+               remove_proc_entry("mac_reg_dump2", dir_dev);
+               remove_proc_entry("mac_reg_dump3", dir_dev);
+               remove_proc_entry("bb_reg_dump1", dir_dev);
+               remove_proc_entry("bb_reg_dump2", dir_dev);
+               remove_proc_entry("bb_reg_dump3", dir_dev);
+               remove_proc_entry("rf_reg_dump1", dir_dev);
+               remove_proc_entry("rf_reg_dump2", dir_dev);
+               rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
+               if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type)) {
+                       remove_proc_entry("rf_reg_dump3", dir_dev);
+                       remove_proc_entry("rf_reg_dump4", dir_dev);
+               }
+#ifdef CONFIG_88EU_AP_MODE
+               remove_proc_entry("all_sta_info", dir_dev);
+#endif
+
+               remove_proc_entry("best_channel", dir_dev);
+               remove_proc_entry("rx_signal", dir_dev);
+               remove_proc_entry("cbw40_enable", dir_dev);
+               remove_proc_entry("ht_enable", dir_dev);
+               remove_proc_entry("ampdu_enable", dir_dev);
+               remove_proc_entry("rx_stbc", dir_dev);
+               remove_proc_entry("path_rssi", dir_dev);
+               remove_proc_entry("rssi_disp", dir_dev);
+               remove_proc_entry(dev->name, rtw_proc);
+               dir_dev = NULL;
+       } else {
+               return;
+       }
+       rtw_proc_cnt--;
+
+       if (rtw_proc_cnt == 0) {
+               if (rtw_proc) {
+                       remove_proc_entry("ver_info", rtw_proc);
+
+                       remove_proc_entry(rtw_proc_name, init_net.proc_net);
+                       rtw_proc = NULL;
+               }
+       }
+}
+#endif
+
+static uint loadparam(struct adapter *padapter,  struct  net_device *pnetdev)
+{
+       uint status = _SUCCESS;
+       struct registry_priv  *registry_par = &padapter->registrypriv;
+
+_func_enter_;
+
+       GlobalDebugLevel = rtw_debug;
+       registry_par->chip_version = (u8)rtw_chip_version;
+       registry_par->rfintfs = (u8)rtw_rfintfs;
+       registry_par->lbkmode = (u8)rtw_lbkmode;
+       registry_par->network_mode  = (u8)rtw_network_mode;
+
+       memcpy(registry_par->ssid.Ssid, "ANY", 3);
+       registry_par->ssid.SsidLength = 3;
+
+       registry_par->channel = (u8)rtw_channel;
+       registry_par->wireless_mode = (u8)rtw_wireless_mode;
+       registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense ;
+       registry_par->vcs_type = (u8)rtw_vcs_type;
+       registry_par->rts_thresh = (u16)rtw_rts_thresh;
+       registry_par->frag_thresh = (u16)rtw_frag_thresh;
+       registry_par->preamble = (u8)rtw_preamble;
+       registry_par->scan_mode = (u8)rtw_scan_mode;
+       registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
+       registry_par->soft_ap =  (u8)rtw_soft_ap;
+       registry_par->smart_ps =  (u8)rtw_smart_ps;
+       registry_par->power_mgnt = (u8)rtw_power_mgnt;
+       registry_par->ips_mode = (u8)rtw_ips_mode;
+       registry_par->radio_enable = (u8)rtw_radio_enable;
+       registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
+       registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
+       registry_par->busy_thresh = (u16)rtw_busy_thresh;
+       registry_par->ack_policy = (u8)rtw_ack_policy;
+       registry_par->mp_mode = (u8)rtw_mp_mode;
+       registry_par->software_encrypt = (u8)rtw_software_encrypt;
+       registry_par->software_decrypt = (u8)rtw_software_decrypt;
+       registry_par->acm_method = (u8)rtw_acm_method;
+
+        /* UAPSD */
+       registry_par->wmm_enable = (u8)rtw_wmm_enable;
+       registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
+       registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
+       registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
+       registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
+       registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
+       registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
+
+       registry_par->ht_enable = (u8)rtw_ht_enable;
+       registry_par->cbw40_enable = (u8)rtw_cbw40_enable;
+       registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
+       registry_par->rx_stbc = (u8)rtw_rx_stbc;
+       registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
+       registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
+       registry_par->rf_config = (u8)rtw_rf_config;
+       registry_par->low_power = (u8)rtw_low_power;
+       registry_par->wifi_spec = (u8)rtw_wifi_spec;
+       registry_par->channel_plan = (u8)rtw_channel_plan;
+       registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq;
+       registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
+       registry_par->antdiv_type = (u8)rtw_antdiv_type;
+       registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;/* 0:disable, 1:enable, 2:by EFUSE config */
+       registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;/* 0:disable, 1:enable */
+       registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
+
+       registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
+
+       registry_par->fw_iol = rtw_fw_iol;
+
+       registry_par->enable80211d = (u8)rtw_80211d;
+       snprintf(registry_par->ifname, 16, "%s", ifname);
+       snprintf(registry_par->if2name, 16, "%s", if2name);
+       registry_par->notch_filter = (u8)rtw_notch_filter;
+_func_exit_;
+       return status;
+}
+
+static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
+{
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
+       struct sockaddr *addr = p;
+
+       if (!padapter->bup)
+               memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
+
+       return 0;
+}
+
+static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
+{
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
+       struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
+       struct recv_priv *precvpriv = &(padapter->recvpriv);
+
+       padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
+       padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */
+       padapter->stats.tx_dropped = pxmitpriv->tx_drop;
+       padapter->stats.rx_dropped = precvpriv->rx_drop;
+       padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
+       padapter->stats.rx_bytes = precvpriv->rx_bytes;
+       return &padapter->stats;
+}
+
+/*
+ * AC to queue mapping
+ *
+ * AC_VO -> queue 0
+ * AC_VI -> queue 1
+ * AC_BE -> queue 2
+ * AC_BK -> queue 3
+ */
+static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
+
+/* Given a data frame determine the 802.1p/1d tag to use. */
+static unsigned int rtw_classify8021d(struct sk_buff *skb)
+{
+       unsigned int dscp;
+
+       /* skb->priority values from 256->263 are magic values to
+        * directly indicate a specific 802.1d priority.  This is used
+        * to allow 802.1d priority to be passed directly in from VLAN
+        * tags, etc.
+        */
+       if (skb->priority >= 256 && skb->priority <= 263)
+               return skb->priority - 256;
+
+       switch (skb->protocol) {
+       case htons(ETH_P_IP):
+               dscp = ip_hdr(skb)->tos & 0xfc;
+               break;
+       default:
+               return 0;
+       }
+
+       return dscp >> 5;
+}
+
+static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb)
+{
+       struct adapter  *padapter = rtw_netdev_priv(dev);
+       struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+
+       skb->priority = rtw_classify8021d(skb);
+
+       if (pmlmepriv->acm_mask != 0)
+               skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
+
+       return rtw_1d_to_queue[skb->priority];
+}
+
+u16 rtw_recv_select_queue(struct sk_buff *skb)
+{
+       struct iphdr *piphdr;
+       unsigned int dscp;
+       __be16  eth_type;
+       u32 priority;
+       u8 *pdata = skb->data;
+
+       memcpy(&eth_type, pdata+(ETH_ALEN<<1), 2);
+
+       switch (eth_type) {
+       case htons(ETH_P_IP):
+               piphdr = (struct iphdr *)(pdata+ETH_HLEN);
+               dscp = piphdr->tos & 0xfc;
+               priority = dscp >> 5;
+               break;
+       default:
+               priority = 0;
+       }
+
+       return rtw_1d_to_queue[priority];
+}
+
+static const struct net_device_ops rtw_netdev_ops = {
+       .ndo_open = netdev_open,
+       .ndo_stop = netdev_close,
+       .ndo_start_xmit = rtw_xmit_entry,
+       .ndo_select_queue       = rtw_select_queue,
+       .ndo_set_mac_address = rtw_net_set_mac_address,
+       .ndo_get_stats = rtw_net_get_stats,
+       .ndo_do_ioctl = rtw_ioctl,
+};
+
+int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
+{
+       if (dev_alloc_name(pnetdev, ifname) < 0)
+               RT_TRACE(_module_os_intfs_c_, _drv_err_, ("dev_alloc_name, fail!\n"));
+
+       netif_carrier_off(pnetdev);
+       return 0;
+}
+
+struct net_device *rtw_init_netdev(struct adapter *old_padapter)
+{
+       struct adapter *padapter;
+       struct net_device *pnetdev;
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+init_net_dev\n"));
+
+       if (old_padapter != NULL)
+               pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter);
+       else
+               pnetdev = rtw_alloc_etherdev(sizeof(struct adapter));
+
+       if (!pnetdev)
+               return NULL;
+
+       padapter = rtw_netdev_priv(pnetdev);
+       padapter->pnetdev = pnetdev;
+       DBG_88E("register rtw_netdev_ops to netdev_ops\n");
+       pnetdev->netdev_ops = &rtw_netdev_ops;
+       pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */
+       pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
+
+       /* step 2. */
+       loadparam(padapter, pnetdev);
+
+       return pnetdev;
+}
+
+u32 rtw_start_drv_threads(struct adapter *padapter)
+{
+       u32 _status = _SUCCESS;
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_start_drv_threads\n"));
+
+       padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
+       if (IS_ERR(padapter->cmdThread))
+               _status = _FAIL;
+       else
+               _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); /* wait for cmd_thread to run */
+
+       rtw_hal_start_thread(padapter);
+       return _status;
+}
+
+void rtw_stop_drv_threads(struct adapter *padapter)
+{
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_stop_drv_threads\n"));
+
+       /* Below is to termindate rtw_cmd_thread & event_thread... */
+       _rtw_up_sema(&padapter->cmdpriv.cmd_queue_sema);
+       if (padapter->cmdThread)
+               _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema);
+
+       rtw_hal_stop_thread(padapter);
+}
+
+static u8 rtw_init_default_value(struct adapter *padapter)
+{
+       u8 ret  = _SUCCESS;
+       struct registry_priv *pregistrypriv = &padapter->registrypriv;
+       struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
+       struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+       struct security_priv *psecuritypriv = &padapter->securitypriv;
+
+       /* xmit_priv */
+       pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
+       pxmitpriv->vcs = pregistrypriv->vcs_type;
+       pxmitpriv->vcs_type = pregistrypriv->vcs_type;
+       pxmitpriv->frag_len = pregistrypriv->frag_thresh;
+
+       /* mlme_priv */
+       pmlmepriv->scan_interval = SCAN_INTERVAL;/*  30*2 sec = 60sec */
+       pmlmepriv->scan_mode = SCAN_ACTIVE;
+
+       /* ht_priv */
+       pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
+
+       /* security_priv */
+       psecuritypriv->binstallGrpkey = _FAIL;
+       psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
+       psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
+       psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
+       psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
+       psecuritypriv->dot11PrivacyKeyIndex = 0;
+       psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
+       psecuritypriv->dot118021XGrpKeyid = 1;
+       psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
+       psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
+
+       /* registry_priv */
+       rtw_init_registrypriv_dev_network(padapter);
+       rtw_update_registrypriv_dev_network(padapter);
+
+       /* hal_priv */
+       rtw_hal_def_value_init(padapter);
+
+       /* misc. */
+       padapter->bReadPortCancel = false;
+       padapter->bWritePortCancel = false;
+       padapter->bRxRSSIDisplay = 0;
+       padapter->bNotifyChannelChange = 0;
+#ifdef CONFIG_88EU_P2P
+       padapter->bShowGetP2PState = 1;
+#endif
+       return ret;
+}
+
+u8 rtw_reset_drv_sw(struct adapter *padapter)
+{
+       u8      ret8 = _SUCCESS;
+       struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+       struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
+
+       /* hal_priv */
+       rtw_hal_def_value_init(padapter);
+       padapter->bReadPortCancel = false;
+       padapter->bWritePortCancel = false;
+       padapter->bRxRSSIDisplay = 0;
+       pmlmepriv->scan_interval = SCAN_INTERVAL;/*  30*2 sec = 60sec */
+
+       padapter->xmitpriv.tx_pkts = 0;
+       padapter->recvpriv.rx_pkts = 0;
+
+       pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
+
+       _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);
+
+       rtw_hal_sreset_reset_value(padapter);
+       pwrctrlpriv->pwr_state_check_cnts = 0;
+
+       /* mlmeextpriv */
+       padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
+
+       rtw_set_signal_stat_timer(&padapter->recvpriv);
+
+       return ret8;
+}
+
+u8 rtw_init_drv_sw(struct adapter *padapter)
+{
+       u8      ret8 = _SUCCESS;
+
+_func_enter_;
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_init_drv_sw\n"));
+
+       if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL) {
+               RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init cmd_priv\n"));
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+       padapter->cmdpriv.padapter = padapter;
+
+       if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL) {
+               RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init evt_priv\n"));
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+       if (rtw_init_mlme_priv(padapter) == _FAIL) {
+               RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_priv\n"));
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+#ifdef CONFIG_88EU_P2P
+       rtw_init_wifidirect_timers(padapter);
+       init_wifidirect_info(padapter, P2P_ROLE_DISABLE);
+       reset_global_wifidirect_info(padapter);
+#endif /* CONFIG_88EU_P2P */
+
+       if (init_mlme_ext_priv(padapter) == _FAIL) {
+               RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_ext_priv\n"));
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+       if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) {
+               DBG_88E("Can't _rtw_init_xmit_priv\n");
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+       if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL) {
+               DBG_88E("Can't _rtw_init_recv_priv\n");
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+       if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) {
+               DBG_88E("Can't _rtw_init_sta_priv\n");
+               ret8 = _FAIL;
+               goto exit;
+       }
+
+       padapter->stapriv.padapter = padapter;
+
+       rtw_init_bcmc_stainfo(padapter);
+
+       rtw_init_pwrctrl_priv(padapter);
+
+       if (init_mp_priv(padapter) == _FAIL)
+               DBG_88E("%s: initialize MP private data Fail!\n", __func__);
+
+       ret8 = rtw_init_default_value(padapter);
+
+       rtw_hal_dm_init(padapter);
+       rtw_hal_sw_led_init(padapter);
+
+       rtw_hal_sreset_init(padapter);
+
+       _rtw_spinlock_init(&padapter->br_ext_lock);
+
+exit:
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_init_drv_sw\n"));
+
+       _func_exit_;
+
+       return ret8;
+}
+
+void rtw_cancel_all_timer(struct adapter *padapter)
+{
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_cancel_all_timer\n"));
+
+       _cancel_timer_ex(&padapter->mlmepriv.assoc_timer);
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel association timer complete!\n"));
+
+       _cancel_timer_ex(&padapter->mlmepriv.scan_to_timer);
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel scan_to_timer!\n"));
+
+       _cancel_timer_ex(&padapter->mlmepriv.dynamic_chk_timer);
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel dynamic_chk_timer!\n"));
+
+       /*  cancel sw led timer */
+       rtw_hal_sw_led_deinit(padapter);
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel DeInitSwLeds!\n"));
+
+       _cancel_timer_ex(&padapter->pwrctrlpriv.pwr_state_check_timer);
+
+       _cancel_timer_ex(&padapter->recvpriv.signal_stat_timer);
+       /* cancel dm timer */
+       rtw_hal_dm_deinit(padapter);
+}
+
+u8 rtw_free_drv_sw(struct adapter *padapter)
+{
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("==>rtw_free_drv_sw"));
+
+       /* we can call rtw_p2p_enable here, but: */
+       /*  1. rtw_p2p_enable may have IO operation */
+       /*  2. rtw_p2p_enable is bundled with wext interface */
+       #ifdef CONFIG_88EU_P2P
+       {
+               struct wifidirect_info *pwdinfo = &padapter->wdinfo;
+               if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) {
+                       _cancel_timer_ex(&pwdinfo->find_phase_timer);
+                       _cancel_timer_ex(&pwdinfo->restore_p2p_state_timer);
+                       _cancel_timer_ex(&pwdinfo->pre_tx_scan_timer);
+                       rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
+               }
+       }
+       #endif
+
+
+       _rtw_spinlock_free(&padapter->br_ext_lock);
+
+       free_mlme_ext_priv(&padapter->mlmeextpriv);
+
+       rtw_free_cmd_priv(&padapter->cmdpriv);
+
+       rtw_free_evt_priv(&padapter->evtpriv);
+
+       rtw_free_mlme_priv(&padapter->mlmepriv);
+       _rtw_free_xmit_priv(&padapter->xmitpriv);
+
+       _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
+
+       _rtw_free_recv_priv(&padapter->recvpriv);
+
+       rtw_free_pwrctrl_priv(padapter);
+
+       rtw_hal_free_data(padapter);
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("<== rtw_free_drv_sw\n"));
+
+       /* free the old_pnetdev */
+       if (padapter->rereg_nd_name_priv.old_pnetdev) {
+               free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
+               padapter->rereg_nd_name_priv.old_pnetdev = NULL;
+       }
+
+       /*  clear pbuddystruct adapter to avoid access wrong pointer. */
+       if (padapter->pbuddy_adapter != NULL)
+               padapter->pbuddy_adapter->pbuddy_adapter = NULL;
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_free_drv_sw\n"));
+
+       return _SUCCESS;
+}
+
+void netdev_br_init(struct net_device *netdev)
+{
+       struct adapter *adapter = (struct adapter *)rtw_netdev_priv(netdev);
+
+       rcu_read_lock();
+
+       if (rcu_dereference(adapter->pnetdev->rx_handler_data)) {
+               struct net_device *br_netdev;
+               struct net *devnet = NULL;
+
+               devnet = dev_net(netdev);
+               br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME);
+               if (br_netdev) {
+                       memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN);
+                       dev_put(br_netdev);
+               } else {
+                       pr_info("%s()-%d: dev_get_by_name(%s) failed!",
+                               __func__, __LINE__, CONFIG_BR_EXT_BRNAME);
+               }
+       }
+       adapter->ethBrExtInfo.addPPPoETag = 1;
+
+       rcu_read_unlock();
+}
+
+int _netdev_open(struct net_device *pnetdev)
+{
+       uint status;
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
+       struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - dev_open\n"));
+       DBG_88E("+88eu_drv - drv_open, bup =%d\n", padapter->bup);
+
+       if (pwrctrlpriv->ps_flag) {
+               padapter->net_closed = false;
+               goto netdev_open_normal_process;
+       }
+
+       if (!padapter->bup) {
+               padapter->bDriverStopped = false;
+               padapter->bSurpriseRemoved = false;
+               padapter->bCardDisableWOHSM = false;
+
+               status = rtw_hal_init(padapter);
+               if (status == _FAIL) {
+                       RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl88eu_hal_init(): Can't init h/w!\n"));
+                       goto netdev_open_error;
+               }
+
+               pr_info("MAC Address = %pM\n", pnetdev->dev_addr);
+
+               status = rtw_start_drv_threads(padapter);
+               if (status == _FAIL) {
+                       pr_info("Initialize driver software resource Failed!\n");
+                       goto netdev_open_error;
+               }
+
+               if (init_hw_mlme_ext(padapter) == _FAIL) {
+                       pr_info("can't init mlme_ext_priv\n");
+                       goto netdev_open_error;
+               }
+               if (padapter->intf_start)
+                       padapter->intf_start(padapter);
+               rtw_proc_init_one(pnetdev);
+
+               rtw_led_control(padapter, LED_CTL_NO_LINK);
+
+               padapter->bup = true;
+       }
+       padapter->net_closed = false;
+
+       _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
+
+       padapter->pwrctrlpriv.bips_processing = false;
+       rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
+
+       if (!rtw_netif_queue_stopped(pnetdev))
+               rtw_netif_start_queue(pnetdev);
+       else
+               rtw_netif_wake_queue(pnetdev);
+
+       netdev_br_init(pnetdev);
+
+netdev_open_normal_process:
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - dev_open\n"));
+       DBG_88E("-88eu_drv - drv_open, bup =%d\n", padapter->bup);
+       return 0;
+
+netdev_open_error:
+       padapter->bup = false;
+       netif_carrier_off(pnetdev);
+       rtw_netif_stop_queue(pnetdev);
+       RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-88eu_drv - dev_open, fail!\n"));
+       DBG_88E("-88eu_drv - drv_open fail, bup =%d\n", padapter->bup);
+       return -1;
+}
+
+int netdev_open(struct net_device *pnetdev)
+{
+       int ret;
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
+
+       _enter_critical_mutex(padapter->hw_init_mutex, NULL);
+       ret = _netdev_open(pnetdev);
+       _exit_critical_mutex(padapter->hw_init_mutex, NULL);
+       return ret;
+}
+
+static int  ips_netdrv_open(struct adapter *padapter)
+{
+       int status = _SUCCESS;
+       padapter->net_closed = false;
+       DBG_88E("===> %s.........\n", __func__);
+
+       padapter->bDriverStopped = false;
+       padapter->bSurpriseRemoved = false;
+       padapter->bCardDisableWOHSM = false;
+
+       status = rtw_hal_init(padapter);
+       if (status == _FAIL) {
+               RT_TRACE(_module_os_intfs_c_, _drv_err_, ("ips_netdrv_open(): Can't init h/w!\n"));
+               goto netdev_open_error;
+       }
+
+       if (padapter->intf_start)
+               padapter->intf_start(padapter);
+
+       rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
+       _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 5000);
+
+        return _SUCCESS;
+
+netdev_open_error:
+       DBG_88E("-ips_netdrv_open - drv_open failure, bup =%d\n", padapter->bup);
+
+       return _FAIL;
+}
+
+
+int rtw_ips_pwr_up(struct adapter *padapter)
+{
+       int result;
+       u32 start_time = rtw_get_current_time();
+       DBG_88E("===>  rtw_ips_pwr_up..............\n");
+       rtw_reset_drv_sw(padapter);
+
+       result = ips_netdrv_open(padapter);
+
+       rtw_led_control(padapter, LED_CTL_NO_LINK);
+
+       DBG_88E("<===  rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time));
+       return result;
+}
+
+void rtw_ips_pwr_down(struct adapter *padapter)
+{
+       u32 start_time = rtw_get_current_time();
+       DBG_88E("===> rtw_ips_pwr_down...................\n");
+
+       padapter->bCardDisableWOHSM = true;
+       padapter->net_closed = true;
+
+       rtw_led_control(padapter, LED_CTL_POWER_OFF);
+
+       rtw_ips_dev_unload(padapter);
+       padapter->bCardDisableWOHSM = false;
+       DBG_88E("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time));
+}
+
+void rtw_ips_dev_unload(struct adapter *padapter)
+{
+       DBG_88E("====> %s...\n", __func__);
+
+       rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, NULL);
+
+       if (padapter->intf_stop)
+               padapter->intf_stop(padapter);
+
+       /* s5. */
+       if (!padapter->bSurpriseRemoved)
+               rtw_hal_deinit(padapter);
+}
+
+int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
+{
+       int status;
+
+       if (bnormal)
+               status = netdev_open(pnetdev);
+       else
+               status =  (_SUCCESS == ips_netdrv_open((struct adapter *)rtw_netdev_priv(pnetdev))) ? (0) : (-1);
+       return status;
+}
+
+int netdev_close(struct net_device *pnetdev)
+{
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+88eu_drv - drv_close\n"));
+
+       if (padapter->pwrctrlpriv.bInternalAutoSuspend) {
+               if (padapter->pwrctrlpriv.rf_pwrstate == rf_off)
+                       padapter->pwrctrlpriv.ps_flag = true;
+       }
+       padapter->net_closed = true;
+
+       if (padapter->pwrctrlpriv.rf_pwrstate == rf_on) {
+               DBG_88E("(2)88eu_drv - drv_close, bup =%d, hw_init_completed =%d\n",
+                       padapter->bup, padapter->hw_init_completed);
+
+               /* s1. */
+               if (pnetdev) {
+                       if (!rtw_netif_queue_stopped(pnetdev))
+                               rtw_netif_stop_queue(pnetdev);
+               }
+
+               /* s2. */
+               LeaveAllPowerSaveMode(padapter);
+               rtw_disassoc_cmd(padapter, 500, false);
+               /* s2-2.  indicate disconnect to os */
+               rtw_indicate_disconnect(padapter);
+               /* s2-3. */
+               rtw_free_assoc_resources(padapter, 1);
+               /* s2-4. */
+               rtw_free_network_queue(padapter, true);
+               /*  Close LED */
+               rtw_led_control(padapter, LED_CTL_POWER_OFF);
+       }
+
+       nat25_db_cleanup(padapter);
+
+#ifdef CONFIG_88EU_P2P
+       rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
+#endif /* CONFIG_88EU_P2P */
+
+       RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-88eu_drv - drv_close\n"));
+       DBG_88E("-88eu_drv - drv_close, bup =%d\n", padapter->bup);
+       return 0;
+}
diff --git a/drivers/staging/rtl8188eu/os_dep/recv_linux.c b/drivers/staging/rtl8188eu/os_dep/recv_linux.c
new file mode 100644 (file)
index 0000000..e2f4e7d
--- /dev/null
@@ -0,0 +1,261 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define _RECV_OSDEP_C_
+
+#include <osdep_service.h>
+#include <drv_types.h>
+
+#include <wifi.h>
+#include <recv_osdep.h>
+
+#include <osdep_intf.h>
+#include <ethernet.h>
+#include <usb_ops.h>
+
+/* init os related resource in struct recv_priv */
+int rtw_os_recv_resource_init(struct recv_priv *precvpriv,
+                             struct adapter *padapter)
+{
+       return _SUCCESS;
+}
+
+/* alloc os related resource in union recv_frame */
+int rtw_os_recv_resource_alloc(struct adapter *padapter,
+                              union recv_frame *precvframe)
+{
+       precvframe->u.hdr.pkt_newalloc = NULL;
+       precvframe->u.hdr.pkt = NULL;
+       return _SUCCESS;
+}
+
+/* free os related resource in union recv_frame */
+void rtw_os_recv_resource_free(struct recv_priv *precvpriv)
+{
+}
+
+/* alloc os related resource in struct recv_buf */
+int rtw_os_recvbuf_resource_alloc(struct adapter *padapter,
+                                 struct recv_buf *precvbuf)
+{
+       int res = _SUCCESS;
+
+       precvbuf->irp_pending = false;
+       precvbuf->purb = usb_alloc_urb(0, GFP_KERNEL);
+       if (precvbuf->purb == NULL)
+               res = _FAIL;
+       precvbuf->pskb = NULL;
+       precvbuf->reuse = false;
+       precvbuf->pallocated_buf = NULL;
+       precvbuf->pbuf = NULL;
+       precvbuf->pdata = NULL;
+       precvbuf->phead = NULL;
+       precvbuf->ptail = NULL;
+       precvbuf->pend = NULL;
+       precvbuf->transfer_len = 0;
+       precvbuf->len = 0;
+       return res;
+}
+
+/* free os related resource in struct recv_buf */
+int rtw_os_recvbuf_resource_free(struct adapter *padapter,
+                                struct recv_buf *precvbuf)
+{
+       if (precvbuf->purb)
+               usb_free_urb(precvbuf->purb);
+       return _SUCCESS;
+}
+
+void rtw_handle_tkip_mic_err(struct adapter *padapter, u8 bgroup)
+{
+       union iwreq_data wrqu;
+       struct iw_michaelmicfailure    ev;
+       struct mlme_priv *pmlmepriv  = &padapter->mlmepriv;
+       struct security_priv    *psecuritypriv = &padapter->securitypriv;
+       u32 cur_time = 0;
+
+       if (psecuritypriv->last_mic_err_time == 0) {
+               psecuritypriv->last_mic_err_time = rtw_get_current_time();
+       } else {
+               cur_time = rtw_get_current_time();
+
+               if (cur_time - psecuritypriv->last_mic_err_time < 60*HZ) {
+                       psecuritypriv->btkip_countermeasure = true;
+                       psecuritypriv->last_mic_err_time = 0;
+                       psecuritypriv->btkip_countermeasure_time = cur_time;
+               } else {
+                       psecuritypriv->last_mic_err_time = rtw_get_current_time();
+               }
+       }
+
+       _rtw_memset(&ev, 0x00, sizeof(ev));
+       if (bgroup)
+               ev.flags |= IW_MICFAILURE_GROUP;
+       else
+               ev.flags |= IW_MICFAILURE_PAIRWISE;
+
+       ev.src_addr.sa_family = ARPHRD_ETHER;
+       memcpy(ev.src_addr.sa_data, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
+       _rtw_memset(&wrqu, 0x00, sizeof(wrqu));
+       wrqu.data.length = sizeof(ev);
+       wireless_send_event(padapter->pnetdev, IWEVMICHAELMICFAILURE,
+                           &wrqu, (char *)&ev);
+}
+
+void rtw_hostapd_mlme_rx(struct adapter *padapter,
+                        union recv_frame *precv_frame)
+{
+}
+
+int rtw_recv_indicatepkt(struct adapter *padapter,
+                        union recv_frame *precv_frame)
+{
+       struct recv_priv *precvpriv;
+       struct __queue *pfree_recv_queue;
+       struct sk_buff *skb;
+       struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
+
+_func_enter_;
+
+       precvpriv = &(padapter->recvpriv);
+       pfree_recv_queue = &(precvpriv->free_recv_queue);
+
+       skb = precv_frame->u.hdr.pkt;
+       if (skb == NULL) {
+               RT_TRACE(_module_recv_osdep_c_, _drv_err_,
+                        ("rtw_recv_indicatepkt():skb == NULL something wrong!!!!\n"));
+               goto _recv_indicatepkt_drop;
+       }
+
+       RT_TRACE(_module_recv_osdep_c_, _drv_info_,
+                ("rtw_recv_indicatepkt():skb != NULL !!!\n"));
+       RT_TRACE(_module_recv_osdep_c_, _drv_info_,
+                ("rtw_recv_indicatepkt():precv_frame->u.hdr.rx_head =%p  precv_frame->hdr.rx_data =%p\n",
+                precv_frame->u.hdr.rx_head, precv_frame->u.hdr.rx_data));
+       RT_TRACE(_module_recv_osdep_c_, _drv_info_,
+                ("precv_frame->hdr.rx_tail =%p precv_frame->u.hdr.rx_end =%p precv_frame->hdr.len =%d\n",
+                precv_frame->u.hdr.rx_tail, precv_frame->u.hdr.rx_end,
+                precv_frame->u.hdr.len));
+
+       skb->data = precv_frame->u.hdr.rx_data;
+
+       skb_set_tail_pointer(skb, precv_frame->u.hdr.len);
+
+       skb->len = precv_frame->u.hdr.len;
+
+       RT_TRACE(_module_recv_osdep_c_, _drv_info_,
+                ("skb->head =%p skb->data =%p skb->tail =%p skb->end =%p skb->len =%d\n",
+                skb->head, skb->data, skb_tail_pointer(skb),
+                skb_end_pointer(skb), skb->len));
+
+       if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
+               struct sk_buff *pskb2 = NULL;
+               struct sta_info *psta = NULL;
+               struct sta_priv *pstapriv = &padapter->stapriv;
+               struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
+               int bmcast = IS_MCAST(pattrib->dst);
+
+               if (!_rtw_memcmp(pattrib->dst, myid(&padapter->eeprompriv),
+                                ETH_ALEN)) {
+                       if (bmcast) {
+                               psta = rtw_get_bcmc_stainfo(padapter);
+                               pskb2 = skb_clone(skb, GFP_ATOMIC);
+                       } else {
+                               psta = rtw_get_stainfo(pstapriv, pattrib->dst);
+                       }
+
+                       if (psta) {
+                               struct net_device *pnetdev;
+
+                               pnetdev = (struct net_device *)padapter->pnetdev;
+                               skb->dev = pnetdev;
+                               skb_set_queue_mapping(skb, rtw_recv_select_queue(skb));
+
+                               rtw_xmit_entry(skb, pnetdev);
+
+                               if (bmcast)
+                                       skb = pskb2;
+                               else
+                                       goto _recv_indicatepkt_end;
+                       }
+               }
+       }
+
+       rcu_read_lock();
+       rcu_dereference(padapter->pnetdev->rx_handler_data);
+       rcu_read_unlock();
+
+       skb->ip_summed = CHECKSUM_NONE;
+       skb->dev = padapter->pnetdev;
+       skb->protocol = eth_type_trans(skb, padapter->pnetdev);
+
+       netif_rx(skb);
+
+_recv_indicatepkt_end:
+
+       /*  pointers to NULL before rtw_free_recvframe() */
+       precv_frame->u.hdr.pkt = NULL;
+
+       rtw_free_recvframe(precv_frame, pfree_recv_queue);
+
+       RT_TRACE(_module_recv_osdep_c_, _drv_info_,
+                ("\n rtw_recv_indicatepkt :after netif_rx!!!!\n"));
+
+_func_exit_;
+
+       return _SUCCESS;
+
+_recv_indicatepkt_drop:
+
+        /* enqueue back to free_recv_queue */
+       if (precv_frame)
+               rtw_free_recvframe(precv_frame, pfree_recv_queue);
+
+_func_exit_;
+        return _FAIL;
+}
+
+void rtw_os_read_port(struct adapter *padapter, struct recv_buf *precvbuf)
+{
+       struct recv_priv *precvpriv = &padapter->recvpriv;
+
+       precvbuf->ref_cnt--;
+       /* free skb in recv_buf */
+       dev_kfree_skb_any(precvbuf->pskb);
+       precvbuf->pskb = NULL;
+       precvbuf->reuse = false;
+       if (!precvbuf->irp_pending)
+               rtw_read_port(padapter, precvpriv->ff_hwaddr, 0,
+                             (unsigned char *)precvbuf);
+}
+
+static void _rtw_reordering_ctrl_timeout_handler(void *func_context)
+{
+       struct recv_reorder_ctrl *preorder_ctrl;
+
+       preorder_ctrl = (struct recv_reorder_ctrl *)func_context;
+       rtw_reordering_ctrl_timeout_handler(preorder_ctrl);
+}
+
+void rtw_init_recv_timer(struct recv_reorder_ctrl *preorder_ctrl)
+{
+       struct adapter *padapter = preorder_ctrl->padapter;
+
+       _init_timer(&(preorder_ctrl->reordering_ctrl_timer), padapter->pnetdev, _rtw_reordering_ctrl_timeout_handler, preorder_ctrl);
+}
diff --git a/drivers/staging/rtl8188eu/os_dep/rtw_android.c b/drivers/staging/rtl8188eu/os_dep/rtw_android.c
new file mode 100644 (file)
index 0000000..6cf71cc
--- /dev/null
@@ -0,0 +1,293 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+
+#include <linux/module.h>
+#include <linux/netdevice.h>
+
+#include <rtw_android.h>
+#include <osdep_service.h>
+#include <rtw_debug.h>
+#include <ioctl_cfg80211.h>
+#include <rtw_ioctl_set.h>
+
+static const char *android_wifi_cmd_str[ANDROID_WIFI_CMD_MAX] = {
+       "START",
+       "STOP",
+       "SCAN-ACTIVE",
+       "SCAN-PASSIVE",
+       "RSSI",
+       "LINKSPEED",
+       "RXFILTER-START",
+       "RXFILTER-STOP",
+       "RXFILTER-ADD",
+       "RXFILTER-REMOVE",
+       "BTCOEXSCAN-START",
+       "BTCOEXSCAN-STOP",
+       "BTCOEXMODE",
+       "SETSUSPENDOPT",
+       "P2P_DEV_ADDR",
+       "SETFWPATH",
+       "SETBAND",
+       "GETBAND",
+       "COUNTRY",
+       "P2P_SET_NOA",
+       "P2P_GET_NOA",
+       "P2P_SET_PS",
+       "SET_AP_WPS_P2P_IE",
+       "MACADDR",
+       "BLOCK",
+       "WFD-ENABLE",
+       "WFD-DISABLE",
+       "WFD-SET-TCPPORT",
+       "WFD-SET-MAXTPUT",
+       "WFD-SET-DEVTYPE",
+};
+
+struct android_wifi_priv_cmd {
+       const char __user *buf;
+       int used_len;
+       int total_len;
+};
+
+/**
+ * Local (static) functions and variables
+ */
+
+/* Initialize g_wifi_on to 1 so dhd_bus_start will be called for the first
+ * time (only) in dhd_open, subsequential wifi on will be handled by
+ * wl_android_wifi_on
+ */
+static int g_wifi_on = true;
+
+int rtw_android_cmdstr_to_num(char *cmdstr)
+{
+       int cmd_num;
+       for (cmd_num = 0; cmd_num < ANDROID_WIFI_CMD_MAX; cmd_num++)
+               if (0 == strnicmp(cmdstr , android_wifi_cmd_str[cmd_num],
+                                 strlen(android_wifi_cmd_str[cmd_num])))
+                       break;
+       return cmd_num;
+}
+
+static int rtw_android_get_rssi(struct net_device *net, char *command,
+                               int total_len)
+{
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(net);
+       struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
+       struct  wlan_network    *pcur_network = &pmlmepriv->cur_network;
+       int bytes_written = 0;
+
+       if (check_fwstate(pmlmepriv, _FW_LINKED)) {
+               bytes_written += snprintf(&command[bytes_written], total_len,
+                                         "%s rssi %d",
+                                         pcur_network->network.Ssid.Ssid,
+                                         padapter->recvpriv.rssi);
+       }
+       return bytes_written;
+}
+
+static int rtw_android_get_link_speed(struct net_device *net, char *command,
+                                     int total_len)
+{
+       struct adapter *padapter = (struct adapter *)rtw_netdev_priv(net);
+       int bytes_written;
+       u16 link_speed;
+
+       link_speed = rtw_get_cur_max_rate(padapter) / 10;
+       bytes_written = snprintf(command, total_len, "LinkSpeed %d",
+                                link_speed);
+       return bytes_written;
+}
+
+static int rtw_android_get_macaddr(struct net_device *net, char *command,
+                                  int total_len)
+{
+       int bytes_written;
+
+       bytes_written = snprintf(command, total_len, "Macaddr = %pM",
+                                net->dev_addr);
+       return bytes_written;
+}
+
+static int android_set_cntry(struct net_device *net, char *command,
+                            int total_len)
+{
+       struct adapter *adapter = (struct adapter *)rtw_netdev_priv(net);
+       char *country_code = command + strlen(android_wifi_cmd_str[ANDROID_WIFI_CMD_COUNTRY]) + 1;
+       int ret;
+
+       ret = rtw_set_country(adapter, country_code);
+       return (ret == _SUCCESS) ? 0 : -1;
+}
+
+static int android_get_p2p_addr(struct net_device *net, char *command,
+                                       int total_len)
+{
+       /* We use the same address as our HW MAC address */
+       memcpy(command, net->dev_addr, ETH_ALEN);
+       return ETH_ALEN;
+}
+
+static int rtw_android_set_block(struct net_device *net, char *command,
+                                int total_len)
+{
+       return 0;
+}
+
+int rtw_android_priv_cmd(struct net_device *net, struct ifreq *ifr, int cmd)
+{
+       int ret = 0;
+       char *command = NULL;
+       int cmd_num;
+       int bytes_written = 0;
+       struct android_wifi_priv_cmd priv_cmd;
+
+       rtw_lock_suspend();
+       if (!ifr->ifr_data) {
+               ret = -EINVAL;
+               goto exit;
+       }
+       if (copy_from_user(&priv_cmd, ifr->ifr_data,
+                          sizeof(struct android_wifi_priv_cmd))) {
+               ret = -EFAULT;
+               goto exit;
+       }
+       command = kmalloc(priv_cmd.total_len, GFP_KERNEL);
+       if (!command) {
+               DBG_88E("%s: failed to allocate memory\n", __func__);
+               ret = -ENOMEM;
+               goto exit;
+       }
+       if (!access_ok(VERIFY_READ, priv_cmd.buf, priv_cmd.total_len)) {
+               DBG_88E("%s: failed to access memory\n", __func__);
+               ret = -EFAULT;
+               goto exit;
+       }
+       if (copy_from_user(command, (char __user *)priv_cmd.buf,
+                          priv_cmd.total_len)) {
+               ret = -EFAULT;
+               goto exit;
+       }
+       DBG_88E("%s: Android private cmd \"%s\" on %s\n",
+               __func__, command, ifr->ifr_name);
+       cmd_num = rtw_android_cmdstr_to_num(command);
+       switch (cmd_num) {
+       case ANDROID_WIFI_CMD_START:
+               goto response;
+       case ANDROID_WIFI_CMD_SETFWPATH:
+               goto response;
+       }
+       if (!g_wifi_on) {
+               DBG_88E("%s: Ignore private cmd \"%s\" - iface %s is down\n",
+                       __func__, command, ifr->ifr_name);
+               ret = 0;
+               goto exit;
+       }
+       switch (cmd_num) {
+       case ANDROID_WIFI_CMD_STOP:
+               break;
+       case ANDROID_WIFI_CMD_SCAN_ACTIVE:
+               break;
+       case ANDROID_WIFI_CMD_SCAN_PASSIVE:
+               break;
+       case ANDROID_WIFI_CMD_RSSI:
+               bytes_written = rtw_android_get_rssi(net, command,
+                                                    priv_cmd.total_len);
+               break;
+       case ANDROID_WIFI_CMD_LINKSPEED:
+               bytes_written = rtw_android_get_link_speed(net, command,
+                                                          priv_cmd.total_len);
+               break;
+       case ANDROID_WIFI_CMD_MACADDR:
+               bytes_written = rtw_android_get_macaddr(net, command,
+                                                       priv_cmd.total_len);
+               break;
+       case ANDROID_WIFI_CMD_BLOCK:
+               bytes_written = rtw_android_set_block(net, command,
+                                                     priv_cmd.total_len);
+               break;
+       case ANDROID_WIFI_CMD_RXFILTER_START:
+               break;
+       case ANDROID_WIFI_CMD_RXFILTER_STOP:
+               break;
+       case ANDROID_WIFI_CMD_RXFILTER_ADD:
+               break;
+       case ANDROID_WIFI_CMD_RXFILTER_REMOVE:
+               break;
+       case ANDROID_WIFI_CMD_BTCOEXSCAN_START:
+               /* TBD: BTCOEXSCAN-START */
+               break;
+       case ANDROID_WIFI_CMD_BTCOEXSCAN_STOP:
+               /* TBD: BTCOEXSCAN-STOP */
+               break;
+       case ANDROID_WIFI_CMD_BTCOEXMODE:
+               break;
+       case ANDROID_WIFI_CMD_SETSUSPENDOPT:
+               break;
+       case ANDROID_WIFI_CMD_SETBAND:
+               break;
+       case ANDROID_WIFI_CMD_GETBAND:
+               break;
+       case ANDROID_WIFI_CMD_COUNTRY:
+               bytes_written = android_set_cntry(net, command,
+                                                 priv_cmd.total_len);
+               break;
+       case ANDROID_WIFI_CMD_P2P_DEV_ADDR:
+               bytes_written = android_get_p2p_addr(net, command,
+                                                    priv_cmd.total_len);
+               break;
+       case ANDROID_WIFI_CMD_P2P_SET_NOA:
+               break;
+       case ANDROID_WIFI_CMD_P2P_GET_NOA:
+               break;
+       case ANDROID_WIFI_CMD_P2P_SET_PS:
+               break;
+       default:
+               DBG_88E("Unknown PRIVATE command %s - ignored\n", command);
+               snprintf(command, 3, "OK");
+               bytes_written = strlen("OK");
+       }
+
+response:
+       if (bytes_written >= 0) {
+               if ((bytes_written == 0) && (priv_cmd.total_len > 0))
+                       command[0] = '\0';
+               if (bytes_written >= priv_cmd.total_len) {
+                       DBG_88E("%s: bytes_written = %d\n", __func__,
+                               bytes_written);
+                       bytes_written = priv_cmd.total_len;
+               } else {
+                       bytes_written++;
+               }
+               priv_cmd.used_len = bytes_written;
+               if (copy_to_user((char __user *)priv_cmd.buf, command,
+                                bytes_written)) {
+                       DBG_88E("%s: failed to copy data to user buffer\n",
+                               __func__);
+                       ret = -EFAULT;
+               }
+       } else {
+               ret = bytes_written;
+       }
+exit:
+       rtw_unlock_suspend();
+       kfree(command);
+       return ret;
+}