netease
/
SmartAudio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SmartAudio/lichee/linux-4.9/drivers/net/wireless/xr829/wlan/txrx.c

3294 lines
89 KiB
C
Executable File
Raw Blame History

/*
* Datapath implementation for XRadio drivers
*
* Copyright (c) 2013
* Xradio Technology Co., Ltd. <www.xradiotech.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <net/mac80211.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include "xradio.h"
#include "wsm.h"
#include "bh.h"
#include "ap.h"
#include "sta.h"
#include "sbus.h"
#ifndef SUPPORT_HT40
#define B_RATE_INDEX 0 /* 11b rate for important short frames in 2.4G. */
#define AG_RATE_INDEX 6 /* 11a/g rate for important short frames in 5G. */
#define XRADIO_INVALID_RATE_ID (0xFF)
#endif
/* rate should fall quickly to avoid dropping frames by aps.*/
#ifdef ENHANCE_ANTI_INTERFERE
#define HIGH_RATE_MAX_RETRY 9
#else
#define HIGH_RATE_MAX_RETRY 7
#endif
#ifdef CONFIG_XRADIO_TESTMODE
#include "nl80211_testmode_msg_copy.h"
#endif /* CONFIG_XRADIO_TESTMODE */
#ifdef TES_P2P_0002_ROC_RESTART
#include <linux/time.h>
#endif
static const struct ieee80211_rate *xradio_get_tx_rate(
const struct xradio_common *hw_priv,
const struct ieee80211_tx_rate *rate);
#ifdef SUPPORT_HT40
u32 TxedHtofdmRateMap[4][8] = { {0x0} };
u32 TxedLegacyRateMap[2][8] = { {0x0} };
u32 RxedHtofdmRateMap[4][8] = { {0x0} };
u32 RxedLegacyRateMap[2][8] = { {0x0} };
u8 LegacyRxedRateLut[2][14] = {
{
0, 1, 2, 3, 0, 0, 4, 5, 6, 7, 8, 9, 10, 11
},
{
0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7
}
};
#else
u32 TxedRateIdx_Map[24] = { 0 };
u32 RxedRateIdx_Map[24] = { 0 };
#endif
/* ******************************************************************** */
/* TX policy cache implementation */
static void tx_policy_dump(struct tx_policy *policy)
{
txrx_printk(XRADIO_DBG_MSG, "[TX policy] "
"%.1X%.1X%.1X%.1X%.1X%.1X%.1X%.1X"
"%.1X%.1X%.1X%.1X%.1X%.1X%.1X%.1X"
"%.1X%.1X%.1X%.1X%.1X%.1X%.1X%.1X: %d\n",
policy->raw[0] & 0x0F, policy->raw[0] >> 4,
policy->raw[1] & 0x0F, policy->raw[1] >> 4,
policy->raw[2] & 0x0F, policy->raw[2] >> 4,
policy->raw[3] & 0x0F, policy->raw[3] >> 4,
policy->raw[4] & 0x0F, policy->raw[4] >> 4,
policy->raw[5] & 0x0F, policy->raw[5] >> 4,
policy->raw[6] & 0x0F, policy->raw[6] >> 4,
policy->raw[7] & 0x0F, policy->raw[7] >> 4,
policy->raw[8] & 0x0F, policy->raw[8] >> 4,
policy->raw[9] & 0x0F, policy->raw[9] >> 4,
policy->raw[10] & 0x0F, policy->raw[10] >> 4,
policy->raw[11] & 0x0F, policy->raw[11] >> 4,
policy->defined);
}
static void xradio_check_go_neg_conf_success(struct xradio_common *hw_priv,
u8 *action)
{
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (action[2] == 0x50 && action[3] == 0x6F && action[4] == 0x9A &&
action[5] == 0x09 && action[6] == 0x02) {
if (action[17] == 0) {
hw_priv->is_go_thru_go_neg = true;
} else {
hw_priv->is_go_thru_go_neg = false;
}
}
}
#ifdef TES_P2P_0002_ROC_RESTART
/*
* TES_P2P_0002 WorkAround:
* P2P GO Neg Process and P2P FIND may be collision.
* When P2P Device is waiting for GO NEG CFM in 30ms,
* P2P FIND may end with p2p listen, and then goes to p2p search.
* Then xradio scan will occupy phy on other channel in 3+ seconds.
* P2P Device will not be able to receive the GO NEG CFM.
* We extend the roc period to remaind phy to receive
* GO NEG CFM as WorkAround.
*/
s32 TES_P2P_0002_roc_dur;
s32 TES_P2P_0002_roc_sec;
s32 TES_P2P_0002_roc_usec;
u32 TES_P2P_0002_packet_id;
u32 TES_P2P_0002_state = TES_P2P_0002_STATE_IDLE;
static void xradio_frame_monitor(struct xradio_common *hw_priv,
struct sk_buff *skb, bool tx)
{
struct ieee80211_hdr *frame = (struct ieee80211_hdr *)skb->data;
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
u8 *action = (u8 *) &mgmt->u.action.category;
u8 *category_code = &(action[0]);
u8 *action_code = &(action[1]);
u8 *oui = &(action[2]);
u8 *subtype = &(action[5]);
u8 *oui_subtype = &(action[6]);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (ieee80211_is_action(frame->frame_control) &&
*category_code == WLAN_CATEGORY_PUBLIC &&
*action_code == 0x09) {
if ((oui[0] == 0x50) && (oui[1] == 0x6F) &&
(oui[2] == 0x9A) && (*subtype == 0x09)) {
/* w, GO Negotiation Response */
if (*oui_subtype == 0x01) {
if ((TES_P2P_0002_state == TES_P2P_0002_STATE_IDLE) &&
(tx == true)) { /* w, p2p atturbute:status,id=0 */
u8 *go_neg_resp_res = &(action[17]);
if (*go_neg_resp_res == 0x0) {
TES_P2P_0002_state = TES_P2P_0002_STATE_SEND_RESP;
txrx_printk(XRADIO_DBG_NIY,
"[ROC_RESTART_STATE_SEND_RESP]\n");
}
}
/* w, GO Negotiation Confirmation */
} else if (*oui_subtype == 0x02) {
if (tx == false) {
TES_P2P_0002_state = TES_P2P_0002_STATE_IDLE;
txrx_printk(XRADIO_DBG_NIY, "[ROC_RESTART_STATE_IDLE]"
"[GO Negotiation Confirmation]\n");
}
/* w, Provision Discovery Response */
} else if (*oui_subtype == 0x08) {
if (tx == false) {
TES_P2P_0002_state = TES_P2P_0002_STATE_IDLE;
txrx_printk(XRADIO_DBG_NIY, "[ROC_RESTART_STATE_IDLE]"
"[Provision Discovery Response]\n");
}
}
}
}
}
#endif
static void xradio_check_prov_desc_req(struct xradio_common *hw_priv,
u8 *action)
{
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (action[2] == 0x50 && action[3] == 0x6F && action[4] == 0x9A &&
action[5] == 0x09 && action[6] == 0x07) {
hw_priv->is_go_thru_go_neg = false;
}
}
#ifdef AP_HT_COMPAT_FIX
#define AP_COMPAT_THRESHOLD 2000
#define AP_COMPAT_MIN_CNT 200
u8 ap_compat_bssid[ETH_ALEN] = { 0 };
#ifdef SUPPORT_HT40
static int xradio_apcompat_detect(struct xradio_vif *priv, u16 rxedRateEntry)
#else
static int xradio_apcompat_detect(struct xradio_vif *priv, u8 rx_rate)
#endif
{
#ifdef SUPPORT_HT40
if ((GET_RATE_ENTRY_MODEM(rxedRateEntry) == FW_RATE_MODEM_LEGACY)
&& (GET_RATE_ENTRY_RATEINDEX(rxedRateEntry) < 6)) {
#else
if (rx_rate < AG_RATE_INDEX) {
#endif
priv->ht_compat_cnt++;
#ifdef SUPPORT_HT40
txrx_printk(XRADIO_DBG_MSG, "%s:rate=%d.\n",
__func__, GET_RATE_ENTRY_RATEINDEX(rxedRateEntry));
#else
txrx_printk(XRADIO_DBG_MSG, "%s:rate=%d.\n", __func__, rx_rate);
#endif
} else {
priv->ht_compat_det |= 1;
priv->ht_compat_cnt = 0;
txrx_printk(XRADIO_DBG_NIY, "%s:HT compat detect\n", __func__);
return 0;
}
/* Enhance compatibility with some illegal APs.*/
if (priv->ht_compat_cnt > AP_COMPAT_THRESHOLD ||
(priv->ht_compat_cnt > AP_COMPAT_MIN_CNT &&
priv->bssid[0] == 0xC8 &&
priv->bssid[1] == 0x3A &&
priv->bssid[2] == 0x35)) {
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
memcpy(ap_compat_bssid, priv->bssid, ETH_ALEN);
wsm_send_disassoc_to_self(hw_priv, priv);
txrx_printk(XRADIO_DBG_WARN, "%s:SSID=%s, BSSID=" \
"%02x:%02x:%02x:%02x:%02x:%02x\n", __func__, priv->ssid,
ap_compat_bssid[0], ap_compat_bssid[1],
ap_compat_bssid[2], ap_compat_bssid[3],
ap_compat_bssid[4], ap_compat_bssid[5]);
return 1;
}
return 0;
}
static void xradio_remove_ht_ie(struct xradio_vif *priv, struct sk_buff *skb)
{
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
u8 *ies = NULL;
size_t ies_len = 0;
u8 *ht_ie = NULL;
if (!mgmt || memcmp(ap_compat_bssid, mgmt->bssid, ETH_ALEN))
return;
if (ieee80211_is_probe_resp(mgmt->frame_control))
ies = mgmt->u.probe_resp.variable;
else if (ieee80211_is_beacon(mgmt->frame_control))
ies = mgmt->u.beacon.variable;
else if (ieee80211_is_assoc_resp(mgmt->frame_control))
ies = mgmt->u.assoc_resp.variable;
else if (ieee80211_is_assoc_req(mgmt->frame_control))
ies = mgmt->u.assoc_req.variable;
else
return;
ies_len = skb->len - (ies - (u8 *)(skb->data));
ht_ie = (u8 *)xradio_get_ie(ies, ies_len, WLAN_EID_HT_CAPABILITY);
if (ht_ie) {
u8 ht_len = *(ht_ie + 1) + 2;
u8 move_len = (ies + ies_len) - (ht_ie + ht_len);
memmove(ht_ie, (ht_ie + ht_len), move_len);
skb_trim(skb, skb->len - ht_len);
ies_len = skb->len - (ies - (u8 *)(skb->data));
ht_ie = (u8 *)xradio_get_ie(ies, ies_len, WLAN_EID_HT_INFORMATION);
if (ht_ie) {
ht_len = *(ht_ie + 1) + 2;
move_len = (ies + ies_len) - (ht_ie + ht_len);
memmove(ht_ie, (ht_ie + ht_len), move_len);
skb_trim(skb, skb->len - ht_len);
}
}
txrx_printk(XRADIO_DBG_WARN, "%s: BSSID=%02x:%02x:%02x:%02x:%02x:%02x\n",
__func__,
mgmt->bssid[0], mgmt->bssid[1],
mgmt->bssid[2], mgmt->bssid[3],
mgmt->bssid[4], mgmt->bssid[5]);
}
#endif /*AP_HT_COMPAT_FIX*/
#ifdef SUPPORT_HT40
static inline u8 xradio_rate_to_entry_idx(u8 flags, u8 hw_value)
{
u8 entryIndex = 0xF;
if (flags & IEEE80211_TX_RC_MCS)
entryIndex = hw_value - MCS_RATES_OFF;
else
entryIndex = hw_value;
return entryIndex;
}
#endif
static void tx_policy_build(struct xradio_vif *priv,
/* [out] */ struct tx_policy *policy,
struct ieee80211_tx_rate *rates, size_t count)
{
int i, j;
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
struct ieee80211_rate *tmp_rate = NULL;
unsigned limit = hw_priv->short_frame_max_tx_count;
unsigned max_rates_cnt = count;
unsigned total = 0;
u8 lowest_rate_idx = 0;
SYS_BUG(rates[0].idx < 0);
memset(policy, 0, sizeof(*policy));
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
txrx_printk(XRADIO_DBG_MSG, "============================");
#ifdef SUPPORT_HT40
/* calculate the tx policy count and max retry times */
total = rates[0].count;
for (i = 1; i < count; ++i) {
if (rates[i].idx < 0 || i >= limit) {
count = i;
break;
} else {
total += rates[i].count;
}
}
#else
/*
* minstrel is buggy a little bit, so distille
* incoming rates first.
*/
/* Sort rates in descending order. */
total = rates[0].count;
for (i = 1; i < count; ++i) {
if (rates[i].idx > rates[i-1].idx) {
rates[i].idx = rates[i-1].idx > 0 ? (rates[i-1].idx - 1) : -1;
}
if (rates[i].idx < 0 || i >= limit) {
count = i;
break;
} else {
total += rates[i].count;
}
}
#endif
/*
* Add lowest rate to the end.
* TODO: it's better to do this in rate control of mac80211.
*/
if (unlikely(!(rates[0].flags & IEEE80211_TX_RC_MCS)) &&
hw_priv->channel->band == NL80211_BAND_2GHZ) {
u32 rateset = (priv->oper_rates | priv->base_rates) & ~0xf;
if (rateset)
lowest_rate_idx = __ffs(rateset);
else
lowest_rate_idx = 0xff;
txrx_printk(XRADIO_DBG_MSG, "rateset=0x%x, lowest_rate_idx=%d\n",
rateset, lowest_rate_idx);
}
if (count < max_rates_cnt && rates[count-1].idx > lowest_rate_idx) {
rates[count].idx = lowest_rate_idx;
rates[count].count = rates[0].count;
rates[count].flags = rates[0].flags;
rates[count].flags &= (~IEEE80211_TX_RC_40_MHZ_WIDTH);
rates[count].flags &= (~IEEE80211_TX_RC_SHORT_GI);
total += rates[count].count;
count++;
}
/*
* Adjust tx count to limit, rates should fall quickly
* and lower rates should be more retry, because reorder
* buffer of reciever will be timeout and clear probably.
*/
if (count < 2) {
rates[0].count = limit;
total = limit;
} else {
u8 end_retry = 0; /* the retry should be add to last rate. */
if (limit > HIGH_RATE_MAX_RETRY) {
end_retry = limit - HIGH_RATE_MAX_RETRY;
limit = HIGH_RATE_MAX_RETRY;
}
/* i<100 to avoid dead loop */
for (i = 0; (limit != total) && (i < 100); ++i) {
j = i % count;
if (limit < total) {
total += (rates[j].count > 1 ? -1 : 0);
rates[j].count += (rates[j].count > 1 ? -1 : 0);
} else {
j = count - 1 - j;
if (rates[j].count > 0) {
total++;
rates[j].count++;
}
}
}
if (end_retry) {
rates[count-1].count += end_retry;
limit += end_retry;
}
}
#ifdef SUPPORT_HT40
/* Eliminate duplicates. */
total = rates[0].count;
for (i = 0, j = 1; j < count; ++j) {
if ((rates[j].idx == rates[i].idx) &&
(rates[j].flags == rates[i].flags)) {
rates[i].count += rates[j].count;
} else {
++i;
if (i != j)
rates[i] = rates[j];
}
total += rates[j].count;
}
for (j = i + 1; j < count; j++) {
rates[j].idx = -1;
rates[j].count = 0;
}
count = i + 1;
#else
/* Eliminate duplicates. */
total = rates[0].count;
for (i = 0, j = 1; j < count; ++j) {
if (rates[j].idx < 0 || rates[j].idx > rates[i].idx)
break;
if (rates[j].idx == rates[i].idx) {
rates[i].count += rates[j].count;
} else {
++i;
if (i != j)
rates[i] = rates[j];
}
total += rates[j].count;
}
count = i + 1;
#endif
/*
* Re-fill policy trying to keep every requested rate and with
* respect to the global max tx retransmission count.
*/
if (limit < count)
limit = count;
if (total > limit) {
for (i = 0; i < count; ++i) {
int left = count - i - 1;
if (rates[i].count > limit - left)
rates[i].count = limit - left;
limit -= rates[i].count;
}
}
/*
* HACK!!! Device has problems (at least) switching from
* 54Mbps CTS to 1Mbps. This switch takes enormous amount
* of time (100-200 ms), leading to valuable throughput drop.
* As a workaround, additional g-rates are injected to the
* policy.
*/
if (count == 2 && !(rates[0].flags & IEEE80211_TX_RC_MCS) &&
rates[0].idx > 4 && rates[0].count > 2 &&
rates[1].idx < 2) {
/* ">> 1" is an equivalent of "/ 2", but faster */
int mid_rate = (rates[0].idx + 4) >> 1;
/* Decrease number of retries for the initial rate */
rates[0].count -= 2;
if (mid_rate != 4) {
/* Keep fallback rate at 1Mbps. */
rates[3] = rates[1];
/* Inject 1 transmission on lowest g-rate */
rates[2].idx = 4;
rates[2].count = 1;
rates[2].flags = rates[1].flags;
/* Inject 1 transmission on mid-rate */
rates[1].idx = mid_rate;
rates[1].count = 1;
/* Fallback to 1 Mbps is a really bad thing,
* so let's try to increase probability of
* successful transmission on the lowest g rate
* even more */
if (rates[0].count >= 3) {
--rates[0].count;
++rates[2].count;
}
/* Adjust amount of rates defined */
count += 2;
} else {
/* Keep fallback rate at 1Mbps. */
rates[2] = rates[1];
/* Inject 2 transmissions on lowest g-rate */
rates[1].idx = 4;
rates[1].count = 2;
/* Adjust amount of rates defined */
count += 1;
}
}
#ifdef SUPPORT_HT40
/* set rate_entrys */
for (i = 0; i < count; ++i) {
register u8 entry_idx = 0;
register u8 modem_type = RATE_MODEM_LEGACY;
register u8 bandwidth = RATE_BANDWIDTH_20M;
register u8 flag = rates[i].flags;
if (rates[i].idx < 0) {
policy->rate_entrys[i] = XRADIO_INVALID_RATE_ENTRY;
continue;
}
/* set rate index and retry counter. */
tmp_rate = (struct ieee80211_rate *)xradio_get_tx_rate(hw_priv, &rates[i]);
entry_idx = xradio_rate_to_entry_idx(flag, tmp_rate->hw_value);
policy->rate_entrys[i] = ((entry_idx & 0xf) << RATEINDEX_SHIFT)
| (rates[i].count & 0xf);
/* set modem_type and bandwidth. */
if (flag & IEEE80211_TX_RC_MCS)
modem_type = RATE_MODEM_HTOFDM;
if (flag & IEEE80211_TX_RC_40_MHZ_WIDTH)
bandwidth = RATE_BANDWIDTH_40M;
policy->rate_entrys[i] |= ((modem_type << MODEMTYPE_SHIFT) |
(bandwidth << BANDWIDTH_SHIFT));
/* set short preamble in DSSS */
policy->rate_entrys[i] |= MAKE_PREAMBLE_S(flag
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE);
/* set short GI */
policy->rate_entrys[i] |= MAKE_SGI(flag
& IEEE80211_TX_RC_SHORT_GI);
/*
* set green field mode.
* there is a conflict between sgi and green field in one stream,
* and we prefer to use sgi instead of green field
*/
if (priv->association_mode.PhyModeCfg.GF_Enable
&& (modem_type == RATE_MODEM_HTOFDM)) {
if (!(GET_RATE_ENTRY_FLAGS(policy->rate_entrys[i]) & FW_RATE_F_SGI))
policy->rate_entrys[i] |= MAKE_GF(1);
}
/* set STBC, but unsurported in xradio yet. */
policy->rate_entrys[i] |= MAKE_STBC(0);
policy->defined++;
policy->retry_count += (rates[i].count & 0xf);
txrx_printk(XRADIO_DBG_NIY, "[TX policy] rate_entrys=0x%04x",
policy->rate_entrys[i]);
}
#else
tmp_rate = (struct ieee80211_rate *)xradio_get_tx_rate(hw_priv, &rates[0]);
if (tmp_rate)
policy->defined = tmp_rate->hw_value + 1;
#ifdef ENHANCE_ANTI_INTERFERE
/*
* We need to check if 11b rate be supported.
* We only add 11bg rate when no rate below 5.5Mbps is set,
* and last rate has enough reties. Add we need check fw version too.
*/
if (WSM_CAPS_11N_TO_11BG(hw_priv->wsm_caps) && !priv->vif->p2p &&
((priv->oper_rates | priv->base_rates) & 0xf) == 0xf &&
(rates[0].flags & IEEE80211_TX_RC_MCS) &&
rates[count-1].idx == 0 && rates[count-1].count >= 3) {
u8 mcs0_cnt = rates[count-1].count;
u8 cnt1 = (mcs0_cnt>>2);
u8 cnt2 = ((mcs0_cnt - (cnt1<<1))>>1);
if (count <= 1) {
mcs0_cnt -= (cnt1 + cnt1 + cnt2);
rates[count-1].count = 0;
policy->tbl[0] |= ((cnt1&0xf)<<(3<<2));
policy->tbl[0] |= ((cnt2&0xf)<<(2<<2));
policy->tbl[0] |= ((cnt1&0xf)<<(1<<2));
policy->tbl[0] |= ((mcs0_cnt&0xf)<<(0<<2));
policy->retry_count = cnt1 + cnt2 + cnt1 + mcs0_cnt;
txrx_printk(XRADIO_DBG_MSG,
"[TX policy]to11b=%d(f=%d),%d, 11=%d, 5.5=%d, 2=%d, 1=%d\n",
rates[count-1].idx, rates[0].flags,
rates[count-1].count, cnt1, cnt2, cnt1, mcs0_cnt);
} else {
mcs0_cnt -= (cnt1 + cnt1 + cnt2);
rates[count-1].count = cnt1;
policy->tbl[0] |= ((cnt1&0xf)<<(3<<2));
policy->tbl[0] |= ((cnt2&0xf)<<(2<<2));
policy->tbl[0] |= ((mcs0_cnt&0xf)<<(0<<2));
policy->retry_count = cnt1 + cnt2 + mcs0_cnt;
txrx_printk(XRADIO_DBG_MSG,
"[TX policy]to11b=%d(f=%d),%d, 11=%d, 5.5=%d, 2=%d, 1=%d\n",
rates[count-1].idx, rates[0].flags,
rates[count-1].count, cnt1, cnt2, 0, mcs0_cnt);
}
} else {
txrx_printk(XRADIO_DBG_MSG,
"[TX policy]WSM_CAPS to11b=%d, p2p=%d, MSC=%d, rates=0x%08x, count(%d)=%d\n",
!!WSM_CAPS_11N_TO_11BG(hw_priv->wsm_caps), priv->vif->p2p,
!!(rates[0].flags & IEEE80211_TX_RC_MCS),
(priv->oper_rates | priv->base_rates),
count-1, rates[count-1].count);
}
#endif
for (i = 0; i < count; ++i) {
register unsigned rateid, off, shift, retries;
tmp_rate = (struct ieee80211_rate *)xradio_get_tx_rate(hw_priv, &rates[i]);
if (tmp_rate) {
rateid = tmp_rate->hw_value;
} else {
break;
}
off = rateid >> 3; /* eq. rateid / 8 */
shift = (rateid & 0x07) << 2; /* eq. (rateid % 8) * 4 */
retries = rates[i].count;
if (unlikely(retries > 0x0F))
rates[i].count = retries = 0x0F;
policy->tbl[off] |= __cpu_to_le32(retries << shift);
policy->retry_count += retries;
txrx_printk(XRADIO_DBG_MSG, "[TX policy] %d.%dMps=%d",
tmp_rate->bitrate/10, tmp_rate->bitrate%10, retries);
}
#endif
txrx_printk(XRADIO_DBG_MSG, "[TX policy] Dst Policy (%zu): " \
"%d:%d, %d:%d, %d:%d, %d:%d, %d:%d\n",
count,
rates[0].idx, rates[0].count,
rates[1].idx, rates[1].count,
rates[2].idx, rates[2].count,
rates[3].idx, rates[3].count,
rates[4].idx, rates[4].count);
}
#ifdef SUPPORT_HT40
static inline bool tx_policy_is_equal(const struct tx_policy *wanted,
const struct tx_policy *cached)
{
size_t count = wanted->defined << 1;
if (wanted->defined != cached->defined)
return false;
if (count) {
if (memcmp(wanted->raw, cached->raw, count))
return false;
}
return true;
}
#else
static inline bool tx_policy_is_equal(const struct tx_policy *wanted,
const struct tx_policy *cached)
{
size_t count = wanted->defined >> 1;
if (wanted->defined > cached->defined)
return false;
if (count) {
if (memcmp(wanted->raw, cached->raw, count))
return false;
}
if (wanted->defined & 1) {
if ((wanted->raw[count] & 0x0F) != (cached->raw[count] & 0x0F))
return false;
}
return true;
}
#endif
static int tx_policy_find(struct tx_policy_cache *cache,
const struct tx_policy *wanted)
{
/* O(n) complexity. Not so good, but there's only 8 entries in
* the cache.
* Also lru helps to reduce search time. */
struct tx_policy_cache_entry *it;
/* Search for policy in "used" list */
list_for_each_entry(it, &cache->used, link) {
if (tx_policy_is_equal(wanted, &it->policy))
return it - cache->cache;
}
/* Then - in "free list" */
list_for_each_entry(it, &cache->free, link) {
if (tx_policy_is_equal(wanted, &it->policy))
return it - cache->cache;
}
return -1;
}
static inline void tx_policy_use(struct tx_policy_cache *cache,
struct tx_policy_cache_entry *entry)
{
++entry->policy.usage_count;
list_move(&entry->link, &cache->used);
}
static inline int tx_policy_release(struct tx_policy_cache *cache,
struct tx_policy_cache_entry *entry)
{
int ret = --entry->policy.usage_count;
if (!ret)
list_move(&entry->link, &cache->free);
return ret;
}
/* ******************************************************************** */
/* External TX policy cache API */
void tx_policy_init(struct xradio_common *hw_priv)
{
struct tx_policy_cache *cache = &hw_priv->tx_policy_cache;
int i;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
memset(cache, 0, sizeof(*cache));
spin_lock_init(&cache->lock);
INIT_LIST_HEAD(&cache->used);
INIT_LIST_HEAD(&cache->free);
for (i = 0; i < TX_POLICY_CACHE_SIZE; ++i)
list_add(&cache->cache[i].link, &cache->free);
}
static int tx_policy_get(struct xradio_vif *priv,
struct ieee80211_tx_rate *rates,
u8 use_bg_rate, bool *renew)
{
int idx;
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
struct tx_policy_cache *cache = &hw_priv->tx_policy_cache;
struct tx_policy wanted;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (use_bg_rate) {
#ifdef SUPPORT_HT40
memset(&wanted, 0, sizeof(wanted));
wanted.retry_count = (hw_priv->short_frame_max_tx_count&0xf);
wanted.defined = 1;
/* set rate index and retry counter. */
wanted.rate_entrys[0] = (((use_bg_rate & 0xf)<<4)
| (wanted.retry_count & 0xf));
/* set modem_type and bandwidth. */
wanted.rate_entrys[0] |=
((RATE_MODEM_LEGACY << MODEMTYPE_SHIFT)
| (RATE_BANDWIDTH_20M << BANDWIDTH_SHIFT));
/* set short preamble in DSSS */
wanted.rate_entrys[0] |= MAKE_PREAMBLE_S(rates[0].flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE);
txrx_printk(XRADIO_DBG_NIY, "[TX policy] robust rate=0x%04x\n",
wanted.rate_entrys[0]);
#else
u8 rate = (u8)(use_bg_rate & 0x3f);
u8 shitf = ((rate&0x7)<<2);
u8 off = (rate>>3);
memset(&wanted, 0, sizeof(wanted));
wanted.defined = rate + 1;
wanted.retry_count = (hw_priv->short_frame_max_tx_count&0xf);
wanted.tbl[off] = wanted.retry_count<<shitf;
txrx_printk(XRADIO_DBG_NIY, "[TX policy] robust rate=%d\n", rate);
#endif
} else
tx_policy_build(priv, &wanted, rates, IEEE80211_TX_MAX_RATES);
/* use rate policy instead of minstel policy in debug mode*/
#ifdef CONFIG_XRADIO_DEBUGFS
if (rates_dbg_en & 0x2) {
memset(&wanted, 0, sizeof(wanted));
#ifdef SUPPORT_HT40
wanted.defined = Ratecnt_dbg;
wanted.retry_count = (hw_priv->short_frame_max_tx_count&0xf);
memcpy(&wanted.rate_entrys[0], &rates_debug[0],
sizeof(wanted.rate_entrys));
#else
wanted.defined = maxRate_dbg + 1;
wanted.retry_count = (hw_priv->short_frame_max_tx_count&0xf);
memcpy(&wanted.tbl[0], &rates_debug[0], sizeof(wanted.tbl));
#endif
}
#endif
spin_lock_bh(&cache->lock);
idx = tx_policy_find(cache, &wanted);
if (idx >= 0) {
txrx_printk(XRADIO_DBG_MSG, "[TX policy] Used TX policy: %d\n",
idx);
*renew = false;
} else if (WARN_ON_ONCE(list_empty(&cache->free))) {
spin_unlock_bh(&cache->lock);
txrx_printk(XRADIO_DBG_ERROR, "[TX policy] no policy cache\n");
return XRADIO_INVALID_RATE_ID;
} else {
struct tx_policy_cache_entry *entry;
/* If policy is not found create a new one
* using the oldest entry in "free" list */
*renew = true;
entry = list_entry(cache->free.prev,
struct tx_policy_cache_entry, link);
entry->policy = wanted;
idx = entry - cache->cache;
txrx_printk(XRADIO_DBG_MSG, "[TX policy] New TX policy: %d\n",
idx);
tx_policy_dump(&entry->policy);
}
tx_policy_use(cache, &cache->cache[idx]);
if (unlikely(list_empty(&cache->free)) &&
!cache->queue_locked) {
/* Lock TX queues. */
DBG_INT_ADD(policy_lock_cnt);
txrx_printk(XRADIO_DBG_WARN, "[TX policy] policy cache used up\n");
xradio_tx_queues_lock(hw_priv);
cache->queue_locked = true;
}
spin_unlock_bh(&cache->lock);
/*force to upload retry limit when using debug rate policy */
#ifdef CONFIG_XRADIO_DEBUGFS
if (retry_dbg & 0x2) {
retry_dbg &= ~0x2;
/* retry dgb need to be applied to policy. */
*renew = true;
cache->cache[idx].policy.uploaded = 0;
}
#endif
return idx;
}
static void tx_policy_put(struct xradio_common *hw_priv, int idx)
{
int usage;
/*int locked;*/
struct tx_policy_cache *cache = &hw_priv->tx_policy_cache;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
spin_lock_bh(&cache->lock);
/*locked = list_empty(&cache->free);*/
usage = tx_policy_release(cache, &cache->cache[idx]);
if (unlikely(cache->queue_locked) && !list_empty(&cache->free)) {
/* Unlock TX queues. */
xradio_tx_queues_unlock(hw_priv);
cache->queue_locked = false;
}
spin_unlock_bh(&cache->lock);
}
/*
bool tx_policy_cache_full(struct xradio_common *hw_priv)
{
bool ret;
struct tx_policy_cache *cache = &hw_priv->tx_policy_cache;
spin_lock_bh(&cache->lock);
ret = list_empty(&cache->free);
spin_unlock_bh(&cache->lock);
return ret;
}
*/
extern u32 policy_upload;
extern u32 policy_num;
static int tx_policy_upload(struct xradio_common *hw_priv)
{
struct tx_policy_cache *cache = &hw_priv->tx_policy_cache;
int i;
struct wsm_set_tx_rate_retry_policy arg = {
.hdr = {
.numTxRatePolicies = 0,
}
};
int if_id = 0;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
spin_lock_bh(&cache->lock);
/* Upload only modified entries. */
for (i = 0; i < TX_POLICY_CACHE_SIZE; ++i) {
struct tx_policy *src = &cache->cache[i].policy;
if (src->retry_count && !src->uploaded) {
struct wsm_set_tx_rate_retry_policy_policy *dst =
&arg.tbl[arg.hdr.numTxRatePolicies];
dst->policyIndex = i;
dst->shortRetryCount = hw_priv->short_frame_max_tx_count-1;
/* only RTS need use longRetryCount, should be short_frame. */
dst->longRetryCount = hw_priv->short_frame_max_tx_count-1;
/* BIT(2) - Terminate retries when Tx rate retry policy
* finishes.
* BIT(3) - Count initial frame transmission as part of
* rate retry counting but not as a retry
* attempt */
dst->policyFlags = BIT(2) | BIT(3);
#ifdef SUPPORT_HT40
memcpy(dst->rate_entrys, src->rate_entrys,
sizeof(dst->rate_entrys));
#else
memcpy(dst->rateCountIndices, src->tbl,
sizeof(dst->rateCountIndices));
#endif
src->uploaded = 1;
++arg.hdr.numTxRatePolicies;
}
}
spin_unlock_bh(&cache->lock);
atomic_set(&hw_priv->upload_count, 0);
xradio_debug_tx_cache_miss(hw_priv);
txrx_printk(XRADIO_DBG_MSG, "[TX policy] Upload %d policies\n",
arg.hdr.numTxRatePolicies);
#ifdef CONFIG_XRADIO_DEBUGFS
#ifndef SUPPORT_HT40
if (arg.tbl[0].policyIndex == 7)
txrx_printk(XRADIO_DBG_MSG, "rate:0x%08x, 0x%08x, 0x%08x\n",
arg.tbl[0].rateCountIndices[2],
arg.tbl[0].rateCountIndices[1],
arg.tbl[0].rateCountIndices[0]);
#endif
policy_upload++;
policy_num += arg.hdr.numTxRatePolicies;
#endif
/*TODO: COMBO*/
return wsm_set_tx_rate_retry_policy(hw_priv, &arg, if_id);
}
void tx_policy_upload_work(struct work_struct *work)
{
struct xradio_common *hw_priv =
container_of(work, struct xradio_common, tx_policy_upload_work);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
SYS_WARN(tx_policy_upload(hw_priv));
wsm_unlock_tx(hw_priv);
}
/* ******************************************************************** */
/* xradio TX implementation */
struct xradio_txinfo {
struct sk_buff *skb;
unsigned queue;
struct ieee80211_tx_info *tx_info;
const struct ieee80211_rate *rate;
struct ieee80211_hdr *hdr;
size_t hdrlen;
const u8 *da;
struct xradio_sta_priv *sta_priv;
struct xradio_txpriv txpriv;
};
u32 xradio_rate_mask_to_wsm(struct xradio_common *hw_priv, u32 rates)
{
u32 ret = 0;
int i;
u32 n_bitrates =
hw_priv->hw->wiphy->bands[hw_priv->channel->band]->n_bitrates;
struct ieee80211_rate *bitrates =
hw_priv->hw->wiphy->bands[hw_priv->channel->band]->bitrates;
for (i = 0; i < n_bitrates; ++i) {
if (rates & BIT(i))
ret |= BIT(bitrates[i].hw_value);
}
return ret;
}
static const struct ieee80211_rate *
xradio_get_tx_rate(const struct xradio_common *hw_priv,
const struct ieee80211_tx_rate *rate)
{
if (rate->idx < 0)
return NULL;
if (rate->flags & IEEE80211_TX_RC_MCS)
return &hw_priv->mcs_rates[rate->idx];
return &hw_priv->hw->wiphy->bands[hw_priv->channel->band]->
bitrates[rate->idx];
}
#ifdef SUPPORT_HT40
u16 xradio_get_rate_entry(const struct xradio_common *hw_priv,
u8 Bandwidth, u16 FormatFlag, u8 hw_value)
{
u16 rate_entry = XRADIO_INVALID_RATE_ENTRY;
u8 modem_type = 0;
s8 rate_idx = hw_value;
if (rate_idx <= MAX_RATES_IDX) {
if (rate_idx >= MCS_RATES_OFF) {
rate_idx -= MCS_RATES_OFF;
modem_type = RATE_MODEM_HTOFDM;
}
rate_entry = rate_idx << RATEINDEX_SHIFT;
rate_entry |= (modem_type & MODEMTYPE_MASK) << MODEMTYPE_SHIFT;
rate_entry |= (Bandwidth & BANDWIDTH_MASK) << BANDWIDTH_SHIFT;
rate_entry |= (FormatFlag & RATE_F_MASK);
}
return rate_entry;
}
#else
static inline s8 xradio_get_rate_idx(const struct xradio_common *hw_priv,
u8 flag, u16 hw_value)
{
s16 ret = (s16)hw_value;
if (flag & IEEE80211_TX_RC_MCS) { /* 11n */
if (hw_value <= hw_priv->mcs_rates[7].hw_value &&
hw_value >= hw_priv->mcs_rates[0].hw_value)
ret -= hw_priv->mcs_rates[0].hw_value;
else
ret = -1;
} else { /* 11b/g */
if (hw_value > 5 && hw_value < hw_priv->mcs_rates[0].hw_value) {
ret -= hw_priv->hw->wiphy-> \
bands[hw_priv->channel->band]->bitrates[0].hw_value;
if (hw_priv->hw->wiphy-> \
bands[hw_priv->channel->band]->bitrates[0].hw_value < 5) /* 11a*/
ret -= 2;
} else if (hw_value < 4) {
ret -= hw_priv->hw->wiphy-> \
bands[hw_priv->channel->band]->bitrates[0].hw_value;
} else {
ret = -1;
}
}
return (s8)ret;
}
#endif
static int
xradio_tx_h_calc_link_ids(struct xradio_vif *priv,
struct xradio_txinfo *t)
{
#ifndef P2P_MULTIVIF
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
#endif
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
#ifndef P2P_MULTIVIF
if ((t->tx_info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) ||
(hw_priv->roc_if_id == priv->if_id))
t->txpriv.offchannel_if_id = 2;
else
t->txpriv.offchannel_if_id = 0;
#endif
if (likely(t->tx_info->control.sta && t->sta_priv->link_id))
t->txpriv.raw_link_id =
t->txpriv.link_id =
t->sta_priv->link_id;
else if (priv->mode != NL80211_IFTYPE_AP)
t->txpriv.raw_link_id =
t->txpriv.link_id = 0;
else if (is_multicast_ether_addr(t->da)) {
if (priv->enable_beacon) {
t->txpriv.raw_link_id = 0;
t->txpriv.link_id = priv->link_id_after_dtim;
} else {
t->txpriv.raw_link_id = 0;
t->txpriv.link_id = 0;
}
} else {
t->txpriv.link_id =
xradio_find_link_id(priv, t->da);
/* Do not assign valid link id for deauth/disassoc frame being
transmitted to an unassociated STA */
if (!(t->txpriv.link_id) &&
(ieee80211_is_deauth(t->hdr->frame_control) ||
ieee80211_is_disassoc(t->hdr->frame_control))) {
t->txpriv.link_id = 0;
} else {
if (!t->txpriv.link_id)
t->txpriv.link_id = xradio_alloc_link_id(priv, t->da);
if (!t->txpriv.link_id) {
txrx_printk(XRADIO_DBG_ERROR,
"%s: No more link IDs available.\n", __func__);
return -ENOENT;
}
}
t->txpriv.raw_link_id = t->txpriv.link_id;
}
if (t->txpriv.raw_link_id)
priv->link_id_db[t->txpriv.raw_link_id - 1].timestamp =
jiffies;
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
if (t->tx_info->control.sta &&
(t->tx_info->control.sta->uapsd_queues & BIT(t->queue)))
t->txpriv.link_id = priv->link_id_uapsd;
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */
return 0;
}
static void
xradio_tx_h_pm(struct xradio_vif *priv,
struct xradio_txinfo *t)
{
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (unlikely(ieee80211_is_auth(t->hdr->frame_control))) {
u32 mask = ~BIT(t->txpriv.raw_link_id);
spin_lock_bh(&priv->ps_state_lock);
priv->sta_asleep_mask &= mask;
priv->pspoll_mask &= mask;
spin_unlock_bh(&priv->ps_state_lock);
}
}
static void
xradio_tx_h_calc_tid(struct xradio_vif *priv,
struct xradio_txinfo *t)
{
if (ieee80211_is_data_qos(t->hdr->frame_control)) {
u8 *qos = ieee80211_get_qos_ctl(t->hdr);
t->txpriv.tid = qos[0] & IEEE80211_QOS_CTL_TID_MASK;
} else if (ieee80211_is_data(t->hdr->frame_control)) {
t->txpriv.tid = 0;
}
}
/* IV/ICV injection. */
/* TODO: Quite unoptimal. It's better co modify mac80211
* to reserve space for IV */
static int
xradio_tx_h_crypt(struct xradio_vif *priv,
struct xradio_txinfo *t)
{
size_t iv_len;
size_t icv_len;
u8 *icv;
u8 *newhdr;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (!t->tx_info->control.hw_key ||
!(t->hdr->frame_control &
__cpu_to_le32(IEEE80211_FCTL_PROTECTED)))
return 0;
iv_len = t->tx_info->control.hw_key->iv_len;
icv_len = t->tx_info->control.hw_key->icv_len;
#ifdef AP_ARP_COMPAT_FIX
t->txpriv.iv_len = iv_len;
#endif
if (t->tx_info->control.hw_key->cipher == WLAN_CIPHER_SUITE_TKIP)
icv_len += 8; /* MIC */
if ((skb_headroom(t->skb) + skb_tailroom(t->skb) <
iv_len + icv_len + WSM_TX_EXTRA_HEADROOM) ||
(skb_headroom(t->skb) <
iv_len + WSM_TX_EXTRA_HEADROOM)) {
txrx_printk(XRADIO_DBG_ERROR,
"Bug: no space allocated for crypto headers.\n"
"headroom: %d, tailroom: %d, "
"req_headroom: %zu, req_tailroom: %zu\n"
"Please fix it in xradio_get_skb().\n",
skb_headroom(t->skb), skb_tailroom(t->skb),
iv_len + WSM_TX_EXTRA_HEADROOM, icv_len);
return -ENOMEM;
} else if (skb_tailroom(t->skb) < icv_len) {
size_t offset = icv_len - skb_tailroom(t->skb);
u8 *p;
txrx_printk(XRADIO_DBG_ERROR,
"Slowpath: tailroom is not big enough. "
"Req: %zu, got: %d.\n",
icv_len, skb_tailroom(t->skb));
p = skb_push(t->skb, offset);
memmove(p, &p[offset], t->skb->len - offset);
skb_trim(t->skb, t->skb->len - offset);
}
newhdr = skb_push(t->skb, iv_len);
memmove(newhdr, newhdr + iv_len, t->hdrlen);
t->hdr = (struct ieee80211_hdr *) newhdr;
t->hdrlen += iv_len;
icv = skb_put(t->skb, icv_len);
return 0;
}
#ifdef SUPPORT_HT40
static int xradio_tx_h_align(struct xradio_vif *priv, struct xradio_txinfo *t)
#else
static int
xradio_tx_h_align(struct xradio_vif *priv, struct xradio_txinfo *t,
u8 *flags)
#endif
{
size_t offset = (size_t)t->skb->data & 3;
u8 *newhdr;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (!offset)
return 0;
if (skb_headroom(t->skb) < offset) {
txrx_printk(XRADIO_DBG_ERROR,
"Bug: no space allocated "
"for DMA alignment.\n"
"headroom: %d\n",
skb_headroom(t->skb));
return -ENOMEM;
}
/* offset = 1or3 process */
if (offset & 1) {
newhdr = skb_push(t->skb, offset);
memmove(newhdr, newhdr + offset, t->skb->len-offset);
skb_trim(t->skb, t->skb->len-offset);
t->hdr = (struct ieee80211_hdr *) newhdr;
xradio_debug_tx_align(priv);
return 0;
}
/* offset=2 process */
skb_push(t->skb, offset);
t->hdrlen += offset;
t->txpriv.offset += offset;
#ifndef SUPPORT_HT40
*flags |= WSM_TX_2BYTES_SHIFT;
#endif
xradio_debug_tx_align(priv);
return 0;
}
static int
xradio_tx_h_action(struct xradio_vif *priv, struct xradio_txinfo *t)
{
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)t->hdr;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (ieee80211_is_action(t->hdr->frame_control) &&
mgmt->u.action.category == WLAN_CATEGORY_BACK)
return 1;
else
return 0;
}
/* Add WSM header */
static struct wsm_tx *
xradio_tx_h_wsm(struct xradio_vif *priv, struct xradio_txinfo *t)
{
struct wsm_tx *wsm;
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (skb_headroom(t->skb) < sizeof(struct wsm_tx)) {
txrx_printk(XRADIO_DBG_ERROR,
"Bug: no space allocated "
"for WSM header.\n"
"headroom: %d\n",
skb_headroom(t->skb));
return NULL;
}
wsm = (struct wsm_tx *)skb_push(t->skb, sizeof(struct wsm_tx));
t->txpriv.offset += sizeof(struct wsm_tx);
memset(wsm, 0, sizeof(*wsm));
#ifdef SUPPORT_HT40
wsm->DataOffset = t->txpriv.offset;
#endif
wsm->hdr.len = __cpu_to_le16(t->skb->len);
wsm->hdr.id = __cpu_to_le16(0x0004);
wsm->queueId = (t->txpriv.raw_link_id << 2) | wsm_queue_id_to_wsm(t->queue);
if (wsm->hdr.len > hw_priv->wsm_caps.sizeInpChBuf) {
txrx_printk(XRADIO_DBG_ERROR, "%s,msg length too big=%d\n",
__func__, wsm->hdr.len);
skb_pull(t->skb, sizeof(struct wsm_tx)); //skb revert.
wsm = NULL;
}
return wsm;
}
/* BT Coex specific handling */
static void xradio_tx_h_bt(struct xradio_vif *priv, struct xradio_txinfo *t,
struct wsm_tx *wsm)
{
u8 priority = 0;
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (!hw_priv->is_BT_Present)
return;
if (unlikely(ieee80211_is_nullfunc(t->hdr->frame_control)))
priority = WSM_EPTA_PRIORITY_MGT;
else if (ieee80211_is_data(t->hdr->frame_control)) {
/* Skip LLC SNAP header (+6) */
u8 *payload = &t->skb->data[t->hdrlen];
u16 *ethertype = (u16 *) &payload[6];
if (unlikely(*ethertype == __be16_to_cpu(ETH_P_PAE)))
priority = WSM_EPTA_PRIORITY_EAPOL;
} else if (unlikely(ieee80211_is_assoc_req(t->hdr->frame_control) ||
ieee80211_is_reassoc_req(t->hdr->frame_control))) {
struct ieee80211_mgmt *mgt_frame =
(struct ieee80211_mgmt *)t->hdr;
if (mgt_frame->u.assoc_req.listen_interval <
priv->listen_interval) {
txrx_printk(XRADIO_DBG_MSG,
"Modified Listen Interval to %d from %d\n",
priv->listen_interval,
mgt_frame->u.assoc_req.listen_interval);
/* Replace listen interval derieved from
* the one read from SDD */
mgt_frame->u.assoc_req.listen_interval =
priv->listen_interval;
}
}
if (likely(!priority)) {
if (ieee80211_is_action(t->hdr->frame_control))
priority = WSM_EPTA_PRIORITY_ACTION;
else if (ieee80211_is_mgmt(t->hdr->frame_control))
priority = WSM_EPTA_PRIORITY_MGT;
else if ((wsm->queueId == WSM_QUEUE_VOICE))
priority = WSM_EPTA_PRIORITY_VOICE;
else if ((wsm->queueId == WSM_QUEUE_VIDEO))
priority = WSM_EPTA_PRIORITY_VIDEO;
else
priority = WSM_EPTA_PRIORITY_DATA;
}
txrx_printk(XRADIO_DBG_MSG, "[TX] EPTA priority %d.\n",
priority);
#ifdef SUPPORT_HT40
wsm->EptaPriority = priority;
#else
wsm->flags |= priority << 1;
#endif
}
static int
xradio_tx_h_rate_policy(struct xradio_vif *priv,
struct xradio_txinfo *t,
struct wsm_tx *wsm)
{
bool tx_policy_renew = false;
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
/*use debug policy for data frames only*/
#ifdef CONFIG_XRADIO_DEBUGFS
if ((rates_dbg_en & 0x1) && ieee80211_is_data(t->hdr->frame_control)) {
rates_dbg_en |= 0x02;
}
#endif
t->txpriv.rate_id = tx_policy_get(priv,
t->tx_info->control.rates, t->txpriv.use_bg_rate,
&tx_policy_renew);
if (t->txpriv.rate_id == XRADIO_INVALID_RATE_ID)
return -EFAULT;
#ifdef SUPPORT_HT40
wsm->TxPolicyIndex = t->txpriv.rate_id;
wsm->TxRateEntry =
hw_priv->tx_policy_cache.cache[t->txpriv.rate_id].policy.rate_entrys[0];
#else
wsm->flags |= t->txpriv.rate_id << 4;
t->rate = xradio_get_tx_rate(hw_priv, &t->tx_info->control.rates[0]);
if (t->txpriv.use_bg_rate)
wsm->maxTxRate = (u8)(t->txpriv.use_bg_rate & 0x3f);
else
wsm->maxTxRate = t->rate->hw_value;
#endif
#ifdef SUPPORT_HT40
/* set the first TxRateEntry and
clear the dataframe flag of rates_dbg_en */
#ifdef CONFIG_XRADIO_DEBUGFS
if (rates_dbg_en & 0x02) {
wsm->TxRateEntry = rates_debug[0];
rates_dbg_en &= ~0x2;
}
#endif
#else
/*set the maxTxRate and clear the dataframe flag of rates_dbg_en */
#ifdef CONFIG_XRADIO_DEBUGFS
if (rates_dbg_en & 0x02) {
wsm->maxTxRate = maxRate_dbg;
rates_dbg_en &= ~0x2;
}
#endif
if (t->rate->flags & IEEE80211_TX_RC_MCS) {
if (priv->association_mode.greenfieldMode)
wsm->htTxParameters |=
__cpu_to_le32(WSM_HT_TX_GREENFIELD);
else
wsm->htTxParameters |=
__cpu_to_le32(WSM_HT_TX_MIXED);
}
#endif
if (tx_policy_renew) {
txrx_printk(XRADIO_DBG_MSG, "[TX] TX policy renew.\n");
/* It's not so optimal to stop TX queues every now and then.
* Maybe it's better to reimplement task scheduling with
* a counter. */
/* xradio_tx_queues_lock(priv); */
/* Definetly better. TODO. */
if (atomic_add_return(1, &hw_priv->upload_count) == 1) {
wsm_lock_tx_async(hw_priv);
if (queue_work(hw_priv->workqueue,
&hw_priv->tx_policy_upload_work) <= 0) {
atomic_set(&hw_priv->upload_count, 0);
wsm_unlock_tx(hw_priv);
}
}
}
return 0;
}
static bool
xradio_tx_h_pm_state(struct xradio_vif *priv, struct xradio_txinfo *t)
{
int was_buffered = 1;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (t->txpriv.link_id == priv->link_id_after_dtim &&
!priv->buffered_multicasts) {
priv->buffered_multicasts = true;
if (priv->sta_asleep_mask)
queue_work(priv->hw_priv->workqueue,
&priv->multicast_start_work);
}
if (t->txpriv.raw_link_id && t->txpriv.tid < XRADIO_MAX_TID)
was_buffered = priv->link_id_db[t->txpriv.raw_link_id - 1]
.buffered[t->txpriv.tid]++;
return !was_buffered;
}
static void
xradio_tx_h_ba_stat(struct xradio_vif *priv,
struct xradio_txinfo *t)
{
struct xradio_common *hw_priv = priv->hw_priv;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (priv->join_status != XRADIO_JOIN_STATUS_STA)
return;
if (!xradio_is_ht(&hw_priv->ht_info))
return;
if (!priv->setbssparams_done)
return;
if (!ieee80211_is_data(t->hdr->frame_control))
return;
spin_lock_bh(&hw_priv->ba_lock);
hw_priv->ba_acc += t->skb->len - t->hdrlen;
if (!(hw_priv->ba_cnt_rx || hw_priv->ba_cnt)) {
mod_timer(&hw_priv->ba_timer,
jiffies + XRADIO_BLOCK_ACK_INTERVAL);
}
hw_priv->ba_cnt++;
spin_unlock_bh(&hw_priv->ba_lock);
}
static int
xradio_tx_h_skb_pad(struct xradio_common *priv,
struct wsm_tx *wsm,
struct sk_buff *skb)
{
size_t len = __le16_to_cpu(wsm->hdr.len);
size_t padded_len = priv->sbus_ops->align_size(priv->sbus_priv, len);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (SYS_WARN(skb_padto(skb, padded_len) != 0)) {
return -EINVAL;
}
return 0;
}
/* ******************************************************************** */
#if (defined(CONFIG_XRADIO_DEBUG))
u16 txparse_flags;
u16 rxparse_flags;
#endif
#if PERF_INFO_TEST
struct timeval mac_start_time;
#endif
void xradio_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
{
struct xradio_common *hw_priv = dev->priv;
struct xradio_txinfo t = {
.skb = skb,
.queue = skb_get_queue_mapping(skb),
.tx_info = IEEE80211_SKB_CB(skb),
.hdr = (struct ieee80211_hdr *)skb->data,
.txpriv.tid = XRADIO_MAX_TID,
.txpriv.rate_id = XRADIO_INVALID_RATE_ID,
#ifdef P2P_MULTIVIF
.txpriv.raw_if_id = 0,
#endif
.txpriv.use_bg_rate = 0,
#ifdef AP_ARP_COMPAT_FIX
.txpriv.iv_len = 0,
#endif
};
struct ieee80211_sta *sta;
struct wsm_tx *wsm;
bool tid_update = 0;
#if PERF_INFO_TEST
int date_len = skb->len;
#endif
#ifndef SUPPORT_HT40
u8 flags = 0;
#endif
int ret = 0;
struct xradio_vif *priv;
struct ieee80211_hdr *frame = (struct ieee80211_hdr *)skb->data;
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
PERF_INFO_GETTIME(&mac_start_time);
if (!skb->data)
SYS_BUG(1);
#ifdef HW_RESTART
if (hw_priv->hw_restart) {
txrx_printk(XRADIO_DBG_WARN, "%s, hw in reset.\n", __func__);
ret = __LINE__;
goto drop;
}
#endif
if (!(t.tx_info->control.vif)) {
ret = __LINE__;
goto drop;
}
priv = xrwl_get_vif_from_ieee80211(t.tx_info->control.vif);
if (!priv) {
ret = __LINE__;
goto drop;
}
if (atomic_read(&priv->enabled) == 0) {
ret = __LINE__;
goto drop;
}
#if (defined(CONFIG_XRADIO_DEBUG))
/* parse frame for debug. */
if (txparse_flags)
xradio_parse_frame(skb->data, 0, txparse_flags, priv->if_id);
#endif
/*
* dhcp and 8021 frames are important, use b/g rate and delay scan.
* it can make sense, such as accelerate connect.
*/
if (ieee80211_is_auth(frame->frame_control)) {
hw_priv->scan_delay_time[priv->if_id] = jiffies;
hw_priv->scan_delay_status[priv->if_id] = XRADIO_SCAN_DELAY;
} else if (ieee80211_is_data_present(frame->frame_control)) {
u8 *llc = skb->data+ieee80211_hdrlen(frame->frame_control);
if (is_dhcp(llc) || is_8021x(llc)) {
t.txpriv.use_bg_rate =
hw_priv->hw->wiphy-> \
bands[hw_priv->channel->band]->bitrates[0].hw_value;
if (priv->vif->p2p)
t.txpriv.use_bg_rate = AG_RATE_INDEX;
t.txpriv.use_bg_rate |= 0x80;
}
if (t.txpriv.use_bg_rate) {
hw_priv->scan_delay_time[priv->if_id] = jiffies;
hw_priv->scan_delay_status[priv->if_id] = XRADIO_SCAN_DELAY;
}
} else if (ieee80211_is_deauth(frame->frame_control) ||
ieee80211_is_disassoc(frame->frame_control)) {
hw_priv->scan_delay_status[priv->if_id] = XRADIO_SCAN_ALLOW;
}
#ifdef AP_HT_COMPAT_FIX
if (ieee80211_is_assoc_req(frame->frame_control) &&
priv->if_id == 0 && !(priv->ht_compat_det & 0x10)) {
xradio_remove_ht_ie(priv, skb);
}
#endif
#ifdef CONFIG_XRADIO_TESTMODE
spin_lock_bh(&hw_priv->tsm_lock);
if (hw_priv->start_stop_tsm.start) {
if (hw_priv->tsm_info.ac == t.queue)
hw_priv->tsm_stats.txed_msdu_count++;
}
spin_unlock_bh(&hw_priv->tsm_lock);
#endif /*CONFIG_XRADIO_TESTMODE*/
#ifdef TES_P2P_0002_ROC_RESTART
xradio_frame_monitor(hw_priv, skb, true);
#endif
if (ieee80211_is_action(frame->frame_control) &&
mgmt->u.action.category == WLAN_CATEGORY_PUBLIC) {
u8 *action = (u8 *)&mgmt->u.action.category;
xradio_check_go_neg_conf_success(hw_priv, action);
xradio_check_prov_desc_req(hw_priv, action);
}
t.txpriv.if_id = priv->if_id;
t.hdrlen = ieee80211_hdrlen(t.hdr->frame_control);
t.da = ieee80211_get_DA(t.hdr);
t.sta_priv =
(struct xradio_sta_priv *)&t.tx_info->control.sta->drv_priv;
if (SYS_WARN(t.queue >= 4)) {
ret = __LINE__;
goto drop;
}
/*
spin_lock_bh(&hw_priv->tx_queue[t.queue].lock);
if ((priv->if_id == 0) &&
(hw_priv->tx_queue[t.queue].num_queued_vif[0] >=
hw_priv->vif0_throttle)) {
spin_unlock_bh(&hw_priv->tx_queue[t.queue].lock);
ret = __LINE__;
goto drop;
} else if ((priv->if_id == 1) &&
(hw_priv->tx_queue[t.queue].num_queued_vif[1] >=
hw_priv->vif1_throttle)) {
spin_unlock_bh(&hw_priv->tx_queue[t.queue].lock);
ret = __LINE__;
goto drop;
}
spin_unlock_bh(&hw_priv->tx_queue[t.queue].lock);
*/
ret = xradio_tx_h_calc_link_ids(priv, &t);
if (ret) {
ret = __LINE__;
goto drop;
}
txrx_printk(XRADIO_DBG_MSG, "[TX] TX %d bytes (if_id: %d,"
" queue: %d, link_id: %d (%d)).\n",
skb->len, priv->if_id, t.queue, t.txpriv.link_id,
t.txpriv.raw_link_id);
xradio_tx_h_pm(priv, &t);
xradio_tx_h_calc_tid(priv, &t);
ret = xradio_tx_h_crypt(priv, &t);
if (ret) {
ret = __LINE__;
goto drop;
}
#ifdef SUPPORT_HT40
ret = xradio_tx_h_align(priv, &t);
#else
ret = xradio_tx_h_align(priv, &t, &flags);
#endif
if (ret) {
ret = __LINE__;
goto drop;
}
ret = xradio_tx_h_action(priv, &t);
if (ret) {
ret = __LINE__;
goto drop;
}
wsm = xradio_tx_h_wsm(priv, &t);
if (!wsm) {
ret = __LINE__;
goto drop;
}
#ifdef SUPPORT_HT40
#ifdef CONFIG_XRADIO_TESTMODE
wsm->ExpireTimeSetting = WSM_TX_FLAG_EXPIRY_TIME;
#endif /*CONFIG_XRADIO_TESTMODE*/
#else
#ifdef CONFIG_XRADIO_TESTMODE
flags |= WSM_TX_FLAG_EXPIRY_TIME;
#endif /*CONFIG_XRADIO_TESTMODE*/
wsm->flags |= flags;
#endif
xradio_tx_h_bt(priv, &t, wsm);
ret = xradio_tx_h_rate_policy(priv, &t, wsm);
if (ret) {
ret = __LINE__;
goto drop;
}
ret = xradio_tx_h_skb_pad(hw_priv, wsm, skb);
if (ret) {
ret = __LINE__;
goto drop;
}
rcu_read_lock();
sta = rcu_dereference(t.tx_info->control.sta);
xradio_tx_h_ba_stat(priv, &t);
spin_lock_bh(&priv->ps_state_lock);
tid_update = xradio_tx_h_pm_state(priv, &t);
SYS_BUG(xradio_queue_put(&hw_priv->tx_queue[t.queue],
t.skb, &t.txpriv));
#ifdef ROC_DEBUG
txrx_printk(XRADIO_DBG_ERROR, "QPUT %x, %pM, if_id - %d\n",
t.hdr->frame_control, t.da, priv->if_id);
#endif
spin_unlock_bh(&priv->ps_state_lock);
/* To improve tcp tx in linux4.9
* skb_orphan will tell tcp that driver has processed this skb,
* so tcp can send other skb to driver.
* If this is a retransmitted frame by umac, driver do not skb_orphan it again.
*/
if (!(t.tx_info->flags & IEEE80211_TX_INTFL_RETRANSMISSION))
skb_orphan(skb);
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
if (tid_update && sta)
mac80211_sta_set_buffered(sta,
t.txpriv.tid, true);
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */
rcu_read_unlock();
xradio_proc_wakeup(hw_priv);
PERF_INFO_STAMP(&mac_start_time, &mac_tx, date_len);
return;
drop:
txrx_printk(XRADIO_DBG_WARN, "drop=%d, fctl=0x%04x.\n",
ret, frame->frame_control);
if (!(t.tx_info->flags & IEEE80211_TX_INTFL_RETRANSMISSION))
skb_orphan(skb);
xradio_skb_post_gc(hw_priv, skb, &t.txpriv);
return;
}
/* ******************************************************************** */
static int xradio_handle_pspoll(struct xradio_vif *priv,
struct sk_buff *skb)
{
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
struct ieee80211_sta *sta;
struct ieee80211_pspoll *pspoll =
(struct ieee80211_pspoll *) skb->data;
int link_id = 0;
u32 pspoll_mask = 0;
int drop = 1;
int i;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (priv->join_status != XRADIO_JOIN_STATUS_AP)
goto done;
if (memcmp(priv->vif->addr, pspoll->bssid, ETH_ALEN))
goto done;
rcu_read_lock();
sta = mac80211_find_sta(priv->vif, pspoll->ta);
if (sta) {
struct xradio_sta_priv *sta_priv;
sta_priv = (struct xradio_sta_priv *)&sta->drv_priv;
link_id = sta_priv->link_id;
pspoll_mask = BIT(sta_priv->link_id);
}
rcu_read_unlock();
if (!link_id)
goto done;
priv->pspoll_mask |= pspoll_mask;
drop = 0;
/* Do not report pspols if data for given link id is
* queued already. */
for (i = 0; i < 4; ++i) {
if (xradio_queue_get_num_queued(priv,
&hw_priv->tx_queue[i],
pspoll_mask)) {
xradio_proc_wakeup(hw_priv);
drop = 1;
break;
}
}
txrx_printk(XRADIO_DBG_NIY, "[RX] PSPOLL: %s\n", drop ? "local" : "fwd");
done:
return drop;
}
/* ******************************************************************** */
extern u32 tx_retrylimit;
extern u32 tx_over_limit;
extern u32 tx_lower_limit;
extern int retry_mis;
#ifdef SUPPORT_HT40
void xradio_get_ieee80211_tx_rate(struct xradio_common *hw_priv,
u16 RateEntry, struct ieee80211_tx_rate *rates)
{
if (GET_RATE_ENTRY_RATEINDEX(RateEntry) == FW_RATE_USE_DEFAULT) {
rates->idx = -1;
rates->count = 0;
rates->flags = 0;
return;
}
if (GET_RATE_ENTRY_MODEM(RateEntry) == FW_RATE_MODEM_HTOFDM) {
rates->idx = GET_RATE_ENTRY_RATEINDEX(RateEntry);
rates->count = GET_RATE_ENTRY_MAXRETRY(RateEntry);
rates->flags = IEEE80211_TX_RC_MCS;
if (GET_RATE_ENTRY_BANDWIDTH(RateEntry) == FW_RATE_BW_40M)
rates->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
if (GET_RATE_ENTRY_FLAGS(RateEntry) & FW_RATE_F_GF)
rates->flags |= IEEE80211_TX_RC_GREEN_FIELD;
if (GET_RATE_ENTRY_FLAGS(RateEntry) & FW_RATE_F_SGI)
rates->flags |= IEEE80211_TX_RC_SHORT_GI;
} else {
rates->idx = LegacyRxedRateLut[hw_priv->channel->band] \
[GET_RATE_ENTRY_RATEINDEX(RateEntry)];
rates->count = GET_RATE_ENTRY_MAXRETRY(RateEntry);
if (GET_RATE_ENTRY_FLAGS(RateEntry) & FW_RATE_F_SPRE)
rates->flags |= IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
}
return;
}
#endif
void xradio_tx_confirm_cb(struct xradio_common *hw_priv,
struct wsm_tx_confirm *arg)
{
u8 queue_id = xradio_queue_get_queue_id(arg->packetID);
struct xradio_queue *queue = &hw_priv->tx_queue[queue_id];
struct sk_buff *skb;
const struct xradio_txpriv *txpriv;
struct xradio_vif *priv;
u32 feedback_retry = 0;
#ifdef SUPPORT_HT40
if (arg->status) {
txrx_printk(XRADIO_DBG_WARN, "status=%d, retry=%d, lastRate=0x%04x\n",
arg->status, arg->ackFailures, arg->txedRateEntry);
} else {
txrx_printk(XRADIO_DBG_MSG, "status=%d, retry=%d, lastRate=0x%04x\n",
arg->status, arg->ackFailures, arg->txedRateEntry);
}
#else
if (arg->status) {
txrx_printk(XRADIO_DBG_NIY, "status=%d, retry=%d, lastRate=%d\n",
arg->status, arg->ackFailures, arg->txedRate);
} else {
txrx_printk(XRADIO_DBG_MSG, "status=%d, retry=%d, lastRate=%d\n",
arg->status, arg->ackFailures, arg->txedRate);
}
#endif
#ifdef TES_P2P_0002_ROC_RESTART
if ((TES_P2P_0002_state == TES_P2P_0002_STATE_GET_PKTID) &&
(arg->packetID == TES_P2P_0002_packet_id)) {
if (arg->status == 0x00) {
struct timeval TES_P2P_0002_tmval;
s32 TES_P2P_0002_roc_time;
s32 TES_P2P_0002_now_sec;
s32 TES_P2P_0002_now_usec;
bool TES_P2P_0002_roc_rst_need;
do_gettimeofday(&TES_P2P_0002_tmval);
TES_P2P_0002_roc_rst_need = false;
TES_P2P_0002_now_sec = (s32)(TES_P2P_0002_tmval.tv_sec);
TES_P2P_0002_now_usec = (s32)(TES_P2P_0002_tmval.tv_usec);
TES_P2P_0002_roc_time = TES_P2P_0002_roc_dur -
(((TES_P2P_0002_now_sec - TES_P2P_0002_roc_sec) * 1000) +
((TES_P2P_0002_now_usec - TES_P2P_0002_roc_usec) / 1000));
/* tx rsp to rx cfm will need more than 60ms */
if (TES_P2P_0002_roc_time < 100) {
TES_P2P_0002_roc_time = 100;
TES_P2P_0002_roc_rst_need = true;
}
if (TES_P2P_0002_roc_rst_need == true) {
txrx_printk(XRADIO_DBG_WARN,
"[ROC RESTART ACTIVE ON][Confirm CallBack]");
cancel_delayed_work_sync(&hw_priv->rem_chan_timeout);
if (atomic_read(&hw_priv->remain_on_channel)) {
queue_delayed_work(hw_priv->spare_workqueue,
&hw_priv->rem_chan_timeout,
(TES_P2P_0002_roc_time) * HZ / 1000);
}
}
}
TES_P2P_0002_state = TES_P2P_0002_STATE_IDLE;
txrx_printk(XRADIO_DBG_NIY,
"[ROC_RESTART_STATE_IDLE][Confirm CallBack]");
}
#endif
if (unlikely(xradio_itp_tx_running(hw_priv)))
return;
priv = xrwl_hwpriv_to_vifpriv(hw_priv, arg->if_id);
if (unlikely(!priv))
return;
if (unlikely(priv->mode == NL80211_IFTYPE_UNSPECIFIED)) {
/* STA is stopped. */
spin_unlock(&priv->vif_lock);
return;
}
if (SYS_WARN(queue_id >= 4)) {
spin_unlock(&priv->vif_lock);
return;
}
#ifdef CONFIG_XRADIO_TESTMODE
spin_lock_bh(&hw_priv->tsm_lock);
if ((arg->status == WSM_STATUS_RETRY_EXCEEDED) ||
(arg->status == WSM_STATUS_TX_LIFETIME_EXCEEDED)) {
hw_priv->tsm_stats.msdu_discarded_count++;
} else if ((hw_priv->start_stop_tsm.start) &&
(arg->status == WSM_STATUS_SUCCESS)) {
if (queue_id == hw_priv->tsm_info.ac) {
struct timeval tmval;
do_gettimeofday(&tmval);
u16 pkt_delay =
hw_priv->start_stop_tsm.packetization_delay;
if (hw_priv->tsm_info.sta_roamed &&
!hw_priv->tsm_info.use_rx_roaming) {
hw_priv->tsm_info.roam_delay = tmval.tv_usec -
hw_priv->tsm_info.txconf_timestamp_vo;
if (hw_priv->tsm_info.roam_delay > pkt_delay)
hw_priv->tsm_info.roam_delay -= pkt_delay;
txrx_printk(XRADIO_DBG_MSG, "[TX] txConf"
"Roaming: roam_delay = %u\n",
hw_priv->tsm_info.roam_delay);
hw_priv->tsm_info.sta_roamed = 0;
}
hw_priv->tsm_info.txconf_timestamp_vo = tmval.tv_usec;
}
}
spin_unlock_bh(&hw_priv->tsm_lock);
#endif /*CONFIG_XRADIO_TESTMODE*/
if ((arg->status == WSM_REQUEUE) &&
(arg->flags & WSM_TX_STATUS_REQUEUE)) {
/* "Requeue" means "implicit suspend" */
struct wsm_suspend_resume suspend = {
.link_id = arg->link_id,
.stop = 1,
.multicast = !arg->link_id,
.if_id = arg->if_id,
};
xradio_suspend_resume(priv, &suspend);
txrx_printk(XRADIO_DBG_NIY, "Requeue for link_id %d (try %d)."
" STAs asleep: 0x%.8X\n",
arg->link_id,
xradio_queue_get_generation(arg->packetID) + 1,
priv->sta_asleep_mask);
#ifdef CONFIG_XRADIO_TESTMODE
SYS_WARN(xradio_queue_requeue(hw_priv, queue,
arg->packetID, true));
#else
SYS_WARN(xradio_queue_requeue(queue,
arg->packetID, true));
#endif
spin_lock_bh(&priv->ps_state_lock);
if (!arg->link_id) {
priv->buffered_multicasts = true;
if (priv->sta_asleep_mask) {
queue_work(hw_priv->workqueue,
&priv->multicast_start_work);
}
}
spin_unlock_bh(&priv->ps_state_lock);
spin_unlock(&priv->vif_lock);
} else if (!xradio_queue_get_skb(
queue, arg->packetID, &skb, &txpriv)) {
struct ieee80211_tx_info *tx = IEEE80211_SKB_CB(skb);
struct ieee80211_hdr *frame =
(struct ieee80211_hdr *)&skb->data[txpriv->offset];
int tx_count = arg->ackFailures;
u8 ht_flags = 0;
/*
* reset if_0 in firmware when STA-unjoined,
* fix the errors when switch APs in combo mode.
*/
if (unlikely(ieee80211_is_disassoc(frame->frame_control) ||
ieee80211_is_deauth(frame->frame_control))) {
if (priv->join_status == XRADIO_JOIN_STATUS_STA) {
wsm_send_deauth_to_self(hw_priv, priv);
/* Shedule unjoin work */
txrx_printk(XRADIO_DBG_WARN,
"Issue unjoin command(TX) by self.\n");
wsm_lock_tx_async(hw_priv);
if (queue_work(hw_priv->workqueue, &priv->unjoin_work) <= 0)
wsm_unlock_tx(hw_priv);
}
}
#ifdef ROC_DEBUG
#ifndef P2P_MULTIVIF
if (txpriv->offchannel_if_id)
txrx_printk(XRADIO_DBG_ERROR, "TX CONFIRM %x - %d - %d\n",
skb->data[txpriv->offset],
txpriv->offchannel_if_id, arg->status);
#else
if (txpriv->if_id)
txrx_printk(XRADIO_DBG_ERROR, "TX CONFIRM %x - %d - %d\n",
skb->data[txpriv->offset],
txpriv->raw_if_id, arg->status);
#endif
#endif
#ifdef SUPPORT_HT40
if (priv->association_mode.PhyModeCfg.GF_Enable)
ht_flags |= IEEE80211_TX_RC_GREEN_FIELD;
#else
if (priv->association_mode.greenfieldMode)
ht_flags |= IEEE80211_TX_RC_GREEN_FIELD;
#endif
/* bss loss confirm. */
if (unlikely(priv->bss_loss_status == XRADIO_BSS_LOSS_CONFIRMING &&
priv->bss_loss_confirm_id == arg->packetID)) {
spin_lock(&priv->bss_loss_lock);
priv->bss_loss_status = arg->status ? XRADIO_BSS_LOSS_CONFIRMED :
XRADIO_BSS_LOSS_NONE;
spin_unlock(&priv->bss_loss_lock);
}
/*when less ap can't reply arp request accidentally,
*then disconnect actively,
*and wait system trigger reconnect again.
*/
#ifdef AP_ARP_COMPAT_FIX
if (likely(!arg->status) &&
(priv->join_status == XRADIO_JOIN_STATUS_STA) &&
(ieee80211_is_data(frame->frame_control))) {
u8 machdrlen = ieee80211_hdrlen(frame->frame_control);
u8 *llc_data = (u8 *)frame + machdrlen + txpriv->iv_len;
if (is_SNAP(llc_data) && is_arp(llc_data)) {
u8 *arp_hdr = llc_data + LLC_LEN;
u16 *arp_type = (u16 *)(arp_hdr + ARP_TYPE_OFFSET);
if (*arp_type == cpu_to_be16(ARP_REQUEST))
priv->arp_compat_cnt++;
if (priv->arp_compat_cnt > 10) {
txrx_printk(XRADIO_DBG_ERROR,
"ap don't reply arp resp count=%d\n",
priv->arp_compat_cnt);
priv->arp_compat_cnt = 0;
wsm_send_disassoc_to_self(hw_priv, priv);
}
}
}
#endif
if (likely(!arg->status)) {
tx->flags |= IEEE80211_TX_STAT_ACK;
priv->cqm_tx_failure_count = 0;
++tx_count;
#ifdef SUPPORT_HT40
if (((arg->txedRateEntry >> MODEMTYPE_SHIFT)
& MODEMTYPE_MASK) == RATE_MODEM_HTOFDM) {
if (((arg->txedRateEntry >> BANDWIDTH_SHIFT)
& BANDWIDTH_MASK)
== RATE_BANDWIDTH_20M) {
if (arg->txedRateEntry & RATE_F_SGI) {
u8 index = (arg->txedRateEntry
>> RATEINDEX_SHIFT)
& RATEINDEX_MASK;
TxedHtofdmRateMap[0][index]++;
} else {
u8 index = (arg->txedRateEntry
>> RATEINDEX_SHIFT)
& RATEINDEX_MASK;
TxedHtofdmRateMap[1][index]++;
}
} else {
if (arg->txedRateEntry & RATE_F_SGI) {
u8 index = (arg->txedRateEntry
>> RATEINDEX_SHIFT)
& RATEINDEX_MASK;
TxedHtofdmRateMap[2][index]++;
} else {
u8 index = (arg->txedRateEntry
>> RATEINDEX_SHIFT)
& RATEINDEX_MASK;
TxedHtofdmRateMap[3][index]++;
}
}
} else {
u8 index =
(arg->txedRateEntry >> RATEINDEX_SHIFT)
& RATEINDEX_MASK;
if (index < 6) {
if (arg->txedRateEntry
& RATE_F_PREAMBLE_S) {
TxedLegacyRateMap[0] \
[index*2+1]++;
} else {
TxedLegacyRateMap[0] \
[index*2]++;
}
} else {
TxedLegacyRateMap[1][index-6]++;
}
}
#else
if (arg->txedRate < 24)
TxedRateIdx_Map[arg->txedRate]++;
else
SYS_WARN(1);
#endif
xradio_debug_txed(priv);
if (arg->flags & WSM_TX_STATUS_AGGREGATION) {
/* Do not report aggregation to mac80211:
* it confuses minstrel a lot. */
/* tx->flags |= IEEE80211_TX_STAT_AMPDU; */
xradio_debug_txed_agg(priv);
}
} else {
/* TODO: Update TX failure counters */
if (unlikely(priv->cqm_tx_failure_thold &&
(++priv->cqm_tx_failure_count >
priv->cqm_tx_failure_thold))) {
priv->cqm_tx_failure_thold = 0;
queue_work(hw_priv->workqueue,
&priv->tx_failure_work);
}
if (tx_count)
++tx_count;
}
spin_unlock(&priv->vif_lock);
tx->status.ampdu_len = 1;
tx->status.ampdu_ack_len = 1;
#if 0
tx_count = arg->ackFailures+1;
for (i = 0; i < IEEE80211_TX_MAX_RATES; ++i) {
if (tx->status.rates[i].count >= tx_count) {
tx->status.rates[i].count = tx_count;
if (likely(!arg->status)) {
s8 txed_idx = xradio_get_rate_idx(hw_priv,
tx->status.rates[i].flags,
arg->txedRate);
if (tx->status.rates[i].idx != txed_idx) {
if (i < (IEEE80211_TX_MAX_RATES-1)) {
i++;
tx->status.rates[i].idx = txed_idx;
tx->status.rates[i].count = 1;
} else if (txed_idx >= 0) {
tx->status.rates[i].idx = txed_idx;
tx->status.rates[i].count = 1;
}
}
}
break;
}
tx_count -= tx->status.rates[i].count;
if (tx->status.rates[i].flags & IEEE80211_TX_RC_MCS)
tx->status.rates[i].flags |= ht_flags;
}
for (++i; i < IEEE80211_TX_MAX_RATES; ++i) {
tx->status.rates[i].count = 0;
tx->status.rates[i].idx = -1;
}
#else
#ifdef SUPPORT_HT40
if (txpriv->use_bg_rate) {
tx->status.rates[0].count = arg->ackFailures+1;
tx->status.rates[0].idx = 0;
tx->status.rates[1].idx = -1;
tx->status.rates[2].idx = -1;
tx->status.rates[3].idx = -1;
tx->status.rates[4].idx = -1;
} else {
u8 RateTryIdx = 0x0;
u8 BreakIdx = 0x0;
bool IsFind = false;
bool IsBreak = false;
for (RateTryIdx = 0; RateTryIdx < IEEE80211_TX_MAX_RATES; RateTryIdx++) {
if (!IsBreak)
BreakIdx = RateTryIdx;
if (GET_RATE_ENTRY_RATEINDEX(arg->RateTry[RateTryIdx]) == FW_RATE_USE_DEFAULT)
IsBreak = true;
if (IsBreak) {
tx->status.rates[RateTryIdx].idx = -1;
tx->status.rates[RateTryIdx].count = 0;
tx->status.rates[RateTryIdx].flags = 0;
} else {
xradio_get_ieee80211_tx_rate(hw_priv,
arg->RateTry[RateTryIdx], &tx->status.rates[RateTryIdx]);
if ((!arg->status) && (!IsFind)) {
if ((arg->RateTry[RateTryIdx]&0xFFF0) == (arg->txedRateEntry&0xFFF0)) {
tx->status.rates[RateTryIdx].count++;
IsFind = true;
}
}
}
}
if ((!arg->status) && (!IsFind)) {
if (!IsBreak)
BreakIdx = 4;
xradio_get_ieee80211_tx_rate(hw_priv, arg->txedRateEntry, &tx->status.rates[BreakIdx]);
tx->status.rates[BreakIdx].count = 1;
}
}
#else
txrx_printk(XRADIO_DBG_MSG,
"feedback:%08x, %08x, %08x.\n",
arg->rate_try[2], arg->rate_try[1], arg->rate_try[0]);
if (txpriv->use_bg_rate) { /* bg rates */
tx->status.rates[0].count = arg->ackFailures+1;
tx->status.rates[0].idx = 0;
tx->status.rates[1].idx = -1;
tx->status.rates[2].idx = -1;
tx->status.rates[3].idx = -1;
tx->status.rates[4].idx = -1;
} else {
int i;
int j;
s8 txed_idx;
register u8 rate_num = 0, shift = 0, retries = 0;
u8 flag = tx->status.rates[0].flags;
/* get retry rate idx. */
for (i = 2; i >= 0; i--) {
if (arg->rate_try[i]) {
for (j = 7; j >= 0; j--) {
shift = j<<2;
retries = (arg->rate_try[i]>>shift) & 0xf;
if (retries) {
feedback_retry += retries;
txed_idx = xradio_get_rate_idx(hw_priv, flag,
((i<<3) + j));
txrx_printk(XRADIO_DBG_MSG,
"rate_num=%d, hw=%d, idx=%d, "
"retries=%d, flag=%d",
rate_num, ((i<<3)+j),
txed_idx, retries, flag);
if (likely(txed_idx >= 0)) {
tx->status.rates[rate_num].idx = txed_idx;
tx->status.rates[rate_num].count = retries;
if (tx->status.rates[rate_num].flags &
IEEE80211_TX_RC_MCS)
tx->status.rates[rate_num].flags |=
ht_flags;
rate_num++;
if (rate_num >= IEEE80211_TX_MAX_RATES) {
i = -1;
break;
}
}
}
}
}
}
/* If there is 11b rates in 11n mode, put it into MCS0 */
if ((arg->rate_try[0]&0xffff) && (flag & IEEE80211_TX_RC_MCS)) {
int br_retrys = 0;
for (i = 0; i < 16; i += 4)
br_retrys += ((arg->rate_try[0]>>i)&0xf);
if (rate_num > 0 && tx->status.rates[rate_num-1].idx == 0) {
tx->status.rates[rate_num-1].count += br_retrys;
} else if (rate_num < IEEE80211_TX_MAX_RATES) {
tx->status.rates[rate_num].idx = 0;
tx->status.rates[rate_num].count += br_retrys;
rate_num++;
}
}
/* clear other rate. */
for (i = rate_num; i < IEEE80211_TX_MAX_RATES; ++i) {
tx->status.rates[i].count = 0;
tx->status.rates[i].idx = -1;
}
/* get successful rate idx. */
if (!arg->status) {
txed_idx = xradio_get_rate_idx(hw_priv, flag, arg->txedRate);
if (rate_num == 0) {
tx->status.rates[0].idx = txed_idx;
tx->status.rates[0].count = 1;
} else if (rate_num <= IEEE80211_TX_MAX_RATES) {
--rate_num;
if (txed_idx == tx->status.rates[rate_num].idx) {
tx->status.rates[rate_num].count += 1;
} else if (rate_num < (IEEE80211_TX_MAX_RATES-1)) {
++rate_num;
tx->status.rates[rate_num].idx = txed_idx;
tx->status.rates[rate_num].count = 1;
} else if (txed_idx >= 0) {
tx->status.rates[rate_num].idx = txed_idx;
tx->status.rates[rate_num].count = 1;
}
}
}
}
#endif
#endif
#ifdef CONFIG_XRADIO_DEBUGFS
if (arg->status == WSM_STATUS_RETRY_EXCEEDED) {
tx_retrylimit++;
retry_mis += ((s32)hw_priv->short_frame_max_tx_count -
arg->ackFailures-1);
if (arg->ackFailures != (hw_priv->short_frame_max_tx_count-1)) {
if (arg->ackFailures < (hw_priv->short_frame_max_tx_count-1))
tx_lower_limit++;
else
tx_over_limit++;
txrx_printk(XRADIO_DBG_NIY,
"retry_err, ackFailures=%d, feedbk_retry=%d.\n",
arg->ackFailures, feedback_retry);
}
} else if (feedback_retry > hw_priv->short_frame_max_tx_count-1) {
tx_over_limit++;
txrx_printk(XRADIO_DBG_WARN,
"status=%d, ackFailures=%d, feedbk_retry=%d.\n",
arg->status, arg->ackFailures, feedback_retry);
}
#endif
txrx_printk(XRADIO_DBG_MSG, "[TX policy] Ack: " \
"%d:%d, %d:%d, %d:%d, %d:%d, %d:%d\n",
tx->status.rates[0].idx, tx->status.rates[0].count,
tx->status.rates[1].idx, tx->status.rates[1].count,
tx->status.rates[2].idx, tx->status.rates[2].count,
tx->status.rates[3].idx, tx->status.rates[3].count,
tx->status.rates[4].idx, tx->status.rates[4].count);
#ifdef CONFIG_XRADIO_TESTMODE
xradio_queue_remove(hw_priv, queue, arg->packetID);
#else
xradio_queue_remove(queue, arg->packetID);
#endif /*CONFIG_XRADIO_TESTMODE*/
} else {
spin_unlock(&priv->vif_lock);
txrx_printk(XRADIO_DBG_WARN,
"%s xradio_queue_get_skb failed.\n", __func__);
}
}
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
static void xradio_set_skb_eosp(struct sk_buff *skb)
{
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
info->flags |= IEEE80211_TX_STATUS_EOSP;
}
#endif
static void xradio_notify_buffered_tx(struct xradio_vif *priv,
struct sk_buff *skb, int link_id, int tid)
{
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
struct ieee80211_sta *sta;
struct ieee80211_hdr *hdr;
u8 *buffered;
u8 still_buffered = 0;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (link_id && tid < XRADIO_MAX_TID) {
buffered = priv->link_id_db
[link_id - 1].buffered;
spin_lock_bh(&priv->ps_state_lock);
if (!SYS_WARN(!buffered[tid]))
still_buffered = --buffered[tid];
spin_unlock_bh(&priv->ps_state_lock);
if (!still_buffered && tid < XRADIO_MAX_TID) {
hdr = (struct ieee80211_hdr *) skb->data;
rcu_read_lock();
sta = mac80211_find_sta(priv->vif, hdr->addr1);
if (sta) {
mac80211_sta_set_buffered(sta, tid, false);
xradio_set_skb_eosp(skb);
}
rcu_read_unlock();
}
}
#endif /* CONFIG_XRADIO_USE_EXTENSIONS */
}
void xradio_skb_dtor(struct xradio_common *hw_priv,
struct sk_buff *skb,
const struct xradio_txpriv *txpriv)
{
struct xradio_vif *priv =
__xrwl_hwpriv_to_vifpriv(hw_priv, txpriv->if_id);
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
skb_pull(skb, txpriv->offset);
if (priv && txpriv->rate_id != XRADIO_INVALID_RATE_ID) {
xradio_notify_buffered_tx(priv, skb,
txpriv->raw_link_id, txpriv->tid);
tx_policy_put(hw_priv, txpriv->rate_id);
}
if (likely(!xradio_is_itp(hw_priv))) {
down(&hw_priv->dtor_lock);
mac80211_tx_status(hw_priv->hw, skb);
up(&hw_priv->dtor_lock);
}
}
#ifdef CONFIG_XRADIO_TESTMODE
/* TODO It should be removed before official delivery */
static void frame_hexdump(char *prefix, u8 *data, int len)
{
int i;
txrx_printk(XRADIO_DBG_MSG, "%s hexdump:\n", prefix);
for (i = 0; i < len; i++) {
if (i + 10 < len) {
txrx_printk(XRADIO_DBG_MSG, "%.1X %.1X %.1X %.1X" \
"%.1X %.1X %.1X %.1X %.1X %.1X",
data[i], data[i+1], data[i+2],
data[i+3], data[i+4], data[i+5],
data[i+6], data[i+7], data[i+8],
data[i+9]);
i += 9;
} else {
txrx_printk(XRADIO_DBG_MSG, "%.1X ", data[i]);
}
}
}
/**
* c1200_tunnel_send_testmode_data - Send test frame to the driver
*
* @priv: pointer to xradio private structure
* @skb: skb with frame
*
* Returns: 0 on success or non zero value on failure
*/
static int xradio_tunnel_send_testmode_data(struct xradio_common *hw_priv,
struct sk_buff *skb)
{
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (xradio_tesmode_event(hw_priv->hw->wiphy, XR_MSG_EVENT_FRAME_DATA,
skb->data, skb->len, GFP_ATOMIC))
return -EINVAL;
return 0;
}
/**
* xradio_frame_test_detection - Detection frame_test
*
* @priv: pointer to xradio vif structure
* @frame: ieee80211 header
* @skb: skb with frame
*
* Returns: 1 - frame test detected, 0 - not detected
*/
static int xradio_frame_test_detection(struct xradio_vif *priv,
struct ieee80211_hdr *frame,
struct sk_buff *skb)
{
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
int hdrlen = ieee80211_hdrlen(frame->frame_control);
int detected = 0;
int ret;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (hdrlen + hw_priv->test_frame.len <= skb->len &&
memcmp(skb->data + hdrlen, hw_priv->test_frame.data,
hw_priv->test_frame.len) == 0) {
detected = 1;
txrx_printk(XRADIO_DBG_MSG, "TEST FRAME detected");
frame_hexdump("TEST FRAME original:", skb->data, skb->len);
ret = ieee80211_data_to_8023(skb, hw_priv->mac_addr,
priv->mode);
if (!ret) {
frame_hexdump("FRAME 802.3:", skb->data, skb->len);
ret = xradio_tunnel_send_testmode_data(hw_priv, skb);
}
if (ret)
txrx_printk(XRADIO_DBG_ERROR, "Send TESTFRAME failed(%d)", ret);
}
return detected;
}
#endif /* CONFIG_XRADIO_TESTMODE */
static void
xradio_rx_h_ba_stat(struct xradio_vif *priv,
size_t hdrlen, size_t skb_len)
{
struct xradio_common *hw_priv = priv->hw_priv;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (priv->join_status != XRADIO_JOIN_STATUS_STA)
return;
if (!xradio_is_ht(&hw_priv->ht_info))
return;
if (!priv->setbssparams_done)
return;
spin_lock_bh(&hw_priv->ba_lock);
hw_priv->ba_acc_rx += skb_len - hdrlen;
if (!(hw_priv->ba_cnt_rx || hw_priv->ba_cnt)) {
mod_timer(&hw_priv->ba_timer,
jiffies + XRADIO_BLOCK_ACK_INTERVAL);
}
hw_priv->ba_cnt_rx++;
spin_unlock_bh(&hw_priv->ba_lock);
}
#if 0
u8 nettest_bssid[] = {0x00, 0x02, 0x03, 0x04, 0x05, 0x06};
u8 save_rate_ie;
#endif
#if PERF_INFO_TEST
struct timeval upper_rx_time;
size_t upper_rx_size;
#endif
void xradio_rx_cb(struct xradio_vif *priv,
struct wsm_rx *arg,
struct sk_buff **skb_p)
{
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
struct sk_buff *skb = *skb_p;
struct ieee80211_rx_status *hdr = IEEE80211_SKB_RXCB(skb);
struct ieee80211_hdr *frame = (struct ieee80211_hdr *)skb->data;
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
#endif
struct xradio_link_entry *entry = NULL;
unsigned long grace_period;
bool early_data = false;
size_t hdrlen = 0;
u8 parse_iv_len = 0;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
hdr->flag = 0;
if (unlikely(priv->mode == NL80211_IFTYPE_UNSPECIFIED)) {
/* STA is stopped. */
goto drop;
}
#ifdef TES_P2P_0002_ROC_RESTART
xradio_frame_monitor(hw_priv, skb, false);
#endif
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
if ((ieee80211_is_action(frame->frame_control))
&& (mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)) {
u8 *action = (u8 *)&mgmt->u.action.category;
xradio_check_go_neg_conf_success(hw_priv, action);
}
#endif
#ifdef CONFIG_XRADIO_TESTMODE
spin_lock_bh(&hw_priv->tsm_lock);
if (hw_priv->start_stop_tsm.start) {
unsigned queue_id = skb_get_queue_mapping(skb);
if (queue_id == 0) {
struct timeval tmval;
do_gettimeofday(&tmval);
if (hw_priv->tsm_info.sta_roamed &&
hw_priv->tsm_info.use_rx_roaming) {
hw_priv->tsm_info.roam_delay = tmval.tv_usec -
hw_priv->tsm_info.rx_timestamp_vo;
txrx_printk(XRADIO_DBG_NIY, "[RX] RxInd Roaming:"
"roam_delay = %u\n", hw_priv->tsm_info.roam_delay);
hw_priv->tsm_info.sta_roamed = 0;
}
hw_priv->tsm_info.rx_timestamp_vo = tmval.tv_usec;
}
}
spin_unlock_bh(&hw_priv->tsm_lock);
#endif /*CONFIG_XRADIO_TESTMODE*/
if (arg->link_id && (arg->link_id != XRADIO_LINK_ID_UNMAPPED)
&& (arg->link_id <= XRADIO_MAX_STA_IN_AP_MODE)) {
entry = &priv->link_id_db[arg->link_id - 1];
if (entry->status == XRADIO_LINK_SOFT &&
ieee80211_is_data(frame->frame_control))
early_data = true;
entry->timestamp = jiffies;
}
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
else if ((arg->link_id == XRADIO_LINK_ID_UNMAPPED)
&& (priv->vif->p2p == WSM_START_MODE_P2P_GO)
&& ieee80211_is_action(frame->frame_control)
&& (mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)) {
txrx_printk(XRADIO_DBG_NIY, "[RX] Going to MAP&RESET link ID\n");
#if defined (DEBUG_P2P_SETTING_CRASH)
printk(KERN_ERR "[BUG12]link ID is unmapped,go to MAP&RESET link ID\n");
#endif
if (work_pending(&priv->linkid_reset_work))
SYS_WARN(1);
memcpy(&priv->action_frame_sa[0],
ieee80211_get_SA(frame), ETH_ALEN);
priv->action_linkid = 0;
schedule_work(&priv->linkid_reset_work);
}
if (arg->link_id && (arg->link_id != XRADIO_LINK_ID_UNMAPPED)
&& (priv->vif->p2p == WSM_START_MODE_P2P_GO)
&& ieee80211_is_action(frame->frame_control)
&& (mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)) {
/* Link ID already exists for the ACTION frame.
* Reset and Remap */
if (work_pending(&priv->linkid_reset_work))
SYS_WARN(1);
memcpy(&priv->action_frame_sa[0],
ieee80211_get_SA(frame), ETH_ALEN);
priv->action_linkid = arg->link_id;
schedule_work(&priv->linkid_reset_work);
}
#endif
if (unlikely(arg->status)) {
if (arg->status == WSM_STATUS_MICFAILURE) {
txrx_printk(XRADIO_DBG_WARN, "[RX] IF=%d, MIC failure.\n",
priv->if_id);
hdr->flag |= RX_FLAG_MMIC_ERROR;
} else if (arg->status == WSM_STATUS_NO_KEY_FOUND) {
#ifdef MONITOR_MODE
if (hw_priv->monitor_if_id == -1) {
#endif
txrx_printk(XRADIO_DBG_WARN, "[RX] IF=%d, No key found.\n",
priv->if_id);
goto drop;
#ifdef MONITOR_MODE
}
#endif
} else {
txrx_printk(XRADIO_DBG_WARN, "[RX] IF=%d, Receive failure: %d.\n",
priv->if_id, arg->status);
goto drop;
}
}
if (skb->len < sizeof(struct ieee80211_pspoll)) {
txrx_printk(XRADIO_DBG_WARN, "Mailformed SDU rx'ed. "
"Size is lesser than IEEE header.\n");
goto drop;
}
if (unlikely(ieee80211_is_pspoll(frame->frame_control)))
if (xradio_handle_pspoll(priv, skb))
goto drop;
hdr->mactime = 0; /* Not supported by WSM */
hdr->band = (arg->channelNumber > 14) ?
NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
hdr->freq = ieee80211_channel_to_frequency(
arg->channelNumber,
hdr->band);
#ifdef AP_HT_COMPAT_FIX
#ifdef SUPPORT_HT40
if (!priv->ht_compat_det && priv->htcap &&
ieee80211_is_data_qos(frame->frame_control)) {
if (xradio_apcompat_detect(priv, arg->rxedRateEntry))
goto drop;
}
#else
if (!priv->ht_compat_det && priv->htcap &&
ieee80211_is_data_qos(frame->frame_control)) {
if (xradio_apcompat_detect(priv, arg->rxedRate))
goto drop;
}
#endif
#endif
#ifdef SUPPORT_HT40
if (((arg->rxedRateEntry >> MODEMTYPE_SHIFT) & MODEMTYPE_MASK) ==
RATE_MODEM_HTOFDM) {
if (((arg->rxedRateEntry >> BANDWIDTH_SHIFT) & BANDWIDTH_MASK) ==
RATE_BANDWIDTH_20M) {
if (arg->rxedRateEntry & RATE_F_SGI) {
u8 index = (arg->rxedRateEntry >> RATEINDEX_SHIFT) & RATEINDEX_MASK;
RxedHtofdmRateMap[0][index]++;
} else {
u8 index = (arg->rxedRateEntry >> RATEINDEX_SHIFT) & RATEINDEX_MASK;
RxedHtofdmRateMap[1][index]++;
}
} else {
if (arg->rxedRateEntry & RATE_F_SGI) {
u8 index = (arg->rxedRateEntry >> RATEINDEX_SHIFT) & RATEINDEX_MASK;
RxedHtofdmRateMap[2][index]++;
} else {
u8 index = (arg->rxedRateEntry >> RATEINDEX_SHIFT) & RATEINDEX_MASK;
RxedHtofdmRateMap[3][index]++;
}
}
} else {
u8 index = (arg->rxedRateEntry >> RATEINDEX_SHIFT) & RATEINDEX_MASK;
if (index < 6) {
if (arg->rxedRateEntry & RATE_F_PREAMBLE_S)
RxedLegacyRateMap[0][index*2+1]++;
else
RxedLegacyRateMap[0][index*2]++;
} else {
RxedLegacyRateMap[1][index-6]++;
}
}
if (GET_RATE_ENTRY_MODEM(arg->rxedRateEntry) == FW_RATE_MODEM_HTOFDM) {
hdr->flag |= RX_FLAG_HT;
hdr->rate_idx = GET_RATE_ENTRY_RATEINDEX(arg->rxedRateEntry);
if (GET_RATE_ENTRY_BANDWIDTH(arg->rxedRateEntry) == FW_RATE_BW_40M)
hdr->flag |= RX_FLAG_40MHZ;
if (GET_RATE_ENTRY_FLAGS(arg->rxedRateEntry)&FW_RATE_F_SGI)
hdr->flag |= RX_FLAG_SHORT_GI;
} else {
hdr->rate_idx = LegacyRxedRateLut[hdr->band][GET_RATE_ENTRY_RATEINDEX(arg->rxedRateEntry)];
if (GET_RATE_ENTRY_FLAGS(arg->rxedRateEntry)&FW_RATE_F_SPRE)
hdr->flag |= RX_FLAG_SHORTPRE;
}
#else
if (arg->rxedRate < 24)
RxedRateIdx_Map[arg->rxedRate]++;
else
SYS_WARN(1);
if (arg->rxedRate >= 14) {
hdr->flag |= RX_FLAG_HT;
hdr->rate_idx = arg->rxedRate - 14;
} else if (arg->rxedRate >= 4) {
if (hdr->band == NL80211_BAND_5GHZ)
hdr->rate_idx = arg->rxedRate - 6;
else
hdr->rate_idx = arg->rxedRate - 2;
} else {
hdr->rate_idx = arg->rxedRate;
}
#endif
hdr->signal = (s8)arg->rcpiRssi;
hdr->antenna = 0;
hdrlen = ieee80211_hdrlen(frame->frame_control);
if (WSM_RX_STATUS_ENCRYPTION(arg->flags)) {
size_t iv_len = 0, icv_len = 0;
hdr->flag |= RX_FLAG_DECRYPTED;
/* Oops... There is no fast way to ask mac80211 about
* IV/ICV lengths. Even defineas are not exposed.*/
switch (WSM_RX_STATUS_ENCRYPTION(arg->flags)) {
case WSM_RX_STATUS_WEP:
iv_len = 4 /* WEP_IV_LEN */;
icv_len = 4 /* WEP_ICV_LEN */;
break;
case WSM_RX_STATUS_TKIP:
iv_len = 8 /* TKIP_IV_LEN */;
icv_len = 4 /* TKIP_ICV_LEN */
+ 8 /*MICHAEL_MIC_LEN*/;
break;
case WSM_RX_STATUS_AES:
iv_len = 8 /* CCMP_HDR_LEN */;
icv_len = 8 /* CCMP_MIC_LEN */;
break;
case WSM_RX_STATUS_WAPI:
iv_len = 18 /* WAPI_HDR_LEN */;
icv_len = 16 /* WAPI_MIC_LEN */;
hdr->flag |= RX_FLAG_IV_STRIPPED;
break;
default:
SYS_WARN("Unknown encryption type");
goto drop;
}
/* Firmware strips ICV in case of MIC failure. */
if (arg->status == WSM_STATUS_MICFAILURE) {
icv_len = 0;
hdr->flag |= RX_FLAG_IV_STRIPPED;
}
if (skb->len < hdrlen + iv_len + icv_len) {
txrx_printk(XRADIO_DBG_WARN, "Mailformed SDU rx'ed. "
"Size is lesser than crypto headers.\n");
goto drop;
}
if (WSM_RX_STATUS_ENCRYPTION(arg->flags) ==
WSM_RX_STATUS_TKIP) {
/* Remove TKIP MIC 8 bytes*/
memmove(skb->data + skb->len-icv_len,
skb->data + skb->len-icv_len+8, 4);
skb_trim(skb, skb->len - 8);
hdr->flag |= RX_FLAG_MMIC_STRIPPED;
} else if (unlikely(WSM_RX_STATUS_ENCRYPTION(arg->flags) ==
WSM_RX_STATUS_WAPI)) {
/* Protocols not defined in mac80211 should be
stripped/crypted in driver/firmware */
/* Remove IV, ICV and MIC */
skb_trim(skb, skb->len - icv_len);
memmove(skb->data + iv_len, skb->data, hdrlen);
skb_pull(skb, iv_len);
}
parse_iv_len = iv_len;
}
xradio_debug_rxed(priv);
if (arg->flags & WSM_RX_STATUS_AGGREGATE)
xradio_debug_rxed_agg(priv);
#if 0
/*for nettest*/
if (ieee80211_is_probe_resp(frame->frame_control) &&
!arg->status &&
!memcmp(ieee80211_get_SA(frame), nettest_bssid, ETH_ALEN)) {
const u8 *supp_rate_ie;
u8 *ies = ((struct ieee80211_mgmt *)
(skb->data))->u.probe_resp.variable;
size_t ies_len = skb->len - (ies - (u8 *)(skb->data));
supp_rate_ie = xradio_get_ie(ies, ies_len, WLAN_EID_SUPP_RATES);
save_rate_ie = supp_rate_ie[2];
txrx_printk(XRADIO_DBG_WARN, "[netest]: save_rate_ie=%2x\n",
save_rate_ie);
}
if (ieee80211_is_assoc_resp(frame->frame_control) &&
!arg->status &&
!memcmp(ieee80211_get_SA(frame), nettest_bssid, ETH_ALEN)) {
u8 *supp_rate_ie2;
size_t ies_len;
u8 *ies = ((struct ieee80211_mgmt *)
(skb->data))->u.assoc_resp.variable;
ies_len = skb->len - (ies - (u8 *)(skb->data));
supp_rate_ie2 = xradio_get_ie(ies, ies_len, WLAN_EID_SUPP_RATES);
if ((supp_rate_ie2[1] == 1) && (supp_rate_ie2[2] == 0x80)) {
supp_rate_ie2[2] = save_rate_ie;
txrx_printk(XRADIO_DBG_WARN,
"[netest]: rate_ie modified=%2x\n",
supp_rate_ie2[2]);
}
}
/*for test*/
#endif
if (ieee80211_is_beacon(frame->frame_control) &&
!arg->status &&
!memcmp(ieee80211_get_SA(frame), priv->join_bssid, ETH_ALEN)) {
const u8 *tim_ie;
u8 *ies;
size_t ies_len;
priv->disable_beacon_filter = false;
queue_work(hw_priv->workqueue, &priv->update_filtering_work);
ies = ((struct ieee80211_mgmt *)
(skb->data))->u.beacon.variable;
ies_len = skb->len - (ies - (u8 *)(skb->data));
tim_ie = xradio_get_ie(ies, ies_len, WLAN_EID_TIM);
if (tim_ie) {
struct ieee80211_tim_ie *tim =
(struct ieee80211_tim_ie *)&tim_ie[2];
if (priv->join_dtim_period != tim->dtim_period) {
priv->join_dtim_period = tim->dtim_period;
queue_work(hw_priv->workqueue,
&priv->set_beacon_wakeup_period_work);
}
}
if (unlikely(priv->disable_beacon_filter)) {
priv->disable_beacon_filter = false;
queue_work(hw_priv->workqueue,
&priv->update_filtering_work);
}
}
#ifdef AP_HT_CAP_UPDATE
if (priv->mode == NL80211_IFTYPE_AP &&
ieee80211_is_beacon(frame->frame_control) &&
((priv->ht_info&HT_INFO_MASK) != 0x0011) &&
!arg->status) {
u8 *ies;
size_t ies_len;
const u8 *ht_cap;
ies = ((struct ieee80211_mgmt *)(skb->data))->u.beacon.variable;
ies_len = skb->len - (ies - (u8 *)(skb->data));
ht_cap = xradio_get_ie(ies, ies_len, WLAN_EID_HT_CAPABILITY);
if (!ht_cap) {
priv->ht_info |= 0x0011;
queue_work(hw_priv->workqueue, &priv->ht_info_update_work);
}
}
#endif
#ifdef AP_HT_COMPAT_FIX
if (ieee80211_is_mgmt(frame->frame_control) &&
priv->if_id == 0 && !(priv->ht_compat_det & 0x10)) {
xradio_remove_ht_ie(priv, skb);
}
#endif
#ifdef ROAM_OFFLOAD
if ((ieee80211_is_beacon(frame->frame_control) ||
ieee80211_is_probe_resp(frame->frame_control)) &&
!arg->status) {
if (hw_priv->auto_scanning &&
!atomic_read(&hw_priv->scan.in_progress))
hw_priv->frame_rcvd = 1;
if (!memcmp(ieee80211_get_SA(frame), priv->join_bssid, ETH_ALEN)) {
if (hw_priv->beacon)
dev_kfree_skb(hw_priv->beacon);
hw_priv->beacon = skb_copy(skb, GFP_ATOMIC);
if (!hw_priv->beacon)
txrx_printk(XRADIO_DBG_ERROR,
"sched_scan: own beacon storing failed\n");
}
}
#endif /*ROAM_OFFLOAD*/
/*scanResult.timestamp to adapt to Framework(WiFi) on Android5.0 or advanced version.*/
if ((ieee80211_is_beacon(mgmt->frame_control) ||
ieee80211_is_probe_resp(mgmt->frame_control))
&& !arg->status) {
struct timespec ts;
u64 tv_nsec;
get_monotonic_boottime(&ts);
tv_nsec = ts.tv_nsec;
do_div(tv_nsec, 1000);
if (ieee80211_is_beacon(mgmt->frame_control)) {
mgmt->u.beacon.timestamp = ((u64)ts.tv_sec * 1000000 + tv_nsec);
} else if (ieee80211_is_probe_resp(mgmt->frame_control)) {
mgmt->u.probe_resp.timestamp = ((u64)ts.tv_sec * 1000000 + tv_nsec);
}
}
/* don't delay scan before next connect */
if (ieee80211_is_deauth(frame->frame_control) ||
ieee80211_is_disassoc(frame->frame_control))
hw_priv->scan_delay_status[priv->if_id] = XRADIO_SCAN_ALLOW;
/* Stay awake for 1sec. after frame is received to give
* userspace chance to react and acquire appropriate
* wakelock. */
if (ieee80211_is_auth(frame->frame_control))
grace_period = 5 * HZ;
else if (ieee80211_is_deauth(frame->frame_control))
grace_period = 5 * HZ;
else
grace_period = HZ;
if (ieee80211_is_data(frame->frame_control))
xradio_rx_h_ba_stat(priv, hdrlen, skb->len);
#ifdef CONFIG_PM
xradio_pm_stay_awake(&hw_priv->pm_state, grace_period);
#endif
#ifdef CONFIG_XRADIO_TESTMODE
if (hw_priv->test_frame.len > 0 &&
priv->mode == NL80211_IFTYPE_STATION) {
if (xradio_frame_test_detection(priv, frame, skb) == 1) {
consume_skb(skb);
*skb_p = NULL;
return;
}
}
#endif /* CONFIG_XRADIO_TESTMODE */
#ifdef AP_ARP_COMPAT_FIX
if (priv->join_status == XRADIO_JOIN_STATUS_STA) {
u16 fctl = frame->frame_control;
if (ieee80211_is_data(fctl)) {
u8 machdrlen = ieee80211_hdrlen(fctl);
u8 *llc_data = (u8 *)frame + machdrlen + parse_iv_len;
if (is_SNAP(llc_data) && is_arp(llc_data)) {
u8 *arp_hdr = llc_data + LLC_LEN;
u16 *arp_type = (u16 *)(arp_hdr + ARP_TYPE_OFFSET);
if (*arp_type == cpu_to_be16(ARP_RESPONSE)) {
priv->arp_compat_cnt = 0;
}
}
}
}
#endif
#if (defined(CONFIG_XRADIO_DEBUG))
/* parsse frame here for debug. */
if (rxparse_flags)
xradio_parse_frame(skb->data, parse_iv_len,
rxparse_flags|PF_RX, priv->if_id);
#endif
/* Some aps change channel to inform station by sending beacon with WLAN_EID_DS_PARAMS ie,
*then station needs to reconnect to ap.
*/
if (ieee80211_is_beacon(frame->frame_control) &&
!arg->status &&
(priv->join_status == XRADIO_JOIN_STATUS_STA) &&
!memcmp(ieee80211_get_SA(frame), priv->join_bssid, ETH_ALEN)) {
const u8 *ds_ie;
u8 *ies;
size_t ies_len;
int ds_ie_partms_chan = 0;
ies = ((struct ieee80211_mgmt *)
(skb->data))->u.beacon.variable;
ies_len = skb->len - (ies - (u8 *)(skb->data));
ds_ie = xradio_get_ie(ies, ies_len, WLAN_EID_DS_PARAMS);
if (ds_ie && (ds_ie[1] == 1)) {
ds_ie_partms_chan = ds_ie[2];
if (ds_ie_partms_chan != hw_priv->join_chan) {
txrx_printk(XRADIO_DBG_WARN, "***ap changes channel by beacon with ds ie,"
"then station reconnects to ap, %d -> %d\n",
hw_priv->join_chan, ds_ie_partms_chan);
wsm_send_disassoc_to_self(hw_priv, priv);
}
}
}
#if PERF_INFO_TEST
upper_rx_size = skb->len;
#endif
PERF_INFO_GETTIME(&upper_rx_time);
/* Try to a packet for the case dev_alloc_skb failed in bh.*/
if (unlikely(xradio_itp_rxed(hw_priv, skb)))
consume_skb(skb);
else if (unlikely(early_data)) {
spin_lock_bh(&priv->ps_state_lock);
/* Double-check status with lock held */
if (entry->status == XRADIO_LINK_SOFT) {
skb_queue_tail(&entry->rx_queue, skb);
txrx_printk(XRADIO_DBG_WARN, "***skb_queue_tail\n");
} else
mac80211_rx_irqsafe(priv->hw, skb);
spin_unlock_bh(&priv->ps_state_lock);
} else {
mac80211_rx_irqsafe(priv->hw, skb);
}
*skb_p = NULL;
PERF_INFO_STAMP(&upper_rx_time, &mac_rx, upper_rx_size);
return;
drop:
/* TODO: update failure counters */
return;
}
/* ******************************************************************** */
/* Security */
int xradio_alloc_key(struct xradio_common *hw_priv)
{
int idx;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
idx = ffs(~hw_priv->key_map) - 1;
if (idx < 0 || idx > WSM_KEY_MAX_INDEX)
return -1;
hw_priv->key_map |= BIT(idx);
hw_priv->keys[idx].entryIndex = idx;
txrx_printk(XRADIO_DBG_NIY, "%s, idx=%d\n", __func__, idx);
return idx;
}
void xradio_free_key(struct xradio_common *hw_priv, int idx)
{
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
SYS_BUG(!(hw_priv->key_map & BIT(idx)));
memset(&hw_priv->keys[idx], 0, sizeof(hw_priv->keys[idx]));
hw_priv->key_map &= ~BIT(idx);
txrx_printk(XRADIO_DBG_NIY, "%s, idx=%d\n", __func__, idx);
}
void xradio_free_keys(struct xradio_common *hw_priv)
{
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
memset(&hw_priv->keys, 0, sizeof(hw_priv->keys));
hw_priv->key_map = 0;
}
int xradio_upload_keys(struct xradio_vif *priv)
{
struct xradio_common *hw_priv = xrwl_vifpriv_to_hwpriv(priv);
int idx, ret = 0;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
for (idx = 0; idx <= WSM_KEY_MAX_IDX; ++idx)
if (hw_priv->key_map & BIT(idx)) {
ret = wsm_add_key(hw_priv, &hw_priv->keys[idx], priv->if_id);
if (ret < 0)
break;
}
return ret;
}
#if defined(CONFIG_XRADIO_USE_EXTENSIONS)
/* Workaround for WFD test case 6.1.10 */
void xradio_link_id_reset(struct work_struct *work)
{
struct xradio_vif *priv =
container_of(work, struct xradio_vif, linkid_reset_work);
struct xradio_common *hw_priv = priv->hw_priv;
int temp_linkid;
txrx_printk(XRADIO_DBG_TRC, "%s\n", __func__);
if (!priv->action_linkid) {
/* In GO mode we can receive ACTION frames without a linkID */
temp_linkid = xradio_alloc_link_id(priv,
&priv->action_frame_sa[0]);
SYS_WARN(!temp_linkid);
if (temp_linkid) {
/* Make sure we execute the WQ */
flush_workqueue(hw_priv->workqueue);
/* Release the link ID */
spin_lock_bh(&priv->ps_state_lock);
priv->link_id_db[temp_linkid - 1].prev_status =
priv->link_id_db[temp_linkid - 1].status;
priv->link_id_db[temp_linkid - 1].status =
XRADIO_LINK_RESET;
spin_unlock_bh(&priv->ps_state_lock);
wsm_lock_tx_async(hw_priv);
if (queue_work(hw_priv->workqueue,
&priv->link_id_work) <= 0)
wsm_unlock_tx(hw_priv);
}
} else {
spin_lock_bh(&priv->ps_state_lock);
priv->link_id_db[priv->action_linkid - 1].prev_status =
priv->link_id_db[priv->action_linkid - 1].status;
priv->link_id_db[priv->action_linkid - 1].status =
XRADIO_LINK_RESET_REMAP;
spin_unlock_bh(&priv->ps_state_lock);
wsm_lock_tx_async(hw_priv);
if (queue_work(hw_priv->workqueue, &priv->link_id_work) <= 0)
wsm_unlock_tx(hw_priv);
flush_workqueue(hw_priv->workqueue);
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink