microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

staging: r8723au: Add source files for new driver - part 3 

The Realtek USB device RTL8723AU is found in Lenovo Yoga 13 tablets.
A driver for it has been available in a GitHub repo for several months.
This commit contains the third part of source files. The source
is arbitrarily split to avoid E-mail files that are too large.

Jes Sorensen at RedHat has made many improvements to the vendor code,
and he has been doing the testing. I do not have access to this device.

Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Cc: Jes Sorensen <Jes.Sorensen@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Larry Finger 2014-03-28 21:37:40 -05:00 коммит произвёл Greg Kroah-Hartman
Родитель f7c92d2cc2
Коммит b1925ad846
8 изменённых файлов: 7626 добавлений и 0 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4501
drivers/staging/rtl8723au/os_dep/ioctl_cfg80211.c Normal file
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

187
drivers/staging/rtl8723au/os_dep/mlme_linux.c Normal file
Просмотреть файл

@ -0,0 +1,187 @@
/******************************************************************************
*
* 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.
*
******************************************************************************/
#define _MLME_OSDEP_C_
#include <osdep_service.h>
#include <drv_types.h>
#include <mlme_osdep.h>
#include <rtw_ioctl_set.h>
void rtw_os_indicate_connect23a(struct rtw_adapter *adapter)
{
rtw_cfg80211_indicate_connect(adapter);
netif_carrier_on(adapter->pnetdev);
if (adapter->pid[2] != 0)
rtw_signal_process(adapter->pid[2], SIGALRM);
}
void rtw_os_indicate_scan_done23a(struct rtw_adapter *padapter, bool aborted)
{
rtw_cfg80211_indicate_scan_done(wdev_to_priv(padapter->rtw_wdev),
aborted);
}
static struct rt_pmkid_list backupPMKIDList[NUM_PMKID_CACHE];
void rtw_reset_securitypriv23a(struct rtw_adapter *adapter)
{
u8 backupPMKIDIndex = 0;
u8 backupTKIPCountermeasure = 0x00;
unsigned long backupTKIPcountermeasure_time = 0;
if (adapter->securitypriv.dot11AuthAlgrthm ==
dot11AuthAlgrthm_8021X) { /* 802.1x */
/* We have to backup the PMK information for WiFi PMK
* Caching test item.
* Backup the btkip_countermeasure information.
* When the countermeasure is trigger, the driver have to
* disconnect with AP for 60 seconds.
*/
memset(&backupPMKIDList[0], 0x00, sizeof(struct rt_pmkid_list) *
NUM_PMKID_CACHE);
memcpy(&backupPMKIDList[0], &adapter->securitypriv.PMKIDList[0],
sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
backupPMKIDIndex = adapter->securitypriv.PMKIDIndex;
backupTKIPCountermeasure = adapter->securitypriv.btkip_countermeasure;
backupTKIPcountermeasure_time = adapter->securitypriv.btkip_countermeasure_time;
memset((unsigned char *)&adapter->securitypriv, 0,
sizeof (struct security_priv));
/* Restore the PMK information to securitypriv structure
* for the following connection.
*/
memcpy(&adapter->securitypriv.PMKIDList[0], &backupPMKIDList[0],
sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
adapter->securitypriv.PMKIDIndex = backupPMKIDIndex;
adapter->securitypriv.btkip_countermeasure = backupTKIPCountermeasure;
adapter->securitypriv.btkip_countermeasure_time = backupTKIPcountermeasure_time;
adapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
adapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
} else { /* reset values in securitypriv */
struct security_priv *psec_priv = &adapter->securitypriv;
/* open system */
psec_priv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
psec_priv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
psec_priv->dot11PrivacyKeyIndex = 0;
psec_priv->dot118021XGrpPrivacy = _NO_PRIVACY_;
psec_priv->dot118021XGrpKeyid = 1;
psec_priv->ndisauthtype = Ndis802_11AuthModeOpen;
psec_priv->ndisencryptstatus = Ndis802_11WEPDisabled;
}
}
void rtw_os_indicate_disconnect23a(struct rtw_adapter *adapter)
{
/* Do it first for tx broadcast pkt after disconnection issue! */
netif_carrier_off(adapter->pnetdev);
rtw_cfg80211_indicate_disconnect(adapter);
rtw_reset_securitypriv23a(adapter);
}
void rtw_report_sec_ie23a(struct rtw_adapter *adapter, u8 authmode, u8 *sec_ie)
{
uint len;
u8 *buff, *p, i;
union iwreq_data wrqu;
RT_TRACE(_module_mlme_osdep_c_, _drv_info_,
("+rtw_report_sec_ie23a, authmode =%d\n", authmode));
buff = NULL;
if (authmode == _WPA_IE_ID_) {
RT_TRACE(_module_mlme_osdep_c_, _drv_info_,
("rtw_report_sec_ie23a, authmode =%d\n", authmode));
buff = kzalloc(IW_CUSTOM_MAX, GFP_KERNEL);
if (!buff)
return;
p = buff;
p += sprintf(p, "ASSOCINFO(ReqIEs =");
len = sec_ie[1]+2;
len = (len < IW_CUSTOM_MAX) ? len : IW_CUSTOM_MAX;
for (i = 0; i < len; i++)
p += sprintf(p, "%02x", sec_ie[i]);
p += sprintf(p, ")");
memset(&wrqu, 0, sizeof(wrqu));
wrqu.data.length = p-buff;
wrqu.data.length = (wrqu.data.length < IW_CUSTOM_MAX) ?
wrqu.data.length : IW_CUSTOM_MAX;
kfree(buff);
}
}
#ifdef CONFIG_8723AU_AP_MODE
void rtw_indicate_sta_assoc_event23a(struct rtw_adapter *padapter,
struct sta_info *psta)
{
struct sta_priv *pstapriv = &padapter->stapriv;
union iwreq_data wrqu;
if (psta == NULL)
return;
if (psta->aid > NUM_STA)
return;
if (pstapriv->sta_aid[psta->aid - 1] != psta)
return;
wrqu.addr.sa_family = ARPHRD_ETHER;
memcpy(wrqu.addr.sa_data, psta->hwaddr, ETH_ALEN);
DBG_8723A("+rtw_indicate_sta_assoc_event23a\n");
}
void rtw_indicate_sta_disassoc_event23a(struct rtw_adapter *padapter,
struct sta_info *psta)
{
struct sta_priv *pstapriv = &padapter->stapriv;
union iwreq_data wrqu;
if (psta == NULL)
return;
if (psta->aid > NUM_STA)
return;
if (pstapriv->sta_aid[psta->aid - 1] != psta)
return;
wrqu.addr.sa_family = ARPHRD_ETHER;
memcpy(wrqu.addr.sa_data, psta->hwaddr, ETH_ALEN);
DBG_8723A("+rtw_indicate_sta_disassoc_event23a\n");
}
#endif

970
drivers/staging/rtl8723au/os_dep/os_intfs.c Normal file
Просмотреть файл

@ -0,0 +1,970 @@
/******************************************************************************
*
* 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.
*
******************************************************************************/
#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_version.h>
#include <ethernet.h>
#include <usb_osintf.h>
#include <linux/version.h>
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
MODULE_AUTHOR("Realtek Semiconductor Corp.");
MODULE_AUTHOR("Larry Finger <Larry.Finger@lwfinger.net>");
MODULE_AUTHOR("Jes Sorensen <Jes.Sorensen@redhat.com>");
MODULE_VERSION(DRIVERVERSION);
MODULE_FIRMWARE("rtlwifi/rtl8821aefw.bin");
/* module param defaults */
static int rtw_chip_version = 0x00;
static int rtw_rfintfs = HWPI;
static int rtw_debug = 1;
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_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_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;
int rtw_ht_enable23A = 1;
/* 0 :diable, bit(0): enable 2.4g, bit(1): enable 5g */
int rtw_cbw40_enable23A = 3;
int rtw_ampdu_enable23A = 1;/* for enable tx_ampdu */
/* 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_rx_stbc = 1;
static int rtw_ampdu_amsdu;/* 0: disabled, 1:enabled, 2:auto */
/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
static int rtw_lowrate_two_xmit = 1;
/* int rf_config = RF_1T2R; 1T2R */
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;
#ifdef CONFIG_8723AU_BT_COEXIST
static int rtw_btcoex_enable = 1;
static int rtw_bt_iso = 2;/* 0:Low, 1:High, 2:From Efuse */
/* 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter, 4.Busy, 5.OtherBusy */
static int rtw_bt_sco = 3;
/* 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU. */
static int rtw_bt_ampdu = 1 ;
#endif
/* 0:Reject AP's Add BA req, 1:Accept AP's Add BA req. */
static int rtw_AcceptAddbaReq = true;
static int rtw_antdiv_cfg = 2; /* 0:OFF , 1:ON, 2:decide by Efuse config */
static int rtw_antdiv_type; /* 0:decide by efuse */
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;
static int rtw_80211d;
static int rtw_regulatory_id = 0xff;/* Regulatory tab id, 0xff = follow efuse's setting */
module_param(rtw_regulatory_id, int, 0644);
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");
module_param(rtw_channel_plan, int, 0644);
module_param(rtw_chip_version, int, 0644);
module_param(rtw_rfintfs, int, 0644);
module_param(rtw_channel, 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_enable23A, int, 0644);
module_param(rtw_cbw40_enable23A, int, 0644);
module_param(rtw_ampdu_enable23A, 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_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");
module_param(rtw_80211d, int, 0644);
MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
#ifdef CONFIG_8723AU_BT_COEXIST
module_param(rtw_btcoex_enable, int, 0644);
MODULE_PARM_DESC(rtw_btcoex_enable, "Enable BT co-existence mechanism");
#endif
static uint 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)");
static int netdev_close(struct net_device *pnetdev);
static uint loadparam(struct rtw_adapter *padapter, struct net_device *pnetdev)
{
struct registry_priv *registry_par = &padapter->registrypriv;
uint status = _SUCCESS;
GlobalDebugLevel23A = rtw_debug;
registry_par->chip_version = (u8)rtw_chip_version;
registry_par->rfintfs = (u8)rtw_rfintfs;
memcpy(registry_par->ssid.ssid, "ANY", 3);
registry_par->ssid.ssid_len = 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->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->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->ht_enable = (u8)rtw_ht_enable23A;
registry_par->cbw40_enable = (u8)rtw_cbw40_enable23A;
registry_par->ampdu_enable = (u8)rtw_ampdu_enable23A;
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;
#ifdef CONFIG_8723AU_BT_COEXIST
registry_par->btcoex = (u8)rtw_btcoex_enable;
registry_par->bt_iso = (u8)rtw_bt_iso;
registry_par->bt_sco = (u8)rtw_bt_sco;
registry_par->bt_ampdu = (u8)rtw_bt_ampdu;
#endif
registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq;
registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
registry_par->antdiv_type = (u8)rtw_antdiv_type;
/* 0:disable, 1:enable, 2:by EFUSE config */
registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;
/* 0:disable, 1:enable */
registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;
registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
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;
registry_par->regulatory_tid = (u8)rtw_regulatory_id;
return status;
}
static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
{
struct rtw_adapter *padapter = netdev_priv(pnetdev);
struct sockaddr *addr = p;
if (!padapter->bup)
ether_addr_copy(padapter->eeprompriv.mac_addr, addr->sa_data);
return 0;
}
static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
{
struct rtw_adapter *padapter = netdev_priv(pnetdev);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct recv_priv *precvpriv = &padapter->recvpriv;
padapter->stats.tx_packets = pxmitpriv->tx_pkts;
padapter->stats.rx_packets = 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,
void *accel_priv,
select_queue_fallback_t fallback)
{
struct rtw_adapter *padapter = netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
skb->priority = rtw_classify8021d(skb);
if (pmlmepriv->acm_mask != 0)
skb->priority = qos_acm23a(pmlmepriv->acm_mask, skb->priority);
return rtw_1d_to_queue[skb->priority];
}
u16 rtw_recv_select_queue23a(struct sk_buff *skb)
{
struct iphdr *piphdr;
unsigned int dscp;
u16 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_open23a,
.ndo_stop = netdev_close,
.ndo_start_xmit = rtw_xmit23a_entry23a,
.ndo_select_queue = rtw_select_queue,
.ndo_set_mac_address = rtw_net_set_mac_address,
.ndo_get_stats = rtw_net_get_stats,
};
int rtw_init_netdev23a_name23a(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;
}
static const struct device_type wlan_type = {
.name = "wlan",
};
struct net_device *rtw_init_netdev23a(struct rtw_adapter *old_padapter)
{
struct rtw_adapter *padapter;
struct net_device *pnetdev;
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+init_net_dev\n"));
pnetdev = alloc_etherdev_mq(sizeof(struct rtw_adapter), 4);
if (!pnetdev)
return NULL;
pnetdev->dev.type = &wlan_type;
padapter = netdev_priv(pnetdev);
padapter->pnetdev = pnetdev;
DBG_8723A("register rtw_netdev_ops to netdev_ops\n");
pnetdev->netdev_ops = &rtw_netdev_ops;
pnetdev->watchdog_timeo = HZ*3; /* 3 second timeout */
/* step 2. */
loadparam(padapter, pnetdev);
return pnetdev;
}
u32 rtw_start_drv_threads23a(struct rtw_adapter *padapter)
{
u32 _status = _SUCCESS;
RT_TRACE(_module_os_intfs_c_, _drv_info_,
("+rtw_start_drv_threads23a\n"));
padapter->cmdThread = kthread_run(rtw_cmd_thread23a, padapter,
"RTW_CMD_THREAD");
if (IS_ERR(padapter->cmdThread)) {
_status = _FAIL;
} else {
/* wait for cmd_thread to run */
down(&padapter->cmdpriv.terminate_cmdthread_sema);
}
rtw_hal_start_thread23a(padapter);
return _status;
}
void rtw_stop_drv_threads23a(struct rtw_adapter *padapter)
{
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_stop_drv_threads23a\n"));
/* Below is to termindate rtw_cmd_thread23a & event_thread... */
up(&padapter->cmdpriv.cmd_queue_sema);
if (padapter->cmdThread)
down(&padapter->cmdpriv.terminate_cmdthread_sema);
rtw_hal_stop_thread23a(padapter);
}
static u8 rtw_init_default_value(struct rtw_adapter *padapter)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
u8 ret = _SUCCESS;
/* xmit_priv */
pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
pxmitpriv->vcs = pregistrypriv->vcs_type;
pxmitpriv->vcs_type = pregistrypriv->vcs_type;
/* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
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;
/* open system */
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
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_network23a(padapter);
rtw_update_registrypriv_dev_network23a(padapter);
/* hal_priv */
rtw_hal_def_value_init23a(padapter);
/* misc. */
padapter->bReadPortCancel = false;
padapter->bWritePortCancel = false;
padapter->bRxRSSIDisplay = 0;
padapter->bNotifyChannelChange = 0;
#ifdef CONFIG_8723AU_P2P
padapter->bShowGetP2PState = 1;
#endif
return ret;
}
u8 rtw_reset_drv_sw23a(struct rtw_adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
u8 ret8 = _SUCCESS;
/* hal_priv */
rtw_hal_def_value_init23a(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_reset23a_value23a(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_sw23a(struct rtw_adapter *padapter)
{
u8 ret8 = _SUCCESS;
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_init_drv_sw23a\n"));
if ((rtw_init_cmd_priv23a(&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_priv23a(&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_priv23a(padapter) == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("\n Can't init mlme_priv\n"));
ret8 = _FAIL;
goto exit;
}
#ifdef CONFIG_8723AU_P2P
rtw_init_wifidirect_timers23a(padapter);
init_wifidirect_info23a(padapter, P2P_ROLE_DISABLE);
reset_global_wifidirect_info23a(padapter);
rtw_init_cfg80211_wifidirect_info(padapter);
#ifdef CONFIG_8723AU_P2P
if (rtw_init_wifi_display_info(padapter) == _FAIL)
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("\n Can't init init_wifi_display_info\n"));
#endif
#endif /* CONFIG_8723AU_P2P */
if (init_mlme_ext_priv23a(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_priv23a(&padapter->xmitpriv, padapter) == _FAIL) {
DBG_8723A("Can't _rtw_init_xmit_priv23a\n");
ret8 = _FAIL;
goto exit;
}
if (_rtw_init_recv_priv23a(&padapter->recvpriv, padapter) == _FAIL) {
DBG_8723A("Can't _rtw_init_recv_priv23a\n");
ret8 = _FAIL;
goto exit;
}
if (_rtw_init_sta_priv23a(&padapter->stapriv) == _FAIL) {
DBG_8723A("Can't _rtw_init_sta_priv23a\n");
ret8 = _FAIL;
goto exit;
}
padapter->stapriv.padapter = padapter;
padapter->setband = GHZ24_50;
rtw_init_bcmc_stainfo23a(padapter);
rtw_init_pwrctrl_priv23a(padapter);
ret8 = rtw_init_default_value(padapter);
rtw_hal_dm_init23a(padapter);
rtw_hal_sw_led_init23a(padapter);
rtw_hal_sreset_init23a(padapter);
exit:
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_init_drv_sw23a\n"));
return ret8;
}
void rtw_cancel_all_timer23a(struct rtw_adapter *padapter)
{
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_cancel_all_timer23a\n"));
del_timer_sync(&padapter->mlmepriv.assoc_timer);
RT_TRACE(_module_os_intfs_c_, _drv_info_,
("rtw_cancel_all_timer23a:cancel association timer complete!\n"));
del_timer_sync(&padapter->mlmepriv.scan_to_timer);
RT_TRACE(_module_os_intfs_c_, _drv_info_,
("rtw_cancel_all_timer23a:cancel scan_to_timer!\n"));
del_timer_sync(&padapter->mlmepriv.dynamic_chk_timer);
RT_TRACE(_module_os_intfs_c_, _drv_info_,
("rtw_cancel_all_timer23a:cancel dynamic_chk_timer!\n"));
/* cancel sw led timer */
rtw_hal_sw_led_deinit23a(padapter);
RT_TRACE(_module_os_intfs_c_, _drv_info_,
("rtw_cancel_all_timer23a:cancel DeInitSwLeds!\n"));
del_timer_sync(&padapter->pwrctrlpriv.pwr_state_check_timer);
#ifdef CONFIG_8723AU_P2P
del_timer_sync(&padapter->cfg80211_wdinfo.remain_on_ch_timer);
#endif /* CONFIG_8723AU_P2P */
del_timer_sync(&padapter->mlmepriv.set_scan_deny_timer);
rtw_clear_scan_deny(padapter);
RT_TRACE(_module_os_intfs_c_, _drv_info_,
("rtw_cancel_all_timer23a:cancel set_scan_deny_timer!\n"));
del_timer_sync(&padapter->recvpriv.signal_stat_timer);
/* cancel dm timer */
rtw_hal_dm_deinit23a(padapter);
}
u8 rtw_free_drv_sw23a(struct rtw_adapter *padapter)
{
#ifdef CONFIG_8723AU_P2P
struct wifidirect_info *pwdinfo;
#endif
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("==>rtw_free_drv_sw23a"));
/* we can call rtw_p2p_enable23a here, but:
* 1. rtw_p2p_enable23a may have IO operation
* 2. rtw_p2p_enable23a is bundled with wext interface
*/
#ifdef CONFIG_8723AU_P2P
pwdinfo = &padapter->wdinfo;
if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) {
del_timer_sync(&pwdinfo->find_phase_timer);
del_timer_sync(&pwdinfo->restore_p2p_state_timer);
del_timer_sync(&pwdinfo->pre_tx_scan_timer);
rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
}
#endif
free_mlme_ext_priv23a(&padapter->mlmeextpriv);
rtw_free_cmd_priv23a(&padapter->cmdpriv);
rtw_free_evt_priv23a(&padapter->evtpriv);
rtw_free_mlme_priv23a(&padapter->mlmepriv);
_rtw_free_xmit_priv23a(&padapter->xmitpriv);
_rtw_free_sta_priv23a(&padapter->stapriv);/* will free bcmc_stainfo here */
_rtw_free_recv_priv23a(&padapter->recvpriv);
rtw_free_pwrctrl_priv(padapter);
rtw_hal_free_data23a(padapter);
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("<== rtw_free_drv_sw23a\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 pbuddy_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_sw23a\n"));
return _SUCCESS;
}
static int _rtw_drv_register_netdev(struct rtw_adapter *padapter, char *name)
{
struct net_device *pnetdev = padapter->pnetdev;
int ret = _SUCCESS;
/* alloc netdev name */
rtw_init_netdev23a_name23a(pnetdev, name);
ether_addr_copy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr);
/* Tell the network stack we exist */
if (register_netdev(pnetdev)) {
DBG_8723A(FUNC_NDEV_FMT "Failed!\n", FUNC_NDEV_ARG(pnetdev));
ret = _FAIL;
goto error_register_netdev;
}
DBG_8723A("%s, MAC Address (if%d) = " MAC_FMT "\n", __func__,
(padapter->iface_id + 1), MAC_ARG(pnetdev->dev_addr));
return ret;
error_register_netdev:
if (padapter->iface_id > IFACE_ID0) {
rtw_free_drv_sw23a(padapter);
free_netdev(pnetdev);
}
return ret;
}
int rtw_drv_register_netdev(struct rtw_adapter *if1)
{
struct dvobj_priv *dvobj = if1->dvobj;
int i, status = _SUCCESS;
if (dvobj->iface_nums < IFACE_ID_MAX) {
for (i = 0; i < dvobj->iface_nums; i++) {
struct rtw_adapter *padapter = dvobj->padapters[i];
if (padapter) {
char *name;
if (padapter->iface_id == IFACE_ID0)
name = if1->registrypriv.ifname;
else if (padapter->iface_id == IFACE_ID1)
name = if1->registrypriv.if2name;
else
name = "wlan%d";
status = _rtw_drv_register_netdev(padapter,
name);
if (status != _SUCCESS)
break;
}
}
}
return status;
}
int netdev_open23a(struct net_device *pnetdev)
{
struct rtw_adapter *padapter = netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctrlpriv;
int ret = 0;
uint status;
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+871x_drv - dev_open\n"));
DBG_8723A("+871x_drv - drv_open, bup =%d\n", padapter->bup);
mutex_lock(&adapter_to_dvobj(padapter)->hw_init_mutex);
pwrctrlpriv = &padapter->pwrctrlpriv;
if (pwrctrlpriv->ps_flag) {
padapter->net_closed = false;
goto netdev_open23a_normal_process;
}
if (!padapter->bup) {
padapter->bDriverStopped = false;
padapter->bSurpriseRemoved = false;
padapter->bCardDisableWOHSM = false;
status = rtw_hal_init23a(padapter);
if (status == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("rtl871x_hal_init(): Can't init h/w!\n"));
goto netdev_open23a_error;
}
DBG_8723A("MAC Address = "MAC_FMT"\n",
MAC_ARG(pnetdev->dev_addr));
status = rtw_start_drv_threads23a(padapter);
if (status == _FAIL) {
DBG_8723A("Initialize driver software resource Failed!\n");
goto netdev_open23a_error;
}
if (init_hw_mlme_ext23a(padapter) == _FAIL) {
DBG_8723A("can't init mlme_ext_priv\n");
goto netdev_open23a_error;
}
if (padapter->intf_start)
padapter->intf_start(padapter);
rtw_cfg80211_init_wiphy(padapter);
rtw_led_control(padapter, LED_CTL_NO_LINK);
padapter->bup = true;
}
padapter->net_closed = false;
mod_timer(&padapter->mlmepriv.dynamic_chk_timer,
jiffies + msecs_to_jiffies(2000));
padapter->pwrctrlpriv.bips_processing = false;
rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
/* netif_carrier_on(pnetdev);call this func when
rtw23a_joinbss_event_cb return success */
if (!rtw_netif_queue_stopped(pnetdev))
netif_tx_start_all_queues(pnetdev);
else
netif_tx_wake_all_queues(pnetdev);
netdev_open23a_normal_process:
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-871x_drv - dev_open\n"));
DBG_8723A("-871x_drv - drv_open, bup =%d\n", padapter->bup);
exit:
mutex_unlock(&adapter_to_dvobj(padapter)->hw_init_mutex);
return ret;
netdev_open23a_error:
padapter->bup = false;
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("-871x_drv - dev_open, fail!\n"));
DBG_8723A("-871x_drv - drv_open fail, bup =%d\n", padapter->bup);
ret = -1;
goto exit;
}
static int ips_netdrv_open(struct rtw_adapter *padapter)
{
int status = _SUCCESS;
padapter->net_closed = false;
DBG_8723A("===> %s.........\n", __func__);
padapter->bDriverStopped = false;
padapter->bSurpriseRemoved = false;
padapter->bCardDisableWOHSM = false;
status = rtw_hal_init23a(padapter);
if (status == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("ips_netdrv_open(): Can't init h/w!\n"));
goto netdev_open23a_error;
}
if (padapter->intf_start)
padapter->intf_start(padapter);
rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
mod_timer(&padapter->mlmepriv.dynamic_chk_timer,
jiffies + msecs_to_jiffies(5000));
return _SUCCESS;
netdev_open23a_error:
/* padapter->bup = false; */
DBG_8723A("-ips_netdrv_open - drv_open failure, bup =%d\n",
padapter->bup);
return _FAIL;
}
int rtw_ips_pwr_up23a(struct rtw_adapter *padapter)
{
int result;
unsigned long start_time = jiffies;
DBG_8723A("===> rtw_ips_pwr_up23a..............\n");
rtw_reset_drv_sw23a(padapter);
result = ips_netdrv_open(padapter);
rtw_led_control(padapter, LED_CTL_NO_LINK);
DBG_8723A("<=== rtw_ips_pwr_up23a.............. in %dms\n",
jiffies_to_msecs(jiffies - start_time));
return result;
}
void rtw_ips_pwr_down23a(struct rtw_adapter *padapter)
{
unsigned long start_time = jiffies;
DBG_8723A("===> rtw_ips_pwr_down23a...................\n");
padapter->bCardDisableWOHSM = true;
padapter->net_closed = true;
rtw_led_control(padapter, LED_CTL_POWER_OFF);
rtw_ips_dev_unload23a(padapter);
padapter->bCardDisableWOHSM = false;
DBG_8723A("<=== rtw_ips_pwr_down23a..................... in %dms\n",
jiffies_to_msecs(jiffies - start_time));
}
void rtw_ips_dev_unload23a(struct rtw_adapter *padapter)
{
rtw_hal_set_hwreg23a(padapter, HW_VAR_FIFO_CLEARN_UP, NULL);
if (padapter->intf_stop)
padapter->intf_stop(padapter);
/* s5. */
if (!padapter->bSurpriseRemoved)
rtw_hal_deinit23a(padapter);
}
int pm_netdev_open23a(struct net_device *pnetdev, u8 bnormal)
{
int status;
if (bnormal)
status = netdev_open23a(pnetdev);
else
status = (_SUCCESS == ips_netdrv_open(netdev_priv(pnetdev))) ?
(0) : (-1);
return status;
}
static int netdev_close(struct net_device *pnetdev)
{
struct rtw_adapter *padapter = netdev_priv(pnetdev);
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+871x_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_8723A("(2)871x_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))
netif_tx_stop_all_queues(pnetdev);
}
/* s2. */
LeaveAllPowerSaveMode23a(padapter);
rtw_disassoc_cmd23a(padapter, 500, false);
/* s2-2. indicate disconnect to os */
rtw_indicate_disconnect23a(padapter);
/* s2-3. */
rtw_free_assoc_resources23a(padapter, 1);
/* s2-4. */
rtw_free_network_queue23a(padapter, true);
/* Close LED */
rtw_led_control(padapter, LED_CTL_POWER_OFF);
}
#ifdef CONFIG_8723AU_P2P
if (wdev_to_priv(padapter->rtw_wdev)->p2p_enabled)
wdev_to_priv(padapter->rtw_wdev)->p2p_enabled = false;
rtw_p2p_enable23a(padapter, P2P_ROLE_DISABLE);
#endif /* CONFIG_8723AU_P2P */
rtw_scan_abort23a(padapter);
/* set this at the end */
padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR;
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-871x_drv - drv_close\n"));
DBG_8723A("-871x_drv - drv_close, bup =%d\n", padapter->bup);
return 0;
}
void rtw_ndev_destructor(struct net_device *ndev)
{
DBG_8723A(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
kfree(ndev->ieee80211_ptr);
free_netdev(ndev);
}

429
drivers/staging/rtl8723au/os_dep/osdep_service.c Normal file
Просмотреть файл

@ -0,0 +1,429 @@
/******************************************************************************
*
* Copyright(c) 2007 - 2012 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.
*
******************************************************************************/
#define _OSDEP_SERVICE_C_
#include <osdep_service.h>
#include <drv_types.h>
#include <recv_osdep.h>
#include <linux/vmalloc.h>
#define RT_TAG ('1178')
/*
* Translate the OS dependent @param error_code to OS independent RTW_STATUS_CODE23a
* @return: one of RTW_STATUS_CODE23a
*/
inline int RTW_STATUS_CODE23a(int error_code)
{
if (error_code >= 0)
return _SUCCESS;
return _FAIL;
}
inline u8 *_rtw_vmalloc(u32 sz)
{
u8 *pbuf;
pbuf = vmalloc(sz);
return pbuf;
}
inline u8 *_rtw_zvmalloc(u32 sz)
{
u8 *pbuf;
pbuf = _rtw_vmalloc(sz);
if (pbuf != NULL)
memset(pbuf, 0, sz);
return pbuf;
}
inline void _rtw_vmfree(u8 *pbuf, u32 sz)
{
vfree(pbuf);
}
void _rtw_init_queue23a(struct rtw_queue *pqueue)
{
INIT_LIST_HEAD(&pqueue->queue);
spin_lock_init(&pqueue->lock);
}
u32 _rtw_queue_empty23a(struct rtw_queue *pqueue)
{
if (list_empty(&pqueue->queue))
return true;
else
return false;
}
u32 rtw_get_current_time(void)
{
return jiffies;
}
inline u32 rtw_systime_to_ms23a(u32 systime)
{
return systime * 1000 / HZ;
}
inline u32 rtw_ms_to_systime23a(u32 ms)
{
return ms * HZ / 1000;
}
/* the input parameter start use the same unit as returned
* by rtw_get_current_time
*/
inline s32 rtw_get_passing_time_ms23a(u32 start)
{
return rtw_systime_to_ms23a(jiffies-start);
}
inline s32 rtw_get_time_interval_ms23a(u32 start, u32 end)
{
return rtw_systime_to_ms23a(end-start);
}
#define RTW_SUSPEND_LOCK_NAME "rtw_wifi"
inline void rtw_suspend_lock_init(void)
{
}
inline void rtw_suspend_lock_uninit(void)
{
}
inline void rtw_lock_suspend(void)
{
}
inline void rtw_unlock_suspend(void)
{
}
/* Open a file with the specific @param path, @param flag, @param mode
* @param fpp the pointer of struct file pointer to get struct
* file pointer while file opening is success
* @param path the path of the file to open
* @param flag file operation flags, please refer to linux document
* @param mode please refer to linux document
* @return Linux specific error code
*/
static int openFile(struct file **fpp, char *path, int flag, int mode)
{
struct file *fp;
fp = filp_open(path, flag, mode);
if (IS_ERR(fp)) {
*fpp = NULL;
return PTR_ERR(fp);
} else {
*fpp = fp;
return 0;
}
}
/* Close the file with the specific @param fp
* @param fp the pointer of struct file to close
* @return always 0
*/
static int closeFile(struct file *fp)
{
filp_close(fp, NULL);
return 0;
}
static int readFile(struct file *fp, char *buf, int len)
{
int rlen = 0, sum = 0;
if (!fp->f_op || !fp->f_op->read)
return -EPERM;
while (sum < len) {
rlen = fp->f_op->read(fp, buf+sum, len-sum, &fp->f_pos);
if (rlen > 0)
sum += rlen;
else if (0 != rlen)
return rlen;
else
break;
}
return sum;
}
static int writeFile(struct file *fp, char *buf, int len)
{
int wlen = 0, sum = 0;
if (!fp->f_op || !fp->f_op->write)
return -EPERM;
while (sum < len) {
wlen = fp->f_op->write(fp, buf+sum, len-sum, &fp->f_pos);
if (wlen > 0)
sum += wlen;
else if (0 != wlen)
return wlen;
else
break;
}
return sum;
}
/* Test if the specifi @param path is a file and readable
* @param path the path of the file to test
* @return Linux specific error code
*/
static int isFileReadable(char *path)
{
struct file *fp;
int ret = 0;
mm_segment_t oldfs;
char buf;
fp = filp_open(path, O_RDONLY, 0);
if (IS_ERR(fp)) {
ret = PTR_ERR(fp);
} else {
oldfs = get_fs();
set_fs(get_ds());
if (1 != readFile(fp, &buf, 1))
ret = PTR_ERR(fp);
set_fs(oldfs);
filp_close(fp, NULL);
}
return ret;
}
/* Open the file with @param path and retrive the file content into
* memory starting from @param buf for @param sz at most
* @param path the path of the file to open and read
* @param buf the starting address of the buffer to store file content
* @param sz how many bytes to read at most
* @return the byte we've read, or Linux specific error code
*/
static int retriveFromFile(char *path, u8 *buf, u32 sz)
{
int ret = -1;
mm_segment_t oldfs;
struct file *fp;
if (path && buf) {
ret = openFile(&fp, path, O_RDONLY, 0);
if (!ret) {
DBG_8723A("%s openFile path:%s fp =%p\n",
__func__, path, fp);
oldfs = get_fs(); set_fs(get_ds());
ret = readFile(fp, buf, sz);
set_fs(oldfs);
closeFile(fp);
DBG_8723A("%s readFile, ret:%d\n", __func__, ret);
} else {
DBG_8723A("%s openFile path:%s Fail, ret:%d\n",
__func__, path, ret);
}
} else {
DBG_8723A("%s NULL pointer\n", __func__);
ret = -EINVAL;
}
return ret;
}
/* Open the file with @param path and wirte @param sz byte of data starting
* from @param buf into the file
* @param path the path of the file to open and write
* @param buf the starting address of the data to write into file
* @param sz how many bytes to write at most
* @return the byte we've written, or Linux specific error code
*/
static int storeToFile(char *path, u8 *buf, u32 sz)
{
struct file *fp;
int ret = 0;
mm_segment_t oldfs;
if (path && buf) {
ret = openFile(&fp, path, O_CREAT|O_WRONLY, 0666);
if (!ret) {
DBG_8723A("%s openFile path:%s fp =%p\n", __func__,
path, fp);
oldfs = get_fs(); set_fs(get_ds());
ret = writeFile(fp, buf, sz);
set_fs(oldfs);
closeFile(fp);
DBG_8723A("%s writeFile, ret:%d\n", __func__, ret);
} else {
DBG_8723A("%s openFile path:%s Fail, ret:%d\n",
__func__, path, ret);
}
} else {
DBG_8723A("%s NULL pointer\n", __func__);
ret = -EINVAL;
}
return ret;
}
/*
* Test if the specifi @param path is a file and readable
* @param path the path of the file to test
* @return true or false
*/
int rtw_is_file_readable(char *path)
{
if (isFileReadable(path) == 0)
return true;
else
return false;
}
/* Open the file with @param path and retrive the file content into memoryi
* starting from @param buf for @param sz at most
* @param path the path of the file to open and read
* @param buf the starting address of the buffer to store file content
* @param sz how many bytes to read at most
* @return the byte we've read
*/
int rtw_retrive_from_file(char *path, u8 *buf, u32 sz)
{
int ret = retriveFromFile(path, buf, sz);
return ret >= 0 ? ret : 0;
}
/* Open the file with @param path and wirte @param sz byte of
* data starting from @param buf into the file
* @param path the path of the file to open and write
* @param buf the starting address of the data to write into file
* @param sz how many bytes to write at most
* @return the byte we've written
*/
int rtw_store_to_file(char *path, u8 *buf, u32 sz)
{
int ret = storeToFile(path, buf, sz);
return ret >= 0 ? ret : 0;
}
u64 rtw_modular6423a(u64 x, u64 y)
{
return do_div(x, y);
}
u64 rtw_division6423a(u64 x, u64 y)
{
do_div(x, y);
return x;
}
/* rtw_cbuf_full23a - test if cbuf is full
* @cbuf: pointer of struct rtw_cbuf
*
* Returns: true if cbuf is full
*/
inline bool rtw_cbuf_full23a(struct rtw_cbuf *cbuf)
{
return (cbuf->write == cbuf->read-1) ? true : false;
}
/* rtw_cbuf_empty23a - test if cbuf is empty
* @cbuf: pointer of struct rtw_cbuf
*
* Returns: true if cbuf is empty
*/
inline bool rtw_cbuf_empty23a(struct rtw_cbuf *cbuf)
{
return (cbuf->write == cbuf->read) ? true : false;
}
/**
* rtw_cbuf_push23a - push a pointer into cbuf
* @cbuf: pointer of struct rtw_cbuf
* @buf: pointer to push in
*
* Lock free operation, be careful of the use scheme
* Returns: true push success
*/
bool rtw_cbuf_push23a(struct rtw_cbuf *cbuf, void *buf)
{
if (rtw_cbuf_full23a(cbuf))
return _FAIL;
if (0)
DBG_8723A("%s on %u\n", __func__, cbuf->write);
cbuf->bufs[cbuf->write] = buf;
cbuf->write = (cbuf->write+1)%cbuf->size;
return _SUCCESS;
}
/**
* rtw_cbuf_pop23a - pop a pointer from cbuf
* @cbuf: pointer of struct rtw_cbuf
*
* Lock free operation, be careful of the use scheme
* Returns: pointer popped out
*/
void *rtw_cbuf_pop23a(struct rtw_cbuf *cbuf)
{
void *buf;
if (rtw_cbuf_empty23a(cbuf))
return NULL;
if (0)
DBG_8723A("%s on %u\n", __func__, cbuf->read);
buf = cbuf->bufs[cbuf->read];
cbuf->read = (cbuf->read+1)%cbuf->size;
return buf;
}
/**
* rtw_cbuf_alloc23a - allocte a rtw_cbuf with given size and do initialization
* @size: size of pointer
*
* Returns: pointer of srtuct rtw_cbuf, NULL for allocation failure
*/
struct rtw_cbuf *rtw_cbuf_alloc23a(u32 size)
{
struct rtw_cbuf *cbuf;
cbuf = kmalloc(sizeof(*cbuf) + sizeof(void *)*size, GFP_KERNEL);
if (cbuf) {
cbuf->write = 0;
cbuf->read = 0;
cbuf->size = size;
}
return cbuf;
}
/**
* rtw_cbuf_free - free the given rtw_cbuf
* @cbuf: pointer of struct rtw_cbuf to free
*/
void rtw_cbuf_free(struct rtw_cbuf *cbuf)
{
kfree(cbuf);
}

225
drivers/staging/rtl8723au/os_dep/recv_linux.c Normal file
Просмотреть файл

@ -0,0 +1,225 @@
/******************************************************************************
*
* 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.
*
******************************************************************************/
#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>
/* alloc os related resource in struct recv_frame */
int rtw_os_recv_resource_alloc23a(struct rtw_adapter *padapter,
struct recv_frame *precvframe)
{
int res = _SUCCESS;
precvframe->pkt = NULL;
return res;
}
/* alloc os related resource in struct recv_buf */
int rtw_os_recvbuf_resource_alloc23a(struct rtw_adapter *padapter,
struct recv_buf *precvbuf)
{
int res = _SUCCESS;
precvbuf->purb = usb_alloc_urb(0, GFP_KERNEL);
if (precvbuf->purb == NULL)
res = _FAIL;
precvbuf->pskb = NULL;
return res;
}
/* free os related resource in struct recv_buf */
int rtw_os_recvbuf_resource_free23a(struct rtw_adapter *padapter,
struct recv_buf *precvbuf)
{
int ret = _SUCCESS;
usb_free_urb(precvbuf->purb);
if (precvbuf->pskb)
dev_kfree_skb_any(precvbuf->pskb);
return ret;
}
void rtw_handle_tkip_mic_err23a(struct rtw_adapter *padapter, u8 bgroup)
{
enum nl80211_key_type key_type = 0;
union iwreq_data wrqu;
struct iw_michaelmicfailure ev;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
unsigned long cur_time;
if (psecuritypriv->last_mic_err_time == 0) {
psecuritypriv->last_mic_err_time = jiffies;
} else {
cur_time = jiffies;
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 = jiffies;
}
}
if (bgroup)
key_type |= NL80211_KEYTYPE_GROUP;
else
key_type |= NL80211_KEYTYPE_PAIRWISE;
cfg80211_michael_mic_failure(padapter->pnetdev,
(u8 *)&pmlmepriv->assoc_bssid[0],
key_type, -1, NULL, GFP_ATOMIC);
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;
ether_addr_copy(ev.src_addr.sa_data, &pmlmepriv->assoc_bssid[0]);
memset(&wrqu, 0x00, sizeof(wrqu));
wrqu.data.length = sizeof(ev);
}
void rtw_hostapd_mlme_rx23a(struct rtw_adapter *padapter,
struct recv_frame *precv_frame)
{
}
int rtw_recv_indicatepkt23a(struct rtw_adapter *padapter,
struct recv_frame *precv_frame)
{
struct recv_priv *precvpriv;
struct rtw_queue *pfree_recv_queue;
struct sk_buff *skb;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
precvpriv = &(padapter->recvpriv);
pfree_recv_queue = &(precvpriv->free_recv_queue);
skb = precv_frame->pkt;
if (!skb) {
RT_TRACE(_module_recv_osdep_c_, _drv_err_,
("rtw_recv_indicatepkt23a():skb == NULL!!!!\n"));
goto _recv_indicatepkt_drop;
}
RT_TRACE(_module_recv_osdep_c_, _drv_info_,
("rtw_recv_indicatepkt23a():skb != NULL !!!\n"));
RT_TRACE(_module_recv_osdep_c_, _drv_info_,
("rtw_recv_indicatepkt23a():precv_frame->hdr.rx_data =%p\n",
precv_frame->pkt->data));
RT_TRACE(_module_recv_osdep_c_, _drv_info_,
("\n 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) == true) {
struct sk_buff *pskb2 = NULL;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct rx_pkt_attrib *pattrib = &precv_frame->attrib;
int bmcast = is_multicast_ether_addr(pattrib->dst);
/* DBG_8723A("bmcast =%d\n", bmcast); */
if (!ether_addr_equal(pattrib->dst,
myid(&padapter->eeprompriv))) {
/* DBG_8723A("not ap psta =%p, addr =%pM\n", psta, pattrib->dst); */
if (bmcast) {
psta = rtw_get_bcmc_stainfo23a(padapter);
pskb2 = skb_clone(skb, GFP_ATOMIC);
} else {
psta = rtw_get_stainfo23a(pstapriv, pattrib->dst);
}
if (psta) {
struct net_device *pnetdev = padapter->pnetdev;
/* DBG_8723A("directly forwarding to the rtw_xmit23a_entry23a\n"); */
/* skb->ip_summed = CHECKSUM_NONE; */
skb->dev = pnetdev;
skb_set_queue_mapping(skb, rtw_recv_select_queue23a(skb));
rtw_xmit23a_entry23a(skb, pnetdev);
if (bmcast)
skb = pskb2;
else
goto _recv_indicatepkt_end;
}
} else { /* to APself */
/* DBG_8723A("to APSelf\n"); */
}
}
skb->ip_summed = CHECKSUM_NONE;
skb->dev = padapter->pnetdev;
skb->protocol = eth_type_trans(skb, padapter->pnetdev);
netif_rx(skb);
_recv_indicatepkt_end:
precv_frame->pkt = NULL; /* pointers to NULL before rtw_free_recvframe23a() */
rtw_free_recvframe23a(precv_frame, pfree_recv_queue);
RT_TRACE(_module_recv_osdep_c_, _drv_info_,
("\n rtw_recv_indicatepkt23a :after netif_rx!!!!\n"));
return _SUCCESS;
_recv_indicatepkt_drop:
rtw_free_recvframe23a(precv_frame, pfree_recv_queue);
return _FAIL;
}
void rtw_os_read_port23a(struct rtw_adapter *padapter, struct recv_buf *precvbuf)
{
struct recv_priv *precvpriv = &padapter->recvpriv;
/* free skb in recv_buf */
dev_kfree_skb_any(precvbuf->pskb);
precvbuf->pskb = NULL;
rtw_read_port(padapter, precvpriv->ff_hwaddr, 0, precvbuf);
}
void rtw_init_recv_timer23a(struct recv_reorder_ctrl *preorder_ctrl)
{
setup_timer(&preorder_ctrl->reordering_ctrl_timer,
rtw_reordering_ctrl_timeout_handler23a,
(unsigned long)preorder_ctrl);
}

836
drivers/staging/rtl8723au/os_dep/usb_intf.c Normal file
Просмотреть файл

@ -0,0 +1,836 @@
/******************************************************************************
*
* 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.
*
******************************************************************************/
#define _HCI_INTF_C_
#include <osdep_service.h>
#include <drv_types.h>
#include <recv_osdep.h>
#include <xmit_osdep.h>
#include <hal_intf.h>
#include <rtw_version.h>
#include <osdep_intf.h>
#include <usb_vendor_req.h>
#include <usb_ops.h>
#include <usb_osintf.h>
#include <usb_hal.h>
static int rtw_suspend(struct usb_interface *intf, pm_message_t message);
static int rtw_resume(struct usb_interface *intf);
static int rtw_drv_init(struct usb_interface *pusb_intf,
const struct usb_device_id *pdid);
static void rtw_disconnect(struct usb_interface *pusb_intf);
#define USB_VENDER_ID_REALTEK 0x0BDA
#define RTL8723A_USB_IDS \
{USB_DEVICE_AND_INTERFACE_INFO(USB_VENDER_ID_REALTEK, 0x8724, \
0xff, 0xff, 0xff)}, /* 8723AU 1*1 */ \
{USB_DEVICE_AND_INTERFACE_INFO(USB_VENDER_ID_REALTEK, 0x1724, \
0xff, 0xff, 0xff)}, /* 8723AU 1*1 */ \
{USB_DEVICE_AND_INTERFACE_INFO(USB_VENDER_ID_REALTEK, 0x0724, \
0xff, 0xff, 0xff)}, /* 8723AU 1*1 */
static struct usb_device_id rtl8723a_usb_id_tbl[] = {
RTL8723A_USB_IDS
{} /* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, rtl8723a_usb_id_tbl);
static struct usb_driver rtl8723a_usb_drv = {
.name = (char *)"rtl8723au",
.probe = rtw_drv_init,
.disconnect = rtw_disconnect,
.id_table = rtl8723a_usb_id_tbl,
.suspend = rtw_suspend,
.resume = rtw_resume,
.reset_resume = rtw_resume,
};
static struct usb_driver *usb_drv = &rtl8723a_usb_drv;
static inline int RT_usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
{
return (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN;
}
static inline int RT_usb_endpoint_dir_out(const struct usb_endpoint_descriptor *epd)
{
return (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT;
}
static inline int RT_usb_endpoint_xfer_int(const struct usb_endpoint_descriptor *epd)
{
return (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT;
}
static inline int RT_usb_endpoint_xfer_bulk(const struct usb_endpoint_descriptor *epd)
{
return (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK;
}
static inline int RT_usb_endpoint_is_bulk_in(const struct usb_endpoint_descriptor *epd)
{
return RT_usb_endpoint_xfer_bulk(epd) && RT_usb_endpoint_dir_in(epd);
}
static inline int RT_usb_endpoint_is_bulk_out(const struct usb_endpoint_descriptor *epd)
{
return RT_usb_endpoint_xfer_bulk(epd) && RT_usb_endpoint_dir_out(epd);
}
static inline int RT_usb_endpoint_is_int_in(const struct usb_endpoint_descriptor *epd)
{
return RT_usb_endpoint_xfer_int(epd) && RT_usb_endpoint_dir_in(epd);
}
static inline int RT_usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
{
return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
}
static u8 rtw_init_intf_priv(struct dvobj_priv *dvobj)
{
u8 rst = _SUCCESS;
mutex_init(&dvobj->usb_vendor_req_mutex);
dvobj->usb_alloc_vendor_req_buf = kzalloc(MAX_USB_IO_CTL_SIZE,
GFP_KERNEL);
if (dvobj->usb_alloc_vendor_req_buf == NULL) {
DBG_8723A("alloc usb_vendor_req_buf failed... /n");
rst = _FAIL;
goto exit;
}
dvobj->usb_vendor_req_buf =
PTR_ALIGN(dvobj->usb_alloc_vendor_req_buf, ALIGNMENT_UNIT);
exit:
return rst;
}
static u8 rtw_deinit_intf_priv(struct dvobj_priv *dvobj)
{
u8 rst = _SUCCESS;
kfree(dvobj->usb_alloc_vendor_req_buf);
mutex_destroy(&dvobj->usb_vendor_req_mutex);
return rst;
}
static struct dvobj_priv *usb_dvobj_init(struct usb_interface *usb_intf)
{
struct dvobj_priv *pdvobjpriv;
struct usb_device_descriptor *pdev_desc;
struct usb_host_config *phost_conf;
struct usb_config_descriptor *pconf_desc;
struct usb_host_interface *phost_iface;
struct usb_interface_descriptor *piface_desc;
struct usb_host_endpoint *phost_endp;
struct usb_endpoint_descriptor *pendp_desc;
struct usb_device *pusbd;
int i;
int status = _FAIL;
pdvobjpriv = kzalloc(sizeof(*pdvobjpriv), GFP_KERNEL);
if (!pdvobjpriv)
goto exit;
mutex_init(&pdvobjpriv->hw_init_mutex);
mutex_init(&pdvobjpriv->h2c_fwcmd_mutex);
mutex_init(&pdvobjpriv->setch_mutex);
mutex_init(&pdvobjpriv->setbw_mutex);
pdvobjpriv->pusbintf = usb_intf;
pusbd = interface_to_usbdev(usb_intf);
pdvobjpriv->pusbdev = pusbd;
usb_set_intfdata(usb_intf, pdvobjpriv);
pdvobjpriv->RtNumInPipes = 0;
pdvobjpriv->RtNumOutPipes = 0;
pdev_desc = &pusbd->descriptor;
phost_conf = pusbd->actconfig;
pconf_desc = &phost_conf->desc;
phost_iface = &usb_intf->altsetting[0];
piface_desc = &phost_iface->desc;
pdvobjpriv->NumInterfaces = pconf_desc->bNumInterfaces;
pdvobjpriv->InterfaceNumber = piface_desc->bInterfaceNumber;
pdvobjpriv->nr_endpoint = piface_desc->bNumEndpoints;
for (i = 0; i < pdvobjpriv->nr_endpoint; i++) {
phost_endp = phost_iface->endpoint + i;
if (phost_endp) {
pendp_desc = &phost_endp->desc;
DBG_8723A("\nusb_endpoint_descriptor(%d):\n", i);
DBG_8723A("bLength =%x\n", pendp_desc->bLength);
DBG_8723A("bDescriptorType =%x\n",
pendp_desc->bDescriptorType);
DBG_8723A("bEndpointAddress =%x\n",
pendp_desc->bEndpointAddress);
DBG_8723A("wMaxPacketSize =%d\n",
le16_to_cpu(pendp_desc->wMaxPacketSize));
DBG_8723A("bInterval =%x\n", pendp_desc->bInterval);
if (RT_usb_endpoint_is_bulk_in(pendp_desc)) {
DBG_8723A("RT_usb_endpoint_is_bulk_in = %x\n",
RT_usb_endpoint_num(pendp_desc));
pdvobjpriv->RtInPipe[pdvobjpriv->RtNumInPipes] =
RT_usb_endpoint_num(pendp_desc);
pdvobjpriv->RtNumInPipes++;
} else if (RT_usb_endpoint_is_int_in(pendp_desc)) {
DBG_8723A("RT_usb_endpoint_is_int_in = %x, Interval = %x\n",
RT_usb_endpoint_num(pendp_desc),
pendp_desc->bInterval);
pdvobjpriv->RtInPipe[pdvobjpriv->RtNumInPipes] =
RT_usb_endpoint_num(pendp_desc);
pdvobjpriv->RtNumInPipes++;
} else if (RT_usb_endpoint_is_bulk_out(pendp_desc)) {
DBG_8723A("RT_usb_endpoint_is_bulk_out = %x\n",
RT_usb_endpoint_num(pendp_desc));
pdvobjpriv->RtOutPipe[pdvobjpriv->RtNumOutPipes] =
RT_usb_endpoint_num(pendp_desc);
pdvobjpriv->RtNumOutPipes++;
}
pdvobjpriv->ep_num[i] = RT_usb_endpoint_num(pendp_desc);
}
}
DBG_8723A("nr_endpoint =%d, in_num =%d, out_num =%d\n\n",
pdvobjpriv->nr_endpoint, pdvobjpriv->RtNumInPipes,
pdvobjpriv->RtNumOutPipes);
if (pusbd->speed == USB_SPEED_HIGH) {
pdvobjpriv->ishighspeed = true;
DBG_8723A("USB_SPEED_HIGH\n");
} else {
pdvobjpriv->ishighspeed = false;
DBG_8723A("NON USB_SPEED_HIGH\n");
}
if (rtw_init_intf_priv(pdvobjpriv) == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("\n Can't INIT rtw_init_intf_priv\n"));
goto free_dvobj;
}
/* 3 misc */
sema_init(&(pdvobjpriv->usb_suspend_sema), 0);
rtw_reset_continual_urb_error(pdvobjpriv);
usb_get_dev(pusbd);
status = _SUCCESS;
free_dvobj:
if (status != _SUCCESS && pdvobjpriv) {
usb_set_intfdata(usb_intf, NULL);
mutex_destroy(&pdvobjpriv->hw_init_mutex);
mutex_destroy(&pdvobjpriv->h2c_fwcmd_mutex);
mutex_destroy(&pdvobjpriv->setch_mutex);
mutex_destroy(&pdvobjpriv->setbw_mutex);
kfree(pdvobjpriv);
pdvobjpriv = NULL;
}
exit:
return pdvobjpriv;
}
static void usb_dvobj_deinit(struct usb_interface *usb_intf)
{
struct dvobj_priv *dvobj = usb_get_intfdata(usb_intf);
usb_set_intfdata(usb_intf, NULL);
if (dvobj) {
/* Modify condition for 92DU DMDP 2010.11.18, by Thomas */
if ((dvobj->NumInterfaces != 2 && dvobj->NumInterfaces != 3) ||
(dvobj->InterfaceNumber == 1)) {
if (interface_to_usbdev(usb_intf)->state !=
USB_STATE_NOTATTACHED) {
/* If we didn't unplug usb dongle and
* remove/insert module, driver fails on
* sitesurvey for the first time when
* device is up .
* Reset usb port for sitesurvey fail issue.
*/
DBG_8723A("usb attached..., try to reset usb device\n");
usb_reset_device(interface_to_usbdev(usb_intf));
}
}
rtw_deinit_intf_priv(dvobj);
mutex_destroy(&dvobj->hw_init_mutex);
mutex_destroy(&dvobj->h2c_fwcmd_mutex);
mutex_destroy(&dvobj->setch_mutex);
mutex_destroy(&dvobj->setbw_mutex);
kfree(dvobj);
}
usb_put_dev(interface_to_usbdev(usb_intf));
}
static void decide_chip_type_by_usb_device_id(struct rtw_adapter *padapter,
const struct usb_device_id *pdid)
{
padapter->chip_type = NULL_CHIP_TYPE;
hal_set_hw_type(padapter);
}
static void usb_intf_start(struct rtw_adapter *padapter)
{
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+usb_intf_start\n"));
rtw_hal_inirp_init23a(padapter);
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-usb_intf_start\n"));
}
static void usb_intf_stop(struct rtw_adapter *padapter)
{
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+usb_intf_stop\n"));
/* disable_hw_interrupt */
if (!padapter->bSurpriseRemoved) {
/* device still exists, so driver can do i/o operation
* TODO:
*/
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("SurpriseRemoved == false\n"));
}
/* cancel in irp */
rtw_hal_inirp_deinit23a(padapter);
/* cancel out irp */
rtw_write_port_cancel(padapter);
/* todo:cancel other irps */
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-usb_intf_stop\n"));
}
static void rtw_dev_unload(struct rtw_adapter *padapter)
{
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_dev_unload\n"));
if (padapter->bup) {
DBG_8723A("===> rtw_dev_unload\n");
padapter->bDriverStopped = true;
if (padapter->xmitpriv.ack_tx)
rtw_ack_tx_done23a(&padapter->xmitpriv,
RTW_SCTX_DONE_DRV_STOP);
/* s3. */
if (padapter->intf_stop)
padapter->intf_stop(padapter);
/* s4. */
if (!padapter->pwrctrlpriv.bInternalAutoSuspend)
rtw_stop_drv_threads23a(padapter);
/* s5. */
if (!padapter->bSurpriseRemoved) {
rtw_hal_deinit23a(padapter);
padapter->bSurpriseRemoved = true;
}
padapter->bup = false;
} else {
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("r871x_dev_unload():padapter->bup == false\n"));
}
DBG_8723A("<=== rtw_dev_unload\n");
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-rtw_dev_unload\n"));
}
int rtw_hw_suspend23a(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct net_device *pnetdev = padapter->pnetdev;
if ((!padapter->bup) || (padapter->bDriverStopped) ||
(padapter->bSurpriseRemoved)) {
DBG_8723A("padapter->bup =%d bDriverStopped =%d bSurpriseRemoved = %d\n",
padapter->bup, padapter->bDriverStopped,
padapter->bSurpriseRemoved);
goto error_exit;
}
if (padapter) { /* system suspend */
LeaveAllPowerSaveMode23a(padapter);
DBG_8723A("==> rtw_hw_suspend23a\n");
down(&pwrpriv->lock);
pwrpriv->bips_processing = true;
/* padapter->net_closed = true; */
/* s1. */
if (pnetdev) {
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
}
/* s2. */
rtw_disassoc_cmd23a(padapter, 500, false);
/* s2-2. indicate disconnect to os */
/* rtw_indicate_disconnect23a(padapter); */
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (check_fwstate(pmlmepriv, _FW_LINKED)) {
_clr_fwstate_(pmlmepriv, _FW_LINKED);
rtw_led_control(padapter, LED_CTL_NO_LINK);
rtw_os_indicate_disconnect23a(padapter);
/* donnot enqueue cmd */
rtw_lps_ctrl_wk_cmd23a(padapter,
LPS_CTRL_DISCONNECT, 0);
}
}
/* s2-3. */
rtw_free_assoc_resources23a(padapter, 1);
/* s2-4. */
rtw_free_network_queue23a(padapter, true);
rtw_ips_dev_unload23a(padapter);
pwrpriv->rf_pwrstate = rf_off;
pwrpriv->bips_processing = false;
up(&pwrpriv->lock);
} else {
goto error_exit;
}
return 0;
error_exit:
DBG_8723A("%s, failed\n", __func__);
return -1;
}
int rtw_hw_resume23a(struct rtw_adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct net_device *pnetdev = padapter->pnetdev;
if (padapter) { /* system resume */
DBG_8723A("==> rtw_hw_resume23a\n");
down(&pwrpriv->lock);
pwrpriv->bips_processing = true;
rtw_reset_drv_sw23a(padapter);
if (pm_netdev_open23a(pnetdev, false)) {
up(&pwrpriv->lock);
goto error_exit;
}
netif_device_attach(pnetdev);
netif_carrier_on(pnetdev);
if (!rtw_netif_queue_stopped(pnetdev))
netif_tx_start_all_queues(pnetdev);
else
netif_tx_wake_all_queues(pnetdev);
pwrpriv->bkeepfwalive = false;
pwrpriv->brfoffbyhw = false;
pwrpriv->rf_pwrstate = rf_on;
pwrpriv->bips_processing = false;
up(&pwrpriv->lock);
} else {
goto error_exit;
}
return 0;
error_exit:
DBG_8723A("%s, Open net dev failed\n", __func__);
return -1;
}
static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message)
{
struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
struct rtw_adapter *padapter = dvobj->if1;
struct net_device *pnetdev = padapter->pnetdev;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
int ret = 0;
unsigned long start_time = jiffies;
DBG_8723A("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
if ((!padapter->bup) || (padapter->bDriverStopped) ||
(padapter->bSurpriseRemoved)) {
DBG_8723A("padapter->bup =%d bDriverStopped =%d bSurpriseRemoved = %d\n",
padapter->bup, padapter->bDriverStopped,
padapter->bSurpriseRemoved);
goto exit;
}
pwrpriv->bInSuspend = true;
rtw_cancel_all_timer23a(padapter);
LeaveAllPowerSaveMode23a(padapter);
down(&pwrpriv->lock);
/* padapter->net_closed = true; */
/* s1. */
if (pnetdev) {
netif_carrier_off(pnetdev);
netif_tx_stop_all_queues(pnetdev);
}
/* s2. */
rtw_disassoc_cmd23a(padapter, 0, false);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
check_fwstate(pmlmepriv, _FW_LINKED)) {
DBG_8723A("%s:%d %s(%pM), length:%d assoc_ssid.length:%d\n",
__func__, __LINE__,
pmlmepriv->cur_network.network.Ssid.ssid,
pmlmepriv->cur_network.network.MacAddress,
pmlmepriv->cur_network.network.Ssid.ssid_len,
pmlmepriv->assoc_ssid.ssid_len);
rtw_set_roaming(padapter, 1);
}
/* s2-2. indicate disconnect to os */
rtw_indicate_disconnect23a(padapter);
/* s2-3. */
rtw_free_assoc_resources23a(padapter, 1);
/* s2-4. */
rtw_free_network_queue23a(padapter, true);
rtw_dev_unload(padapter);
up(&pwrpriv->lock);
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
rtw_indicate_scan_done23a(padapter, 1);
if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
rtw_indicate_disconnect23a(padapter);
exit:
DBG_8723A("<=== %s return %d.............. in %dms\n", __func__,
ret, jiffies_to_msecs(jiffies - start_time));
return ret;
}
static int rtw_resume(struct usb_interface *pusb_intf)
{
struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
struct rtw_adapter *padapter = dvobj->if1;
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
int ret = 0;
if (pwrpriv->bInternalAutoSuspend)
ret = rtw_resume_process23a(padapter);
else
ret = rtw_resume_process23a(padapter);
return ret;
}
int rtw_resume_process23a(struct rtw_adapter *padapter)
{
struct net_device *pnetdev;
struct pwrctrl_priv *pwrpriv = NULL;
int ret = -1;
unsigned long start_time = jiffies;
DBG_8723A("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
if (!padapter)
goto exit;
pnetdev = padapter->pnetdev;
pwrpriv = &padapter->pwrctrlpriv;
down(&pwrpriv->lock);
rtw_reset_drv_sw23a(padapter);
pwrpriv->bkeepfwalive = false;
DBG_8723A("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive);
if (pm_netdev_open23a(pnetdev, true) != 0)
goto exit;
netif_device_attach(pnetdev);
netif_carrier_on(pnetdev);
up(&pwrpriv->lock);
if (padapter->pid[1] != 0) {
DBG_8723A("pid[1]:%d\n", padapter->pid[1]);
rtw_signal_process(padapter->pid[1], SIGUSR2);
}
rtw23a_roaming(padapter, NULL);
ret = 0;
exit:
if (pwrpriv)
pwrpriv->bInSuspend = false;
DBG_8723A("<=== %s return %d.............. in %dms\n", __func__,
ret, jiffies_to_msecs(jiffies - start_time));
return ret;
}
/*
* drv_init() - a device potentially for us
*
* notes: drv_init() is called when the bus driver has located a card
* for us to support.
* We accept the new device by returning 0.
*/
static struct rtw_adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj,
struct usb_interface *pusb_intf,
const struct usb_device_id *pdid)
{
struct rtw_adapter *padapter = NULL;
struct net_device *pnetdev = NULL;
int status = _FAIL;
pnetdev = rtw_init_netdev23a(padapter);
if (!pnetdev)
goto handle_dualmac;
padapter = netdev_priv(pnetdev);
padapter->dvobj = dvobj;
padapter->bDriverStopped = true;
dvobj->if1 = padapter;
dvobj->padapters[dvobj->iface_nums++] = padapter;
padapter->iface_id = IFACE_ID0;
/* step 1-1., decide the chip_type via vid/pid */
decide_chip_type_by_usb_device_id(padapter, pdid);
if (rtw_handle_dualmac23a(padapter, 1) != _SUCCESS)
goto free_adapter;
SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
if (rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj)))
goto handle_dualmac;
/* step 2. hook HalFunc, allocate HalData */
if (rtl8723au_set_hal_ops(padapter))
return NULL;
padapter->intf_start = &usb_intf_start;
padapter->intf_stop = &usb_intf_stop;
/* step init_io_priv */
rtw_init_io_priv23a(padapter, usb_set_intf_ops);
/* step read_chip_version */
rtw_hal_read_chip_version23a(padapter);
/* step usb endpoint mapping */
rtw_hal_chip_configure23a(padapter);
/* step read efuse/eeprom data and get mac_addr */
rtw_hal_read_chip_info23a(padapter);
/* step 5. */
if (rtw_init_drv_sw23a(padapter) == _FAIL) {
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("Initialize driver software resource Failed!\n"));
goto free_hal_data;
}
#ifdef CONFIG_PM
if (padapter->pwrctrlpriv.bSupportRemoteWakeup) {
dvobj->pusbdev->do_remote_wakeup = 1;
pusb_intf->needs_remote_wakeup = 1;
device_init_wakeup(&pusb_intf->dev, 1);
DBG_8723A("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~~~~\n");
DBG_8723A("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~[%d]~~~\n",
device_may_wakeup(&pusb_intf->dev));
}
#endif
/* 2012-07-11 Move here to prevent the 8723AS-VAU BT
* auto suspend influence
*/
if (usb_autopm_get_interface(pusb_intf) < 0)
DBG_8723A("can't get autopm:\n");
#ifdef CONFIG_8723AU_BT_COEXIST
padapter->pwrctrlpriv.autopm_cnt = 1;
#endif
/* set mac addr */
rtw_macaddr_cfg23a(padapter->eeprompriv.mac_addr);
rtw_init_wifidirect_addrs23a(padapter, padapter->eeprompriv.mac_addr,
padapter->eeprompriv.mac_addr);
DBG_8723A("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n",
padapter->bDriverStopped, padapter->bSurpriseRemoved,
padapter->bup, padapter->hw_init_completed
);
status = _SUCCESS;
free_hal_data:
if (status != _SUCCESS)
kfree(padapter->HalData);
if (status != _SUCCESS) {
rtw_wdev_unregister(padapter->rtw_wdev);
rtw_wdev_free(padapter->rtw_wdev);
}
handle_dualmac:
if (status != _SUCCESS)
rtw_handle_dualmac23a(padapter, 0);
free_adapter:
if (status != _SUCCESS) {
if (pnetdev)
free_netdev(pnetdev);
padapter = NULL;
}
return padapter;
}
static void rtw_usb_if1_deinit(struct rtw_adapter *if1)
{
struct net_device *pnetdev = if1->pnetdev;
struct mlme_priv *pmlmepriv = &if1->mlmepriv;
if (check_fwstate(pmlmepriv, _FW_LINKED))
rtw_disassoc_cmd23a(if1, 0, false);
#ifdef CONFIG_8723AU_AP_MODE
free_mlme_ap_info23a(if1);
#endif
if (pnetdev)
unregister_netdev(pnetdev); /* will call netdev_close() */
rtw_cancel_all_timer23a(if1);
rtw_dev_unload(if1);
DBG_8723A("+r871xu_dev_remove, hw_init_completed =%d\n",
if1->hw_init_completed);
rtw_handle_dualmac23a(if1, 0);
if (if1->rtw_wdev) {
rtw_wdev_unregister(if1->rtw_wdev);
rtw_wdev_free(if1->rtw_wdev);
}
#ifdef CONFIG_8723AU_BT_COEXIST
if (1 == if1->pwrctrlpriv.autopm_cnt) {
usb_autopm_put_interface(adapter_to_dvobj(if1)->pusbintf);
if1->pwrctrlpriv.autopm_cnt--;
}
#endif
rtw_free_drv_sw23a(if1);
if (pnetdev)
free_netdev(pnetdev);
}
static int rtw_drv_init(struct usb_interface *pusb_intf,
const struct usb_device_id *pdid)
{
struct rtw_adapter *if1 = NULL;
struct dvobj_priv *dvobj;
int status = _FAIL;
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_drv_init\n"));
/* Initialize dvobj_priv */
dvobj = usb_dvobj_init(pusb_intf);
if (!dvobj) {
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("initialize device object priv Failed!\n"));
goto exit;
}
if1 = rtw_usb_if1_init(dvobj, pusb_intf, pdid);
if (!if1) {
DBG_8723A("rtw_init_primary_adapter Failed!\n");
goto free_dvobj;
}
/* dev_alloc_name && register_netdev */
status = rtw_drv_register_netdev(if1);
if (status != _SUCCESS)
goto free_if1;
RT_TRACE(_module_hci_intfs_c_, _drv_err_,
("-871x_drv - drv_init, success!\n"));
status = _SUCCESS;
free_if1:
if (status != _SUCCESS && if1)
rtw_usb_if1_deinit(if1);
free_dvobj:
if (status != _SUCCESS)
usb_dvobj_deinit(pusb_intf);
exit:
return status == _SUCCESS ? 0 : -ENODEV;
}
/* dev_remove() - our device is being removed */
static void rtw_disconnect(struct usb_interface *pusb_intf)
{
struct dvobj_priv *dvobj;
struct rtw_adapter *padapter;
struct net_device *pnetdev;
struct mlme_priv *pmlmepriv;
dvobj = usb_get_intfdata(pusb_intf);
if (!dvobj)
return;
padapter = dvobj->if1;
pnetdev = padapter->pnetdev;
pmlmepriv = &padapter->mlmepriv;
usb_set_intfdata(pusb_intf, NULL);
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+dev_remove()\n"));
rtw_pm_set_ips23a(padapter, IPS_NONE);
rtw_pm_set_lps23a(padapter, PS_MODE_ACTIVE);
LeaveAllPowerSaveMode23a(padapter);
rtw_usb_if1_deinit(padapter);
usb_dvobj_deinit(pusb_intf);
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-dev_remove()\n"));
DBG_8723A("-r871xu_dev_remove, done\n");
return;
}
extern int console_suspend_enabled;
static int __init rtw_drv_entry(void)
{
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_drv_entry\n"));
rtw_suspend_lock_init();
return usb_register(usb_drv);
}
static void __exit rtw_drv_halt(void)
{
RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_drv_halt\n"));
DBG_8723A("+rtw_drv_halt\n");
rtw_suspend_lock_uninit();
usb_deregister(usb_drv);
DBG_8723A("-rtw_drv_halt\n");
}
module_init(rtw_drv_entry);
module_exit(rtw_drv_halt);

283
drivers/staging/rtl8723au/os_dep/usb_ops_linux.c Normal file
Просмотреть файл

@ -0,0 +1,283 @@
/******************************************************************************
*
* Copyright(c) 2007 - 2012 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.
*
******************************************************************************/
#define _USB_OPS_LINUX_C_
#include <drv_types.h>
#include <usb_ops_linux.h>
#include <rtw_sreset.h>
unsigned int ffaddr2pipehdl23a(struct dvobj_priv *pdvobj, u32 addr)
{
struct usb_device *pusbd = pdvobj->pusbdev;
unsigned int pipe = 0, ep_num = 0;
if (addr == RECV_BULK_IN_ADDR) {
pipe = usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[0]);
} else if (addr == RECV_INT_IN_ADDR) {
pipe = usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[1]);
} else if (addr < HW_QUEUE_ENTRY) {
ep_num = pdvobj->Queue2Pipe[addr];
pipe = usb_sndbulkpipe(pusbd, ep_num);
}
return pipe;
}
struct zero_bulkout_context {
void *pbuf;
void *purb;
void *pirp;
void *padapter;
};
void usb_read_mem23a(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
{
}
void usb_write_mem23a(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem)
{
}
void usb_read_port_cancel23a(struct intf_hdl *pintfhdl)
{
struct recv_buf *precvbuf;
struct rtw_adapter *padapter = pintfhdl->padapter;
int i;
precvbuf = (struct recv_buf *)padapter->recvpriv.precv_buf;
DBG_8723A("%s\n", __func__);
padapter->bReadPortCancel = true;
for (i = 0; i < NR_RECVBUFF ; i++) {
if (precvbuf->purb)
usb_kill_urb(precvbuf->purb);
precvbuf++;
}
usb_kill_urb(padapter->recvpriv.int_in_urb);
}
static void usb_write_port23a_complete(struct urb *purb, struct pt_regs *regs)
{
struct xmit_buf *pxmitbuf = (struct xmit_buf *)purb->context;
struct rtw_adapter *padapter = pxmitbuf->padapter;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct hal_data_8723a *phaldata;
unsigned long irqL;
switch (pxmitbuf->flags) {
case VO_QUEUE_INX:
pxmitpriv->voq_cnt--;
break;
case VI_QUEUE_INX:
pxmitpriv->viq_cnt--;
break;
case BE_QUEUE_INX:
pxmitpriv->beq_cnt--;
break;
case BK_QUEUE_INX:
pxmitpriv->bkq_cnt--;
break;
case HIGH_QUEUE_INX:
#ifdef CONFIG_8723AU_AP_MODE
rtw_chk_hi_queue_cmd23a(padapter);
#endif
break;
default:
break;
}
if (padapter->bSurpriseRemoved || padapter->bDriverStopped ||
padapter->bWritePortCancel) {
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a_complete:bDriverStopped(%d) OR bSurpriseRemoved(%d)",
padapter->bDriverStopped, padapter->bSurpriseRemoved));
DBG_8723A("%s(): TX Warning! bDriverStopped(%d) OR bSurpriseRemoved(%d) bWritePortCancel(%d) pxmitbuf->ext_tag(%x)\n",
__func__, padapter->bDriverStopped,
padapter->bSurpriseRemoved, padapter->bReadPortCancel,
pxmitbuf->ext_tag);
goto check_completion;
}
if (purb->status) {
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a_complete : purb->status(%d) != 0\n",
purb->status));
DBG_8723A("###=> urb_write_port_complete status(%d)\n",
purb->status);
if ((purb->status == -EPIPE) || (purb->status == -EPROTO)) {
sreset_set_wifi_error_status23a(padapter,
USB_WRITE_PORT_FAIL);
} else if (purb->status == -EINPROGRESS) {
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a_complete: EINPROGESS\n"));
goto check_completion;
} else if (purb->status == -ENOENT) {
DBG_8723A("%s: -ENOENT\n", __func__);
goto check_completion;
} else if (purb->status == -ECONNRESET) {
DBG_8723A("%s: -ECONNRESET\n", __func__);
goto check_completion;
} else if (purb->status == -ESHUTDOWN) {
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a_complete: ESHUTDOWN\n"));
padapter->bDriverStopped = true;
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a_complete:bDriverStopped = true\n"));
goto check_completion;
} else {
padapter->bSurpriseRemoved = true;
DBG_8723A("bSurpriseRemoved = true\n");
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a_complete:bSurpriseRemoved = true\n"));
goto check_completion;
}
}
phaldata = GET_HAL_DATA(padapter);
phaldata->srestpriv.last_tx_complete_time = jiffies;
check_completion:
spin_lock_irqsave(&pxmitpriv->lock_sctx, irqL);
rtw23a_sctx_done_err(&pxmitbuf->sctx,
purb->status ? RTW_SCTX_DONE_WRITE_PORT_ERR :
RTW_SCTX_DONE_SUCCESS);
spin_unlock_irqrestore(&pxmitpriv->lock_sctx, irqL);
rtw_free_xmitbuf23a(pxmitpriv, pxmitbuf);
tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
}
u32 usb_write_port23a(struct intf_hdl *pintfhdl, u32 addr, u32 cnt,
struct xmit_buf *pxmitbuf)
{
struct urb *purb = NULL;
struct rtw_adapter *padapter = (struct rtw_adapter *)pintfhdl->padapter;
struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pxmitframe = (struct xmit_frame *)pxmitbuf->priv_data;
struct usb_device *pusbd = pdvobj->pusbdev;
unsigned long irqL;
unsigned int pipe;
int status;
u32 ret = _FAIL;
RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("+usb_write_port23a\n"));
if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||
(padapter->pwrctrlpriv.pnp_bstop_trx)) {
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a:( padapter->bDriverStopped ||padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n"));
rtw23a_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_TX_DENY);
goto exit;
}
spin_lock_irqsave(&pxmitpriv->lock, irqL);
switch (addr) {
case VO_QUEUE_INX:
pxmitpriv->voq_cnt++;
pxmitbuf->flags = VO_QUEUE_INX;
break;
case VI_QUEUE_INX:
pxmitpriv->viq_cnt++;
pxmitbuf->flags = VI_QUEUE_INX;
break;
case BE_QUEUE_INX:
pxmitpriv->beq_cnt++;
pxmitbuf->flags = BE_QUEUE_INX;
break;
case BK_QUEUE_INX:
pxmitpriv->bkq_cnt++;
pxmitbuf->flags = BK_QUEUE_INX;
break;
case HIGH_QUEUE_INX:
pxmitbuf->flags = HIGH_QUEUE_INX;
break;
default:
pxmitbuf->flags = MGT_QUEUE_INX;
break;
}
spin_unlock_irqrestore(&pxmitpriv->lock, irqL);
purb = pxmitbuf->pxmit_urb[0];
/* translate DMA FIFO addr to pipehandle */
pipe = ffaddr2pipehdl23a(pdvobj, addr);
usb_fill_bulk_urb(purb, pusbd, pipe,
pxmitframe->buf_addr, /* pxmitbuf->pbuf */
cnt, usb_write_port23a_complete,
pxmitbuf);/* context is pxmitbuf */
status = usb_submit_urb(purb, GFP_ATOMIC);
if (!status) {
struct hal_data_8723a *phaldata = GET_HAL_DATA(padapter);
phaldata->srestpriv.last_tx_time = jiffies;
} else {
rtw23a_sctx_done_err(&pxmitbuf->sctx,
RTW_SCTX_DONE_WRITE_PORT_ERR);
DBG_8723A("usb_write_port23a, status =%d\n", status);
RT_TRACE(_module_hci_ops_os_c_, _drv_err_,
("usb_write_port23a(): usb_submit_urb, status =%x\n",
status));
switch (status) {
case -ENODEV:
padapter->bDriverStopped = true;
break;
default:
break;
}
goto exit;
}
ret = _SUCCESS;
RT_TRACE(_module_hci_ops_os_c_, _drv_err_, ("-usb_write_port23a\n"));
exit:
if (ret != _SUCCESS)
rtw_free_xmitbuf23a(pxmitpriv, pxmitbuf);
return ret;
}
void usb_write_port23a_cancel(struct intf_hdl *pintfhdl)
{
struct rtw_adapter *padapter = pintfhdl->padapter;
struct xmit_buf *pxmitbuf;
struct list_head *plist;
int j;
DBG_8723A("%s\n", __func__);
padapter->bWritePortCancel = true;
list_for_each(plist, &padapter->xmitpriv.xmitbuf_list) {
pxmitbuf = container_of(plist, struct xmit_buf, list2);
for (j = 0; j < 8; j++) {
if (pxmitbuf->pxmit_urb[j])
usb_kill_urb(pxmitbuf->pxmit_urb[j]);
}
}
list_for_each(plist, &padapter->xmitpriv.xmitextbuf_list) {
pxmitbuf = container_of(plist, struct xmit_buf, list2);
for (j = 0; j < 8; j++) {
if (pxmitbuf->pxmit_urb[j])
usb_kill_urb(pxmitbuf->pxmit_urb[j]);
}
}
}

195
drivers/staging/rtl8723au/os_dep/xmit_linux.c Normal file
Просмотреть файл

@ -0,0 +1,195 @@
/******************************************************************************
*
* Copyright(c) 2007 - 2012 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.
*
******************************************************************************/
#define _XMIT_OSDEP_C_
#include <osdep_service.h>
#include <drv_types.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <wifi.h>
#include <mlme_osdep.h>
#include <xmit_osdep.h>
#include <osdep_intf.h>
uint rtw_remainder_len23a(struct pkt_file *pfile)
{
return pfile->buf_len - ((unsigned long)(pfile->cur_addr) -
(unsigned long)(pfile->buf_start));
}
void _rtw_open_pktfile23a(struct sk_buff *pktptr, struct pkt_file *pfile)
{
pfile->pkt = pktptr;
pfile->buf_start = pktptr->data;
pfile->cur_addr = pktptr->data;
pfile->buf_len = pktptr->len;
pfile->pkt_len = pktptr->len;
pfile->cur_buffer = pfile->buf_start;
}
uint _rtw_pktfile_read23a(struct pkt_file *pfile, u8 *rmem, uint rlen)
{
uint len = 0;
len = rtw_remainder_len23a(pfile);
len = (rlen > len) ? len : rlen;
if (rmem)
skb_copy_bits(pfile->pkt, pfile->buf_len-pfile->pkt_len,
rmem, len);
pfile->cur_addr += len;
pfile->pkt_len -= len;
return len;
}
int rtw_endofpktfile23a(struct pkt_file *pfile)
{
if (pfile->pkt_len == 0)
return true;
return false;
}
int rtw_os_xmit_resource_alloc23a(struct rtw_adapter *padapter,
struct xmit_buf *pxmitbuf, u32 alloc_sz)
{
int i;
pxmitbuf->pallocated_buf = kzalloc(alloc_sz, GFP_KERNEL);
if (pxmitbuf->pallocated_buf == NULL)
return _FAIL;
pxmitbuf->pbuf = PTR_ALIGN(pxmitbuf->pallocated_buf, XMITBUF_ALIGN_SZ);
for (i = 0; i < 8; i++) {
pxmitbuf->pxmit_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
if (pxmitbuf->pxmit_urb[i] == NULL) {
DBG_8723A("pxmitbuf->pxmit_urb[i]==NULL");
return _FAIL;
}
}
return _SUCCESS;
}
void rtw_os_xmit_resource_free23a(struct rtw_adapter *padapter,
struct xmit_buf *pxmitbuf)
{
int i;
for (i = 0; i < 8; i++)
usb_free_urb(pxmitbuf->pxmit_urb[i]);
kfree(pxmitbuf->pallocated_buf);
}
#define WMM_XMIT_THRESHOLD (NR_XMITFRAME*2/5)
void rtw_os_pkt_complete23a(struct rtw_adapter *padapter, struct sk_buff *pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u16 queue;
queue = skb_get_queue_mapping(pkt);
if (padapter->registrypriv.wifi_spec) {
if (__netif_subqueue_stopped(padapter->pnetdev, queue) &&
(pxmitpriv->hwxmits[queue].accnt < WMM_XMIT_THRESHOLD))
netif_wake_subqueue(padapter->pnetdev, queue);
} else {
if (__netif_subqueue_stopped(padapter->pnetdev, queue))
netif_wake_subqueue(padapter->pnetdev, queue);
}
dev_kfree_skb_any(pkt);
}
void rtw_os_xmit_complete23a(struct rtw_adapter *padapter,
struct xmit_frame *pxframe)
{
if (pxframe->pkt)
rtw_os_pkt_complete23a(padapter, pxframe->pkt);
pxframe->pkt = NULL;
}
void rtw_os_xmit_schedule23a(struct rtw_adapter *padapter)
{
struct xmit_priv *pxmitpriv;
if (!padapter)
return;
pxmitpriv = &padapter->xmitpriv;
spin_lock_bh(&pxmitpriv->lock);
if (rtw_txframes_pending23a(padapter))
tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
spin_unlock_bh(&pxmitpriv->lock);
}
static void rtw_check_xmit_resource(struct rtw_adapter *padapter,
struct sk_buff *pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u16 queue;
queue = skb_get_queue_mapping(pkt);
if (padapter->registrypriv.wifi_spec) {
/* No free space for Tx, tx_worker is too slow */
if (pxmitpriv->hwxmits[queue].accnt > WMM_XMIT_THRESHOLD)
netif_stop_subqueue(padapter->pnetdev, queue);
} else {
if (pxmitpriv->free_xmitframe_cnt <= 4) {
if (!netif_tx_queue_stopped(netdev_get_tx_queue(padapter->pnetdev, queue)))
netif_stop_subqueue(padapter->pnetdev, queue);
}
}
}
int rtw_xmit23a_entry23a(struct sk_buff *skb, struct net_device *pnetdev)
{
struct rtw_adapter *padapter = netdev_priv(pnetdev);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
int res = 0;
RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("+xmit_enry\n"));
if (!rtw_if_up23a(padapter)) {
RT_TRACE(_module_xmit_osdep_c_, _drv_err_,
("rtw_xmit23a_entry23a: rtw_if_up23a fail\n"));
goto drop_packet;
}
rtw_check_xmit_resource(padapter, skb);
res = rtw_xmit23a(padapter, skb);
if (res < 0)
goto drop_packet;
pxmitpriv->tx_pkts++;
RT_TRACE(_module_xmit_osdep_c_, _drv_info_,
("rtw_xmit23a_entry23a: tx_pkts=%d\n",
(u32)pxmitpriv->tx_pkts));
goto exit;
drop_packet:
pxmitpriv->tx_drop++;
dev_kfree_skb_any(skb);
RT_TRACE(_module_xmit_osdep_c_, _drv_notice_,
("rtw_xmit23a_entry23a: drop, tx_drop=%d\n",
(u32)pxmitpriv->tx_drop));
exit:
return 0;
}