From 5adef66acf73705ae95ea0b1e6b5fc7f17d82d30 Mon Sep 17 00:00:00 2001 From: Larry Finger Date: Wed, 21 Aug 2013 22:34:01 -0500 Subject: [PATCH] staging: r8188eu: Add files for new driver - part 19 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 Signed-off-by: Greg Kroah-Hartman --- drivers/staging/rtl8188eu/os_dep/os_intfs.c | 1251 ++++++++++++++++++++++++ drivers/staging/rtl8188eu/os_dep/recv_linux.c | 261 +++++ drivers/staging/rtl8188eu/os_dep/rtw_android.c | 293 ++++++ 3 files changed, 1805 insertions(+) create mode 100644 drivers/staging/rtl8188eu/os_dep/os_intfs.c create mode 100644 drivers/staging/rtl8188eu/os_dep/recv_linux.c create mode 100644 drivers/staging/rtl8188eu/os_dep/rtw_android.c diff --git a/drivers/staging/rtl8188eu/os_dep/os_intfs.c b/drivers/staging/rtl8188eu/os_dep/os_intfs.c new file mode 100644 index 000000000000..63bc913eba6d --- /dev/null +++ b/drivers/staging/rtl8188eu/os_dep/os_intfs.c @@ -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 +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +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(ð_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 index 000000000000..e2f4e7d77170 --- /dev/null +++ b/drivers/staging/rtl8188eu/os_dep/recv_linux.c @@ -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 +#include + +#include +#include + +#include +#include +#include + +/* 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 index 000000000000..6cf71cc2ca2e --- /dev/null +++ b/drivers/staging/rtl8188eu/os_dep/rtw_android.c @@ -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 +#include + +#include +#include +#include +#include +#include + +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; +} -- 2.11.0