Github/rtl8192eu-linux-driver
1
0
Fork 0
mirror of https://github.com/Mange/rtl8192eu-linux-driver synced 2024-11-01 03:05:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
34ec238387
rtl8192eu-linux-driver/core/mesh/rtw_mesh_hwmp.c
Carlos Garces 1d807f14d8 Add version v5.6.4
2019-11-13 22:12:20 +01:00

1666 lines
48 KiB
C
Raw Blame History

/******************************************************************************
*
* Copyright(c) 2007 - 2017 Realtek Corporation.
*
* 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 _RTW_HWMP_C_
#ifdef CONFIG_RTW_MESH
#include <drv_types.h>
#include <hal_data.h>
#define RTW_TEST_FRAME_LEN 8192
#define RTW_MAX_METRIC 0xffffffff
#define RTW_ARITH_SHIFT 8
#define RTW_LINK_FAIL_THRESH 95
#define RTW_MAX_PREQ_QUEUE_LEN 64
#define RTW_ATLM_REQ_CYCLE 1000
#define rtw_ilog2(n) \
( \
(n) < 2 ? 0 : \
(n) & (1ULL << 63) ? 63 : \
(n) & (1ULL << 62) ? 62 : \
(n) & (1ULL << 61) ? 61 : \
(n) & (1ULL << 60) ? 60 : \
(n) & (1ULL << 59) ? 59 : \
(n) & (1ULL << 58) ? 58 : \
(n) & (1ULL << 57) ? 57 : \
(n) & (1ULL << 56) ? 56 : \
(n) & (1ULL << 55) ? 55 : \
(n) & (1ULL << 54) ? 54 : \
(n) & (1ULL << 53) ? 53 : \
(n) & (1ULL << 52) ? 52 : \
(n) & (1ULL << 51) ? 51 : \
(n) & (1ULL << 50) ? 50 : \
(n) & (1ULL << 49) ? 49 : \
(n) & (1ULL << 48) ? 48 : \
(n) & (1ULL << 47) ? 47 : \
(n) & (1ULL << 46) ? 46 : \
(n) & (1ULL << 45) ? 45 : \
(n) & (1ULL << 44) ? 44 : \
(n) & (1ULL << 43) ? 43 : \
(n) & (1ULL << 42) ? 42 : \
(n) & (1ULL << 41) ? 41 : \
(n) & (1ULL << 40) ? 40 : \
(n) & (1ULL << 39) ? 39 : \
(n) & (1ULL << 38) ? 38 : \
(n) & (1ULL << 37) ? 37 : \
(n) & (1ULL << 36) ? 36 : \
(n) & (1ULL << 35) ? 35 : \
(n) & (1ULL << 34) ? 34 : \
(n) & (1ULL << 33) ? 33 : \
(n) & (1ULL << 32) ? 32 : \
(n) & (1ULL << 31) ? 31 : \
(n) & (1ULL << 30) ? 30 : \
(n) & (1ULL << 29) ? 29 : \
(n) & (1ULL << 28) ? 28 : \
(n) & (1ULL << 27) ? 27 : \
(n) & (1ULL << 26) ? 26 : \
(n) & (1ULL << 25) ? 25 : \
(n) & (1ULL << 24) ? 24 : \
(n) & (1ULL << 23) ? 23 : \
(n) & (1ULL << 22) ? 22 : \
(n) & (1ULL << 21) ? 21 : \
(n) & (1ULL << 20) ? 20 : \
(n) & (1ULL << 19) ? 19 : \
(n) & (1ULL << 18) ? 18 : \
(n) & (1ULL << 17) ? 17 : \
(n) & (1ULL << 16) ? 16 : \
(n) & (1ULL << 15) ? 15 : \
(n) & (1ULL << 14) ? 14 : \
(n) & (1ULL << 13) ? 13 : \
(n) & (1ULL << 12) ? 12 : \
(n) & (1ULL << 11) ? 11 : \
(n) & (1ULL << 10) ? 10 : \
(n) & (1ULL << 9) ? 9 : \
(n) & (1ULL << 8) ? 8 : \
(n) & (1ULL << 7) ? 7 : \
(n) & (1ULL << 6) ? 6 : \
(n) & (1ULL << 5) ? 5 : \
(n) & (1ULL << 4) ? 4 : \
(n) & (1ULL << 3) ? 3 : \
(n) & (1ULL << 2) ? 2 : \
1 \
)
enum rtw_mpath_frame_type {
RTW_MPATH_PREQ = 0,
RTW_MPATH_PREP,
RTW_MPATH_PERR,
RTW_MPATH_RANN
};
static inline u32 rtw_u32_field_get(const u8 *preq_elem, int shift, BOOLEAN ae)
{
if (ae)
shift += 6;
return LE_BITS_TO_4BYTE(preq_elem + shift, 0, 32);
}
static inline u16 rtw_u16_field_get(const u8 *preq_elem, int shift, BOOLEAN ae)
{
if (ae)
shift += 6;
return LE_BITS_TO_2BYTE(preq_elem + shift, 0, 16);
}
/* HWMP IE processing macros */
#define RTW_AE_F (1<<6)
#define RTW_AE_F_SET(x) (*x & RTW_AE_F)
#define RTW_PREQ_IE_FLAGS(x) (*(x))
#define RTW_PREQ_IE_HOPCOUNT(x) (*(x + 1))
#define RTW_PREQ_IE_TTL(x) (*(x + 2))
#define RTW_PREQ_IE_PREQ_ID(x) rtw_u32_field_get(x, 3, 0)
#define RTW_PREQ_IE_ORIG_ADDR(x) (x + 7)
#define RTW_PREQ_IE_ORIG_SN(x) rtw_u32_field_get(x, 13, 0)
#define RTW_PREQ_IE_LIFETIME(x) rtw_u32_field_get(x, 17, RTW_AE_F_SET(x))
#define RTW_PREQ_IE_METRIC(x) rtw_u32_field_get(x, 21, RTW_AE_F_SET(x))
#define RTW_PREQ_IE_TARGET_F(x) (*(RTW_AE_F_SET(x) ? x + 32 : x + 26))
#define RTW_PREQ_IE_TARGET_ADDR(x) (RTW_AE_F_SET(x) ? x + 33 : x + 27)
#define RTW_PREQ_IE_TARGET_SN(x) rtw_u32_field_get(x, 33, RTW_AE_F_SET(x))
#define RTW_PREP_IE_FLAGS(x) RTW_PREQ_IE_FLAGS(x)
#define RTW_PREP_IE_HOPCOUNT(x) RTW_PREQ_IE_HOPCOUNT(x)
#define RTW_PREP_IE_TTL(x) RTW_PREQ_IE_TTL(x)
#define RTW_PREP_IE_ORIG_ADDR(x) (RTW_AE_F_SET(x) ? x + 27 : x + 21)
#define RTW_PREP_IE_ORIG_SN(x) rtw_u32_field_get(x, 27, RTW_AE_F_SET(x))
#define RTW_PREP_IE_LIFETIME(x) rtw_u32_field_get(x, 13, RTW_AE_F_SET(x))
#define RTW_PREP_IE_METRIC(x) rtw_u32_field_get(x, 17, RTW_AE_F_SET(x))
#define RTW_PREP_IE_TARGET_ADDR(x) (x + 3)
#define RTW_PREP_IE_TARGET_SN(x) rtw_u32_field_get(x, 9, 0)
#define RTW_PERR_IE_TTL(x) (*(x))
#define RTW_PERR_IE_TARGET_FLAGS(x) (*(x + 2))
#define RTW_PERR_IE_TARGET_ADDR(x) (x + 3)
#define RTW_PERR_IE_TARGET_SN(x) rtw_u32_field_get(x, 9, 0)
#define RTW_PERR_IE_TARGET_RCODE(x) rtw_u16_field_get(x, 13, 0)
#define RTW_TU_TO_SYSTIME(x) (rtw_us_to_systime((x) * 1024))
#define RTW_TU_TO_EXP_TIME(x) (rtw_get_current_time() + RTW_TU_TO_SYSTIME(x))
#define RTW_MSEC_TO_TU(x) (x*1000/1024)
#define RTW_SN_GT(x, y) ((s32)(y - x) < 0)
#define RTW_SN_LT(x, y) ((s32)(x - y) < 0)
#define RTW_MAX_SANE_SN_DELTA 32
static inline u32 RTW_SN_DELTA(u32 x, u32 y)
{
return x >= y ? x - y : y - x;
}
#define rtw_net_traversal_jiffies(adapter) \
rtw_ms_to_systime(adapter->mesh_cfg.dot11MeshHWMPnetDiameterTraversalTime)
#define rtw_default_lifetime(adapter) \
RTW_MSEC_TO_TU(adapter->mesh_cfg.dot11MeshHWMPactivePathTimeout)
#define rtw_min_preq_int_jiff(adapter) \
(rtw_ms_to_systime(adapter->mesh_cfg.dot11MeshHWMPpreqMinInterval))
#define rtw_max_preq_retries(adapter) (adapter->mesh_cfg.dot11MeshHWMPmaxPREQretries)
#define rtw_disc_timeout_jiff(adapter) \
rtw_ms_to_systime(adapter->mesh_cfg.min_discovery_timeout)
#define rtw_root_path_confirmation_jiffies(adapter) \
rtw_ms_to_systime(adapter->mesh_cfg.dot11MeshHWMPconfirmationInterval)
static inline BOOLEAN rtw_ether_addr_equal(const u8 *addr1, const u8 *addr2)
{
return _rtw_memcmp(addr1, addr2, ETH_ALEN);
}
#ifdef PLATFORM_LINUX
#define rtw_print_ratelimit() printk_ratelimit()
#define rtw_mod_timer(ptimer, expires) mod_timer(&(ptimer)->timer, expires)
#else
#endif
#define RTW_MESH_EWMA_PRECISION 20
#define RTW_MESH_EWMA_WEIGHT_RCP 8
#define RTW_TOTAL_PKT_MIN_THRESHOLD 1
inline void rtw_ewma_err_rate_init(struct rtw_ewma_err_rate *e)
{
e->internal = 0;
}
inline unsigned long rtw_ewma_err_rate_read(struct rtw_ewma_err_rate *e)
{
return e->internal >> (RTW_MESH_EWMA_PRECISION);
}
inline void rtw_ewma_err_rate_add(struct rtw_ewma_err_rate *e,
unsigned long val)
{
unsigned long internal = e->internal;
unsigned long weight_rcp = rtw_ilog2(RTW_MESH_EWMA_WEIGHT_RCP);
unsigned long precision = RTW_MESH_EWMA_PRECISION;
(e->internal) = internal ? (((internal << weight_rcp) - internal) +
(val << precision)) >> weight_rcp :
(val << precision);
}
static const u8 bcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
static int rtw_mesh_path_sel_frame_tx(enum rtw_mpath_frame_type mpath_action, u8 flags,
const u8 *originator_addr, u32 originator_sn,
u8 target_flags, const u8 *target,
u32 target_sn, const u8 *da, u8 hopcount, u8 ttl,
u32 lifetime, u32 metric, u32 preq_id,
_adapter *adapter)
{
struct xmit_priv *pxmitpriv = &(adapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct xmit_frame *pmgntframe = NULL;
struct rtw_ieee80211_hdr *pwlanhdr = NULL;
struct pkt_attrib *pattrib = NULL;
u8 category = RTW_WLAN_CATEGORY_MESH;
u8 action = RTW_ACT_MESH_HWMP_PATH_SELECTION;
u16 *fctrl = NULL;
u8 *pos, ie_len;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return -1;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pos = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pos;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pos, WIFI_ACTION);
pos += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pos = rtw_set_fixed_ie(pos, 1, &(category), &(pattrib->pktlen));
pos = rtw_set_fixed_ie(pos, 1, &(action), &(pattrib->pktlen));
switch (mpath_action) {
case RTW_MPATH_PREQ:
RTW_HWMP_DBG("sending PREQ to "MAC_FMT"\n", MAC_ARG(target));
ie_len = 37;
pattrib->pktlen += (ie_len + 2);
*pos++ = WLAN_EID_PREQ;
break;
case RTW_MPATH_PREP:
RTW_HWMP_DBG("sending PREP to "MAC_FMT"\n", MAC_ARG(originator_addr));
ie_len = 31;
pattrib->pktlen += (ie_len + 2);
*pos++ = WLAN_EID_PREP;
break;
case RTW_MPATH_RANN:
RTW_HWMP_DBG("sending RANN from "MAC_FMT"\n", MAC_ARG(originator_addr));
ie_len = sizeof(struct rtw_ieee80211_rann_ie);
pattrib->pktlen += (ie_len + 2);
*pos++ = WLAN_EID_RANN;
break;
default:
rtw_free_xmitbuf(pxmitpriv, pmgntframe->pxmitbuf);
rtw_free_xmitframe(pxmitpriv, pmgntframe);
return _FAIL;
}
*pos++ = ie_len;
*pos++ = flags;
*pos++ = hopcount;
*pos++ = ttl;
if (mpath_action == RTW_MPATH_PREP) {
_rtw_memcpy(pos, target, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(target_sn);
pos += 4;
} else {
if (mpath_action == RTW_MPATH_PREQ) {
*(u32 *)pos = cpu_to_le32(preq_id);
pos += 4;
}
_rtw_memcpy(pos, originator_addr, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(originator_sn);
pos += 4;
}
*(u32 *)pos = cpu_to_le32(lifetime);
pos += 4;
*(u32 *)pos = cpu_to_le32(metric);
pos += 4;
if (mpath_action == RTW_MPATH_PREQ) {
*pos++ = 1; /* support only 1 destination now */
*pos++ = target_flags;
_rtw_memcpy(pos, target, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(target_sn);
pos += 4;
} else if (mpath_action == RTW_MPATH_PREP) {
_rtw_memcpy(pos, originator_addr, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(originator_sn);
pos += 4;
}
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(adapter, pmgntframe);
return 0;
}
int rtw_mesh_path_error_tx(_adapter *adapter,
u8 ttl, const u8 *target, u32 target_sn,
u16 perr_reason_code, const u8 *ra)
{
struct xmit_priv *pxmitpriv = &(adapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
struct xmit_frame *pmgntframe = NULL;
struct rtw_ieee80211_hdr *pwlanhdr = NULL;
struct pkt_attrib *pattrib = NULL;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
u8 category = RTW_WLAN_CATEGORY_MESH;
u8 action = RTW_ACT_MESH_HWMP_PATH_SELECTION;
u8 *pos, ie_len;
u16 *fctrl = NULL;
if (rtw_time_before(rtw_get_current_time(), minfo->next_perr))
return -1;
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (pmgntframe == NULL)
return -1;
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(adapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pos = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pos;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, ra, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(adapter), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(adapter), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
set_frame_sub_type(pos, WIFI_ACTION);
pos += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pos = rtw_set_fixed_ie(pos, 1, &(category), &(pattrib->pktlen));
pos = rtw_set_fixed_ie(pos, 1, &(action), &(pattrib->pktlen));
ie_len = 15;
pattrib->pktlen += (2 + ie_len);
*pos++ = WLAN_EID_PERR;
*pos++ = ie_len;
/* ttl */
*pos++ = ttl;
/* The Number of Destinations N */
*pos++ = 1;
/* Flags format | B7 | B6 | B5:B0 | = | rsvd | AE | rsvd | */
*pos = 0;
pos++;
_rtw_memcpy(pos, target, ETH_ALEN);
pos += ETH_ALEN;
*(u32 *)pos = cpu_to_le32(target_sn);
pos += 4;
*(u16 *)pos = cpu_to_le16(perr_reason_code);
adapter->mesh_info.next_perr = RTW_TU_TO_EXP_TIME(
adapter->mesh_cfg.dot11MeshHWMPperrMinInterval);
pattrib->last_txcmdsz = pattrib->pktlen;
/* Send directly. Rewrite it if deferred tx is needed */
dump_mgntframe(adapter, pmgntframe);
RTW_HWMP_DBG("TX PERR toward "MAC_FMT", ra = "MAC_FMT"\n", MAC_ARG(target), MAC_ARG(ra));
return 0;
}
static u32 rtw_get_vht_bitrate(u8 mcs, u8 bw, u8 nss, u8 sgi)
{
static const u32 base[4][10] = {
{ 6500000,
13000000,
19500000,
26000000,
39000000,
52000000,
58500000,
65000000,
78000000,
/* not in the spec, but some devices use this: */
86500000,
},
{ 13500000,
27000000,
40500000,
54000000,
81000000,
108000000,
121500000,
135000000,
162000000,
180000000,
},
{ 29300000,
58500000,
87800000,
117000000,
175500000,
234000000,
263300000,
292500000,
351000000,
390000000,
},
{ 58500000,
117000000,
175500000,
234000000,
351000000,
468000000,
526500000,
585000000,
702000000,
780000000,
},
};
u32 bitrate;
int bw_idx;
if (mcs > 9) {
RTW_HWMP_INFO("Invalid mcs = %d\n", mcs);
return 0;
}
if (nss > 4 || nss < 1) {
RTW_HWMP_INFO("Now only support nss = 1, 2, 3, 4\n");
}
switch (bw) {
case CHANNEL_WIDTH_160:
bw_idx = 3;
break;
case CHANNEL_WIDTH_80:
bw_idx = 2;
break;
case CHANNEL_WIDTH_40:
bw_idx = 1;
break;
case CHANNEL_WIDTH_20:
bw_idx = 0;
break;
default:
RTW_HWMP_INFO("bw = %d currently not supported\n", bw);
return 0;
}
bitrate = base[bw_idx][mcs];
bitrate *= nss;
if (sgi)
bitrate = (bitrate / 9) * 10;
/* do NOT round down here */
return (bitrate + 50000) / 100000;
}
static u32 rtw_get_ht_bitrate(u8 mcs, u8 bw, u8 sgi)
{
int modulation, streams, bitrate;
/* the formula below does only work for MCS values smaller than 32 */
if (mcs >= 32) {
RTW_HWMP_INFO("Invalid mcs = %d\n", mcs);
return 0;
}
if (bw > 1) {
RTW_HWMP_INFO("Now HT only support bw = 0(20Mhz), 1(40Mhz)\n");
return 0;
}
modulation = mcs & 7;
streams = (mcs >> 3) + 1;
bitrate = (bw == 1) ? 13500000 : 6500000;
if (modulation < 4)
bitrate *= (modulation + 1);
else if (modulation == 4)
bitrate *= (modulation + 2);
else
bitrate *= (modulation + 3);
bitrate *= streams;
if (sgi)
bitrate = (bitrate / 9) * 10;
/* do NOT round down here */
return (bitrate + 50000) / 100000;
}
/**
* @bw: 0(20Mhz), 1(40Mhz), 2(80Mhz), 3(160Mhz)
* @rate_idx: DESC_RATEXXXX & 0x7f
* @sgi: DESC_RATEXXXX >> 7
* Returns: bitrate in 100kbps
*/
static u32 rtw_desc_rate_to_bitrate(u8 bw, u8 rate_idx, u8 sgi)
{
u32 bitrate;
if (rate_idx <= DESC_RATE54M){
u16 ofdm_rate[12] = {10, 20, 55, 110,
60, 90, 120, 180, 240, 360, 480, 540};
bitrate = ofdm_rate[rate_idx];
} else if ((DESC_RATEMCS0 <= rate_idx) &&
(rate_idx <= DESC_RATEMCS31)) {
u8 mcs = rate_idx - DESC_RATEMCS0;
bitrate = rtw_get_ht_bitrate(mcs, bw, sgi);
} else if ((DESC_RATEVHTSS1MCS0 <= rate_idx) &&
(rate_idx <= DESC_RATEVHTSS4MCS9)) {
u8 mcs = (rate_idx - DESC_RATEVHTSS1MCS0) % 10;
u8 nss = ((rate_idx - DESC_RATEVHTSS1MCS0) / 10) + 1;
bitrate = rtw_get_vht_bitrate(mcs, bw, nss, sgi);
} else {
/* 60Ghz ??? */
bitrate = 1;
}
return bitrate;
}
static u32 rtw_airtime_link_metric_get(_adapter *adapter, struct sta_info *sta)
{
struct dm_struct *dm = adapter_to_phydm(adapter);
int device_constant = phydm_get_plcp(dm, sta->cmn.mac_id) << RTW_ARITH_SHIFT;
u32 test_frame_len = RTW_TEST_FRAME_LEN << RTW_ARITH_SHIFT;
u32 s_unit = 1 << RTW_ARITH_SHIFT;
u32 err;
u16 rate;
u32 tx_time, estimated_retx;
u64 result;
/* The fail_avg should <= 100 here */
u32 fail_avg = (u32)rtw_ewma_err_rate_read(&sta->metrics.err_rate);
if (fail_avg > RTW_LINK_FAIL_THRESH)
return RTW_MAX_METRIC;
rate = sta->metrics.data_rate;
/* rate unit is 100Kbps, min rate = 10 */
if (rate < 10) {
RTW_HWMP_INFO("rate = %d\n", rate);
return RTW_MAX_METRIC;
}
err = (fail_avg << RTW_ARITH_SHIFT) / 100;
/* test_frame_len*10 to adjust the unit of rate(100kbps/unit) */
tx_time = (device_constant + 10 * test_frame_len / rate);
estimated_retx = ((1 << (2 * RTW_ARITH_SHIFT)) / (s_unit - err));
result = (tx_time * estimated_retx) >> (2 * RTW_ARITH_SHIFT);
/* Convert us to 0.01 TU(10.24us). x/10.24 = x*100/1024 */
result = (result * 100) >> 10;
return (u32)result;
}
void rtw_ieee80211s_update_metric(_adapter *adapter, u8 mac_id,
u8 per, u8 rate,
u8 bw, u8 total_pkt)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
struct sta_info *sta;
u8 rate_idx;
u8 sgi;
sta = macid_ctl->sta[mac_id];
if (!sta)
return;
/* if RA, use reported rate */
if (adapter->fix_rate == 0xff) {
rate_idx = rate & 0x7f;
sgi = rate >> 7;
} else {
rate_idx = adapter->fix_rate & 0x7f;
sgi = adapter->fix_rate >> 7;
}
sta->metrics.data_rate = rtw_desc_rate_to_bitrate(bw, rate_idx, sgi);
if (total_pkt < RTW_TOTAL_PKT_MIN_THRESHOLD)
return;
/* TBD: sta->metrics.overhead = phydm_get_plcp(void *dm_void, u16 macid); */
sta->metrics.total_pkt = total_pkt;
rtw_ewma_err_rate_add(&sta->metrics.err_rate, per);
if (rtw_ewma_err_rate_read(&sta->metrics.err_rate) >
RTW_LINK_FAIL_THRESH)
rtw_mesh_plink_broken(sta);
}
static void rtw_hwmp_preq_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *preq_elem, u32 originator_metric)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_path *path = NULL;
const u8 *target_addr, *originator_addr;
const u8 *da;
u8 target_flags, ttl, flags, to_gate_ask = 0;
u32 originator_sn, target_sn, lifetime, target_metric = 0;
BOOLEAN reply = _FALSE;
BOOLEAN forward = _TRUE;
BOOLEAN preq_is_gate;
/* Update target SN, if present */
target_addr = RTW_PREQ_IE_TARGET_ADDR(preq_elem);
originator_addr = RTW_PREQ_IE_ORIG_ADDR(preq_elem);
target_sn = RTW_PREQ_IE_TARGET_SN(preq_elem);
originator_sn = RTW_PREQ_IE_ORIG_SN(preq_elem);
target_flags = RTW_PREQ_IE_TARGET_F(preq_elem);
/* PREQ gate announcements */
flags = RTW_PREQ_IE_FLAGS(preq_elem);
preq_is_gate = !!(flags & RTW_IEEE80211_PREQ_IS_GATE_FLAG);
RTW_HWMP_DBG("received PREQ from "MAC_FMT"\n", MAC_ARG(originator_addr));
if (rtw_ether_addr_equal(target_addr, adapter_mac_addr(adapter))) {
RTW_HWMP_DBG("PREQ is for us\n");
#ifdef CONFIG_RTW_MESH_ON_DMD_GANN
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
if (preq_is_gate)
rtw_mesh_path_add_gate(path);
else if (path->is_gate) {
enter_critical_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
exit_critical_bh(&path->state_lock);
}
}
path = NULL;
rtw_rcu_read_unlock();
#endif
forward = _FALSE;
reply = _TRUE;
to_gate_ask = 1;
target_metric = 0;
if (rtw_time_after(rtw_get_current_time(), minfo->last_sn_update +
rtw_net_traversal_jiffies(adapter)) ||
rtw_time_before(rtw_get_current_time(), minfo->last_sn_update)) {
++minfo->sn;
minfo->last_sn_update = rtw_get_current_time();
}
target_sn = minfo->sn;
} else if (is_broadcast_mac_addr(target_addr) &&
(target_flags & RTW_IEEE80211_PREQ_TO_FLAG)) {
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
if (flags & RTW_IEEE80211_PREQ_PROACTIVE_PREP_FLAG) {
reply = _TRUE;
target_addr = adapter_mac_addr(adapter);
target_sn = ++minfo->sn;
target_metric = 0;
minfo->last_sn_update = rtw_get_current_time();
}
if (preq_is_gate) {
lifetime = RTW_PREQ_IE_LIFETIME(preq_elem);
path->gate_ann_int = lifetime;
path->gate_asked = false;
rtw_mesh_path_add_gate(path);
} else if (path->is_gate) {
enter_critical_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
exit_critical_bh(&path->state_lock);
}
}
rtw_rcu_read_unlock();
} else {
rtw_rcu_read_lock();
#ifdef CONFIG_RTW_MESH_ON_DMD_GANN
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
if (preq_is_gate)
rtw_mesh_path_add_gate(path);
else if (path->is_gate) {
enter_critical_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
exit_critical_bh(&path->state_lock);
}
}
path = NULL;
#endif
path = rtw_mesh_path_lookup(adapter, target_addr);
if (path) {
if ((!(path->flags & RTW_MESH_PATH_SN_VALID)) ||
RTW_SN_LT(path->sn, target_sn)) {
path->sn = target_sn;
path->flags |= RTW_MESH_PATH_SN_VALID;
} else if ((!(target_flags & RTW_IEEE80211_PREQ_TO_FLAG)) &&
(path->flags & RTW_MESH_PATH_ACTIVE)) {
reply = _TRUE;
target_metric = path->metric;
target_sn = path->sn;
/* Case E2 of sec 13.10.9.3 IEEE 802.11-2012*/
target_flags |= RTW_IEEE80211_PREQ_TO_FLAG;
}
}
rtw_rcu_read_unlock();
}
if (reply) {
lifetime = RTW_PREQ_IE_LIFETIME(preq_elem);
ttl = mshcfg->element_ttl;
if (ttl != 0 && !to_gate_ask) {
RTW_HWMP_DBG("replying to the PREQ\n");
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREP, 0, originator_addr,
originator_sn, 0, target_addr,
target_sn, mgmt->addr2, 0, ttl,
lifetime, target_metric, 0,
adapter);
} else if (ttl != 0 && to_gate_ask) {
RTW_HWMP_DBG("replying to the PREQ (PREQ for us)\n");
if (mshcfg->dot11MeshGateAnnouncementProtocol) {
/* BIT 7 is used to identify the prep is from mesh gate */
to_gate_ask = RTW_IEEE80211_PREQ_IS_GATE_FLAG | BIT(7);
} else {
to_gate_ask = 0;
}
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREP, to_gate_ask, originator_addr,
originator_sn, 0, target_addr,
target_sn, mgmt->addr2, 0, ttl,
lifetime, target_metric, 0,
adapter);
} else {
minfo->mshstats.dropped_frames_ttl++;
}
}
if (forward && mshcfg->dot11MeshForwarding) {
u32 preq_id;
u8 hopcount;
ttl = RTW_PREQ_IE_TTL(preq_elem);
lifetime = RTW_PREQ_IE_LIFETIME(preq_elem);
if (ttl <= 1) {
minfo->mshstats.dropped_frames_ttl++;
return;
}
RTW_HWMP_DBG("forwarding the PREQ from "MAC_FMT"\n", MAC_ARG(originator_addr));
--ttl;
preq_id = RTW_PREQ_IE_PREQ_ID(preq_elem);
hopcount = RTW_PREQ_IE_HOPCOUNT(preq_elem) + 1;
da = (path && path->is_root) ?
path->rann_snd_addr : bcast_addr;
if (flags & RTW_IEEE80211_PREQ_PROACTIVE_PREP_FLAG) {
target_addr = RTW_PREQ_IE_TARGET_ADDR(preq_elem);
target_sn = RTW_PREQ_IE_TARGET_SN(preq_elem);
}
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREQ, flags, originator_addr,
originator_sn, target_flags, target_addr,
target_sn, da, hopcount, ttl, lifetime,
originator_metric, preq_id, adapter);
if (!is_multicast_mac_addr(da))
minfo->mshstats.fwded_unicast++;
else
minfo->mshstats.fwded_mcast++;
minfo->mshstats.fwded_frames++;
}
}
static inline struct sta_info *
rtw_next_hop_deref_protected(struct rtw_mesh_path *path)
{
return rtw_rcu_dereference_protected(path->next_hop,
rtw_lockdep_is_held(&path->state_lock));
}
static void rtw_hwmp_prep_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *prep_elem, u32 metric)
{
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_stats *mshstats = &adapter->mesh_info.mshstats;
struct rtw_mesh_path *path;
const u8 *target_addr, *originator_addr;
u8 ttl, hopcount, flags;
u8 next_hop[ETH_ALEN];
u32 target_sn, originator_sn, lifetime;
RTW_HWMP_DBG("received PREP from "MAC_FMT"\n",
MAC_ARG(RTW_PREP_IE_TARGET_ADDR(prep_elem)));
originator_addr = RTW_PREP_IE_ORIG_ADDR(prep_elem);
if (rtw_ether_addr_equal(originator_addr, adapter_mac_addr(adapter))) {
/* destination, no forwarding required */
rtw_rcu_read_lock();
target_addr = RTW_PREP_IE_TARGET_ADDR(prep_elem);
path = rtw_mesh_path_lookup(adapter, target_addr);
if (path && path->gate_asked) {
flags = RTW_PREP_IE_FLAGS(prep_elem);
if (flags & BIT(7)) {
enter_critical_bh(&path->state_lock);
path->gate_asked = false;
exit_critical_bh(&path->state_lock);
if (!(flags & RTW_IEEE80211_PREQ_IS_GATE_FLAG)) {
enter_critical_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
exit_critical_bh(&path->state_lock);
}
}
}
rtw_rcu_read_unlock();
return;
}
if (!mshcfg->dot11MeshForwarding)
return;
ttl = RTW_PREP_IE_TTL(prep_elem);
if (ttl <= 1) {
mshstats->dropped_frames_ttl++;
return;
}
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path)
enter_critical_bh(&path->state_lock);
else
goto fail;
if (!(path->flags & RTW_MESH_PATH_ACTIVE)) {
exit_critical_bh(&path->state_lock);
goto fail;
}
_rtw_memcpy(next_hop, rtw_next_hop_deref_protected(path)->cmn.mac_addr, ETH_ALEN);
exit_critical_bh(&path->state_lock);
--ttl;
flags = RTW_PREP_IE_FLAGS(prep_elem);
lifetime = RTW_PREP_IE_LIFETIME(prep_elem);
hopcount = RTW_PREP_IE_HOPCOUNT(prep_elem) + 1;
target_addr = RTW_PREP_IE_TARGET_ADDR(prep_elem);
target_sn = RTW_PREP_IE_TARGET_SN(prep_elem);
originator_sn = RTW_PREP_IE_ORIG_SN(prep_elem);
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREP, flags, originator_addr, originator_sn, 0,
target_addr, target_sn, next_hop, hopcount,
ttl, lifetime, metric, 0, adapter);
rtw_rcu_read_unlock();
mshstats->fwded_unicast++;
mshstats->fwded_frames++;
return;
fail:
rtw_rcu_read_unlock();
mshstats->dropped_frames_no_route++;
}
static void rtw_hwmp_perr_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *perr_elem)
{
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_stats *mshstats = &adapter->mesh_info.mshstats;
struct rtw_mesh_path *path;
u8 ttl;
const u8 *ta, *target_addr;
u32 target_sn;
u16 perr_reason_code;
ta = mgmt->addr2;
ttl = RTW_PERR_IE_TTL(perr_elem);
if (ttl <= 1) {
mshstats->dropped_frames_ttl++;
return;
}
ttl--;
target_addr = RTW_PERR_IE_TARGET_ADDR(perr_elem);
target_sn = RTW_PERR_IE_TARGET_SN(perr_elem);
perr_reason_code = RTW_PERR_IE_TARGET_RCODE(perr_elem);
RTW_HWMP_DBG("received PERR toward target "MAC_FMT"\n", MAC_ARG(target_addr));
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, target_addr);
if (path) {
struct sta_info *sta;
enter_critical_bh(&path->state_lock);
sta = rtw_next_hop_deref_protected(path);
if (path->flags & RTW_MESH_PATH_ACTIVE &&
rtw_ether_addr_equal(ta, sta->cmn.mac_addr) &&
!(path->flags & RTW_MESH_PATH_FIXED) &&
(!(path->flags & RTW_MESH_PATH_SN_VALID) ||
RTW_SN_GT(target_sn, path->sn) || target_sn == 0)) {
path->flags &= ~RTW_MESH_PATH_ACTIVE;
if (target_sn != 0)
path->sn = target_sn;
else
path->sn += 1;
exit_critical_bh(&path->state_lock);
if (!mshcfg->dot11MeshForwarding)
goto endperr;
rtw_mesh_path_error_tx(adapter, ttl, target_addr,
target_sn, perr_reason_code,
bcast_addr);
} else
exit_critical_bh(&path->state_lock);
}
endperr:
rtw_rcu_read_unlock();
}
static void rtw_hwmp_rann_frame_process(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const struct rtw_ieee80211_rann_ie *rann)
{
struct sta_info *sta;
struct sta_priv *pstapriv = &adapter->stapriv;
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_stats *mshstats = &adapter->mesh_info.mshstats;
struct rtw_mesh_path *path;
u8 ttl, flags, hopcount;
const u8 *originator_addr;
u32 originator_sn, metric, metric_txsta, interval;
BOOLEAN root_is_gate;
ttl = rann->rann_ttl;
flags = rann->rann_flags;
root_is_gate = !!(flags & RTW_RANN_FLAG_IS_GATE);
originator_addr = rann->rann_addr;
originator_sn = le32_to_cpu(rann->rann_seq);
interval = le32_to_cpu(rann->rann_interval);
hopcount = rann->rann_hopcount;
hopcount++;
metric = le32_to_cpu(rann->rann_metric);
/* Ignore our own RANNs */
if (rtw_ether_addr_equal(originator_addr, adapter_mac_addr(adapter)))
return;
RTW_HWMP_DBG("received RANN from "MAC_FMT" via neighbour "MAC_FMT" (is_gate=%d)\n",
MAC_ARG(originator_addr), MAC_ARG(mgmt->addr2), root_is_gate);
rtw_rcu_read_lock();
sta = rtw_get_stainfo(pstapriv, mgmt->addr2);
if (!sta) {
rtw_rcu_read_unlock();
return;
}
metric_txsta = rtw_airtime_link_metric_get(adapter, sta);
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (!path) {
path = rtw_mesh_path_add(adapter, originator_addr);
if (IS_ERR(path)) {
rtw_rcu_read_unlock();
mshstats->dropped_frames_no_route++;
return;
}
}
if (!(RTW_SN_LT(path->sn, originator_sn)) &&
!(path->sn == originator_sn && metric < path->rann_metric)) {
rtw_rcu_read_unlock();
return;
}
if ((!(path->flags & (RTW_MESH_PATH_ACTIVE | RTW_MESH_PATH_RESOLVING)) ||
(rtw_time_after(rtw_get_current_time(), path->last_preq_to_root +
rtw_root_path_confirmation_jiffies(adapter)) ||
rtw_time_before(rtw_get_current_time(), path->last_preq_to_root))) &&
!(path->flags & RTW_MESH_PATH_FIXED) && (ttl != 0)) {
u8 preq_node_flag = RTW_PREQ_Q_F_START | RTW_PREQ_Q_F_REFRESH;
RTW_HWMP_DBG("time to refresh root path "MAC_FMT"\n",
MAC_ARG(originator_addr));
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (RTW_SN_LT(path->sn, originator_sn) &&
(path->rann_metric + mshcfg->sane_metric_delta < metric) &&
_rtw_memcmp(bcast_addr, path->rann_snd_addr, ETH_ALEN) == _FALSE) {
RTW_HWMP_DBG("Trigger additional check for root "
"confirm PREQ. rann_snd_addr = "MAC_FMT
"add_chk_rann_snd_addr= "MAC_FMT"\n",
MAC_ARG(mgmt->addr2),
MAC_ARG(path->rann_snd_addr));
_rtw_memcpy(path->add_chk_rann_snd_addr,
path->rann_snd_addr, ETH_ALEN);
preq_node_flag |= RTW_PREQ_Q_F_CHK;
}
#endif
rtw_mesh_queue_preq(path, preq_node_flag);
path->last_preq_to_root = rtw_get_current_time();
}
path->sn = originator_sn;
path->rann_metric = metric + metric_txsta;
path->is_root = _TRUE;
/* Recording RANNs sender address to send individually
* addressed PREQs destined for root mesh STA */
_rtw_memcpy(path->rann_snd_addr, mgmt->addr2, ETH_ALEN);
if (root_is_gate) {
path->gate_ann_int = interval;
path->gate_asked = false;
rtw_mesh_path_add_gate(path);
} else if (path->is_gate) {
enter_critical_bh(&path->state_lock);
rtw_mesh_gate_del(adapter->mesh_info.mesh_paths, path);
exit_critical_bh(&path->state_lock);
}
if (ttl <= 1) {
mshstats->dropped_frames_ttl++;
rtw_rcu_read_unlock();
return;
}
ttl--;
if (mshcfg->dot11MeshForwarding) {
rtw_mesh_path_sel_frame_tx(RTW_MPATH_RANN, flags, originator_addr,
originator_sn, 0, NULL, 0, bcast_addr,
hopcount, ttl, interval,
metric + metric_txsta, 0, adapter);
}
rtw_rcu_read_unlock();
}
static u32 rtw_hwmp_route_info_get(_adapter *adapter,
struct rtw_ieee80211_hdr_3addr *mgmt,
const u8 *hwmp_ie, enum rtw_mpath_frame_type action)
{
struct rtw_mesh_path *path;
struct sta_priv *pstapriv = &adapter->stapriv;
struct sta_info *sta;
BOOLEAN fresh_info;
const u8 *originator_addr, *ta;
u32 originator_sn, originator_metric;
unsigned long originator_lifetime, exp_time;
u32 last_hop_metric, new_metric;
BOOLEAN process = _TRUE;
rtw_rcu_read_lock();
sta = rtw_get_stainfo(pstapriv, mgmt->addr2);
if (!sta) {
rtw_rcu_read_unlock();
return 0;
}
last_hop_metric = rtw_airtime_link_metric_get(adapter, sta);
/* Update and check originator routing info */
fresh_info = _TRUE;
switch (action) {
case RTW_MPATH_PREQ:
originator_addr = RTW_PREQ_IE_ORIG_ADDR(hwmp_ie);
originator_sn = RTW_PREQ_IE_ORIG_SN(hwmp_ie);
originator_lifetime = RTW_PREQ_IE_LIFETIME(hwmp_ie);
originator_metric = RTW_PREQ_IE_METRIC(hwmp_ie);
break;
case RTW_MPATH_PREP:
/* Note: For coding, the naming is not consist with spec */
originator_addr = RTW_PREP_IE_TARGET_ADDR(hwmp_ie);
originator_sn = RTW_PREP_IE_TARGET_SN(hwmp_ie);
originator_lifetime = RTW_PREP_IE_LIFETIME(hwmp_ie);
originator_metric = RTW_PREP_IE_METRIC(hwmp_ie);
break;
default:
rtw_rcu_read_unlock();
return 0;
}
new_metric = originator_metric + last_hop_metric;
if (new_metric < originator_metric)
new_metric = RTW_MAX_METRIC;
exp_time = RTW_TU_TO_EXP_TIME(originator_lifetime);
if (rtw_ether_addr_equal(originator_addr, adapter_mac_addr(adapter))) {
process = _FALSE;
fresh_info = _FALSE;
} else {
path = rtw_mesh_path_lookup(adapter, originator_addr);
if (path) {
enter_critical_bh(&path->state_lock);
if (path->flags & RTW_MESH_PATH_FIXED)
fresh_info = _FALSE;
else if ((path->flags & RTW_MESH_PATH_ACTIVE) &&
(path->flags & RTW_MESH_PATH_SN_VALID)) {
if (RTW_SN_GT(path->sn, originator_sn) ||
(path->sn == originator_sn &&
new_metric >= path->metric)) {
process = _FALSE;
fresh_info = _FALSE;
}
} else if (!(path->flags & RTW_MESH_PATH_ACTIVE)) {
BOOLEAN have_sn, newer_sn, bounced;
have_sn = path->flags & RTW_MESH_PATH_SN_VALID;
newer_sn = have_sn && RTW_SN_GT(originator_sn, path->sn);
bounced = have_sn &&
(RTW_SN_DELTA(originator_sn, path->sn) >
RTW_MAX_SANE_SN_DELTA);
if (!have_sn || newer_sn) {
} else if (bounced) {
} else {
process = _FALSE;
fresh_info = _FALSE;
}
}
} else {
path = rtw_mesh_path_add(adapter, originator_addr);
if (IS_ERR(path)) {
rtw_rcu_read_unlock();
return 0;
}
enter_critical_bh(&path->state_lock);
}
if (fresh_info) {
rtw_mesh_path_assign_nexthop(path, sta);
path->flags |= RTW_MESH_PATH_SN_VALID;
path->metric = new_metric;
path->sn = originator_sn;
path->exp_time = rtw_time_after(path->exp_time, exp_time)
? path->exp_time : exp_time;
rtw_mesh_path_activate(path);
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (path->is_root && (action == RTW_MPATH_PREP)) {
_rtw_memcpy(path->rann_snd_addr,
mgmt->addr2, ETH_ALEN);
path->rann_metric = new_metric;
}
#endif
exit_critical_bh(&path->state_lock);
rtw_mesh_path_tx_pending(path);
} else
exit_critical_bh(&path->state_lock);
}
/* Update and check transmitter routing info */
ta = mgmt->addr2;
if (rtw_ether_addr_equal(originator_addr, ta))
fresh_info = _FALSE;
else {
fresh_info = _TRUE;
path = rtw_mesh_path_lookup(adapter, ta);
if (path) {
enter_critical_bh(&path->state_lock);
if ((path->flags & RTW_MESH_PATH_FIXED) ||
((path->flags & RTW_MESH_PATH_ACTIVE) &&
(last_hop_metric > path->metric)))
fresh_info = _FALSE;
} else {
path = rtw_mesh_path_add(adapter, ta);
if (IS_ERR(path)) {
rtw_rcu_read_unlock();
return 0;
}
enter_critical_bh(&path->state_lock);
}
if (fresh_info) {
rtw_mesh_path_assign_nexthop(path, sta);
path->metric = last_hop_metric;
path->exp_time = rtw_time_after(path->exp_time, exp_time)
? path->exp_time : exp_time;
rtw_mesh_path_activate(path);
exit_critical_bh(&path->state_lock);
rtw_mesh_path_tx_pending(path);
} else
exit_critical_bh(&path->state_lock);
}
rtw_rcu_read_unlock();
return process ? new_metric : 0;
}
static void rtw_mesh_rx_hwmp_frame_cnts(_adapter *adapter, u8 *addr)
{
struct sta_info *sta;
sta = rtw_get_stainfo(&adapter->stapriv, addr);
if (sta)
sta->sta_stats.rx_hwmp_pkts++;
}
void rtw_mesh_rx_path_sel_frame(_adapter *adapter, union recv_frame *rframe)
{
struct mesh_plink_ent *plink = NULL;
struct rtw_ieee802_11_elems elems;
u32 path_metric;
struct rx_pkt_attrib *attrib = &rframe->u.hdr.attrib;
u8 *pframe = rframe->u.hdr.rx_data, *start;
uint frame_len = rframe->u.hdr.len, left;
struct rtw_ieee80211_hdr_3addr *frame_hdr = (struct rtw_ieee80211_hdr_3addr *)pframe;
u8 *frame_body = (u8 *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
ParseRes parse_res;
plink = rtw_mesh_plink_get(adapter, get_addr2_ptr(pframe));
if (!plink || plink->plink_state != RTW_MESH_PLINK_ESTAB)
return;
rtw_mesh_rx_hwmp_frame_cnts(adapter, get_addr2_ptr(pframe));
/* Mesh action frame IE offset = 2 */
attrib->hdrlen = sizeof(struct rtw_ieee80211_hdr_3addr);
left = frame_len - attrib->hdrlen - attrib->iv_len - attrib->icv_len - 2;
start = pframe + attrib->hdrlen + 2;
parse_res = rtw_ieee802_11_parse_elems(start, left, &elems, 1);
if (parse_res == ParseFailed)
RTW_HWMP_INFO(FUNC_ADPT_FMT" Path Select Frame ParseFailed\n"
, FUNC_ADPT_ARG(adapter));
else if (parse_res == ParseUnknown)
RTW_HWMP_INFO(FUNC_ADPT_FMT" Path Select Frame ParseUnknown\n"
, FUNC_ADPT_ARG(adapter));
if (elems.preq) {
if (elems.preq_len != 37)
/* Right now we support just 1 destination and no AE */
return;
path_metric = rtw_hwmp_route_info_get(adapter, frame_hdr, elems.preq,
MPATH_PREQ);
if (path_metric)
rtw_hwmp_preq_frame_process(adapter, frame_hdr, elems.preq,
path_metric);
}
if (elems.prep) {
if (elems.prep_len != 31)
/* Right now we support no AE */
return;
path_metric = rtw_hwmp_route_info_get(adapter, frame_hdr, elems.prep,
MPATH_PREP);
if (path_metric)
rtw_hwmp_prep_frame_process(adapter, frame_hdr, elems.prep,
path_metric);
}
if (elems.perr) {
if (elems.perr_len != 15)
/* Right now we support only one destination per PERR */
return;
rtw_hwmp_perr_frame_process(adapter, frame_hdr, elems.perr);
}
if (elems.rann)
rtw_hwmp_rann_frame_process(adapter, frame_hdr, (struct rtw_ieee80211_rann_ie *)elems.rann);
}
void rtw_mesh_queue_preq(struct rtw_mesh_path *path, u8 flags)
{
_adapter *adapter = path->adapter;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_preq_queue *preq_node;
preq_node = rtw_malloc(sizeof(struct rtw_mesh_preq_queue));
if (!preq_node) {
RTW_HWMP_INFO("could not allocate PREQ node\n");
return;
}
enter_critical_bh(&minfo->mesh_preq_queue_lock);
if (minfo->preq_queue_len == RTW_MAX_PREQ_QUEUE_LEN) {
exit_critical_bh(&minfo->mesh_preq_queue_lock);
rtw_mfree(preq_node, sizeof(struct rtw_mesh_preq_queue));
if (rtw_print_ratelimit())
RTW_HWMP_INFO("PREQ node queue full\n");
return;
}
_rtw_spinlock(&path->state_lock);
if (path->flags & RTW_MESH_PATH_REQ_QUEUED) {
_rtw_spinunlock(&path->state_lock);
exit_critical_bh(&minfo->mesh_preq_queue_lock);
rtw_mfree(preq_node, sizeof(struct rtw_mesh_preq_queue));
return;
}
_rtw_memcpy(preq_node->dst, path->dst, ETH_ALEN);
preq_node->flags = flags;
path->flags |= RTW_MESH_PATH_REQ_QUEUED;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (flags & RTW_PREQ_Q_F_CHK)
path->flags |= RTW_MESH_PATH_ROOT_ADD_CHK;
#endif
if (flags & RTW_PREQ_Q_F_PEER_AKA)
path->flags |= RTW_MESH_PATH_PEER_AKA;
_rtw_spinunlock(&path->state_lock);
rtw_list_insert_tail(&preq_node->list, &minfo->preq_queue.list);
++minfo->preq_queue_len;
exit_critical_bh(&minfo->mesh_preq_queue_lock);
if (rtw_time_after(rtw_get_current_time(), minfo->last_preq + rtw_min_preq_int_jiff(adapter)))
rtw_mesh_work(&adapter->mesh_work);
else if (rtw_time_before(rtw_get_current_time(), minfo->last_preq)) {
/* systime wrapped around issue */
minfo->last_preq = rtw_get_current_time() - rtw_min_preq_int_jiff(adapter) - 1;
rtw_mesh_work(&adapter->mesh_work);
} else
rtw_mod_timer(&adapter->mesh_path_timer, minfo->last_preq +
rtw_min_preq_int_jiff(adapter) + 1);
}
static const u8 *rtw_hwmp_preq_da(struct rtw_mesh_path *path,
BOOLEAN is_root_add_chk, BOOLEAN da_is_peer)
{
const u8 *da;
if (da_is_peer)
da = path->dst;
else if (path->is_root)
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
da = is_root_add_chk ? path->add_chk_rann_snd_addr:
path->rann_snd_addr;
#else
da = path->rann_snd_addr;
#endif
else
da = bcast_addr;
return da;
}
void rtw_mesh_path_start_discovery(_adapter *adapter)
{
struct rtw_mesh_info *minfo = &adapter->mesh_info;
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_preq_queue *preq_node;
struct rtw_mesh_path *path;
u8 ttl, target_flags = 0;
const u8 *da;
u32 lifetime;
u8 flags = 0;
BOOLEAN is_root_add_chk = _FALSE;
BOOLEAN da_is_peer;
enter_critical_bh(&minfo->mesh_preq_queue_lock);
if (!minfo->preq_queue_len ||
rtw_time_before(rtw_get_current_time(), minfo->last_preq +
rtw_min_preq_int_jiff(adapter))) {
exit_critical_bh(&minfo->mesh_preq_queue_lock);
return;
}
preq_node = rtw_list_first_entry(&minfo->preq_queue.list,
struct rtw_mesh_preq_queue, list);
rtw_list_delete(&preq_node->list); /* list_del_init(&preq_node->list); */
--minfo->preq_queue_len;
exit_critical_bh(&minfo->mesh_preq_queue_lock);
rtw_rcu_read_lock();
path = rtw_mesh_path_lookup(adapter, preq_node->dst);
if (!path)
goto enddiscovery;
enter_critical_bh(&path->state_lock);
if (path->flags & (RTW_MESH_PATH_DELETED | RTW_MESH_PATH_FIXED)) {
exit_critical_bh(&path->state_lock);
goto enddiscovery;
}
path->flags &= ~RTW_MESH_PATH_REQ_QUEUED;
if (preq_node->flags & RTW_PREQ_Q_F_START) {
if (path->flags & RTW_MESH_PATH_RESOLVING) {
exit_critical_bh(&path->state_lock);
goto enddiscovery;
} else {
path->flags &= ~RTW_MESH_PATH_RESOLVED;
path->flags |= RTW_MESH_PATH_RESOLVING;
path->discovery_retries = 0;
path->discovery_timeout = rtw_disc_timeout_jiff(adapter);
}
} else if (!(path->flags & RTW_MESH_PATH_RESOLVING) ||
path->flags & RTW_MESH_PATH_RESOLVED) {
path->flags &= ~RTW_MESH_PATH_RESOLVING;
exit_critical_bh(&path->state_lock);
goto enddiscovery;
}
minfo->last_preq = rtw_get_current_time();
if (rtw_time_after(rtw_get_current_time(), minfo->last_sn_update +
rtw_net_traversal_jiffies(adapter)) ||
rtw_time_before(rtw_get_current_time(), minfo->last_sn_update)) {
++minfo->sn;
minfo->last_sn_update = rtw_get_current_time();
}
lifetime = rtw_default_lifetime(adapter);
ttl = mshcfg->element_ttl;
if (ttl == 0) {
minfo->mshstats.dropped_frames_ttl++;
exit_critical_bh(&path->state_lock);
goto enddiscovery;
}
if (preq_node->flags & RTW_PREQ_Q_F_REFRESH)
target_flags |= RTW_IEEE80211_PREQ_TO_FLAG;
else
target_flags &= ~RTW_IEEE80211_PREQ_TO_FLAG;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
is_root_add_chk = !!(path->flags & RTW_MESH_PATH_ROOT_ADD_CHK);
#endif
da_is_peer = !!(path->flags & RTW_MESH_PATH_PEER_AKA);
exit_critical_bh(&path->state_lock);
da = rtw_hwmp_preq_da(path, is_root_add_chk, da_is_peer);
#ifdef CONFIG_RTW_MESH_ON_DMD_GANN
flags = (mshcfg->dot11MeshGateAnnouncementProtocol)
? RTW_IEEE80211_PREQ_IS_GATE_FLAG : 0;
#endif
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREQ, flags, adapter_mac_addr(adapter), minfo->sn,
target_flags, path->dst, path->sn, da, 0,
ttl, lifetime, 0, minfo->preq_id++, adapter);
rtw_mod_timer(&path->timer, rtw_get_current_time() + path->discovery_timeout);
enddiscovery:
rtw_rcu_read_unlock();
rtw_mfree(preq_node, sizeof(struct rtw_mesh_preq_queue));
}
void rtw_mesh_path_timer(void *ctx)
{
struct rtw_mesh_path *path = (void *) ctx;
_adapter *adapter = path->adapter;
int ret;
u8 retry = 0;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
#endif
/* TBD: Proctect for suspend */
#if 0
if (suspending)
return;
#endif
enter_critical_bh(&path->state_lock);
if (path->flags & RTW_MESH_PATH_RESOLVED ||
(!(path->flags & RTW_MESH_PATH_RESOLVING))) {
path->flags &= ~(RTW_MESH_PATH_RESOLVING |
RTW_MESH_PATH_RESOLVED |
RTW_MESH_PATH_ROOT_ADD_CHK |
RTW_MESH_PATH_PEER_AKA);
exit_critical_bh(&path->state_lock);
} else if (path->discovery_retries < rtw_max_preq_retries(adapter)) {
++path->discovery_retries;
path->discovery_timeout *= 2;
path->flags &= ~RTW_MESH_PATH_REQ_QUEUED;
#ifdef CONFIG_RTW_MESH_ADD_ROOT_CHK
if (path->discovery_retries > mshcfg->max_root_add_chk_cnt)
path->flags &= ~RTW_MESH_PATH_ROOT_ADD_CHK;
#endif
if (path->gate_asked)
retry |= RTW_PREQ_Q_F_REFRESH;
exit_critical_bh(&path->state_lock);
rtw_mesh_queue_preq(path, retry);
} else {
path->flags &= ~(RTW_MESH_PATH_RESOLVING |
RTW_MESH_PATH_RESOLVED |
RTW_MESH_PATH_REQ_QUEUED |
RTW_MESH_PATH_ROOT_ADD_CHK |
RTW_MESH_PATH_PEER_AKA);
path->exp_time = rtw_get_current_time();
exit_critical_bh(&path->state_lock);
if (!path->is_gate && rtw_mesh_gate_num(adapter) > 0) {
ret = rtw_mesh_path_send_to_gates(path);
if (ret)
RTW_HWMP_DBG("no gate was reachable\n");
} else
rtw_mesh_path_flush_pending(path);
}
}
void rtw_mesh_path_tx_root_frame(_adapter *adapter)
{
struct rtw_mesh_cfg *mshcfg = &adapter->mesh_cfg;
struct rtw_mesh_info *minfo = &adapter->mesh_info;
u32 interval = mshcfg->dot11MeshHWMPRannInterval;
u8 flags, target_flags = 0;
flags = (mshcfg->dot11MeshGateAnnouncementProtocol)
? RTW_RANN_FLAG_IS_GATE : 0;
switch (mshcfg->dot11MeshHWMPRootMode) {
case RTW_IEEE80211_PROACTIVE_RANN:
rtw_mesh_path_sel_frame_tx(RTW_MPATH_RANN, flags, adapter_mac_addr(adapter),
++minfo->sn, 0, NULL, 0, bcast_addr,
0, mshcfg->element_ttl,
interval, 0, 0, adapter);
break;
case RTW_IEEE80211_PROACTIVE_PREQ_WITH_PREP:
flags |= RTW_IEEE80211_PREQ_PROACTIVE_PREP_FLAG;
case RTW_IEEE80211_PROACTIVE_PREQ_NO_PREP:
interval = mshcfg->dot11MeshHWMPactivePathToRootTimeout;
target_flags |= RTW_IEEE80211_PREQ_TO_FLAG |
RTW_IEEE80211_PREQ_USN_FLAG;
rtw_mesh_path_sel_frame_tx(RTW_MPATH_PREQ, flags, adapter_mac_addr(adapter),
++minfo->sn, target_flags,
(u8 *) bcast_addr, 0, bcast_addr,
0, mshcfg->element_ttl, interval,
0, minfo->preq_id++, adapter);
break;
default:
RTW_HWMP_INFO("Proactive mechanism not supported\n");
return;
}
}
void rtw_mesh_work(_workitem *work)
{
/* use kernel global workqueue */
_set_workitem(work);
}
void rtw_ieee80211_mesh_path_timer(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
rtw_mesh_work(&adapter->mesh_work);
}
void rtw_ieee80211_mesh_path_root_timer(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
rtw_set_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags);
rtw_mesh_work(&adapter->mesh_work);
}
static void rtw_ieee80211_mesh_rootpath(_adapter *adapter)
{
u32 interval;
rtw_mesh_path_tx_root_frame(adapter);
if (adapter->mesh_cfg.dot11MeshHWMPRootMode == RTW_IEEE80211_PROACTIVE_RANN)
interval = adapter->mesh_cfg.dot11MeshHWMPRannInterval;
else
interval = adapter->mesh_cfg.dot11MeshHWMProotInterval;
rtw_mod_timer(&adapter->mesh_path_root_timer,
RTW_TU_TO_EXP_TIME(interval));
}
BOOLEAN rtw_ieee80211_mesh_root_setup(_adapter *adapter)
{
BOOLEAN root_enabled = _FALSE;
if (adapter->mesh_cfg.dot11MeshHWMPRootMode > RTW_IEEE80211_ROOTMODE_ROOT) {
rtw_set_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags);
root_enabled = _TRUE;
}
else {
rtw_clear_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags);
/* stop running timer */
_cancel_timer_ex(&adapter->mesh_path_root_timer);
root_enabled = _FALSE;
}
return root_enabled;
}
void rtw_mesh_work_hdl(_workitem *work)
{
_adapter *adapter = container_of(work, _adapter, mesh_work);
while(adapter->mesh_info.preq_queue_len) {
if (rtw_time_after(rtw_get_current_time(),
adapter->mesh_info.last_preq + rtw_min_preq_int_jiff(adapter)))
/* It will consume preq_queue_len */
rtw_mesh_path_start_discovery(adapter);
else {
struct rtw_mesh_info *minfo = &adapter->mesh_info;
rtw_mod_timer(&adapter->mesh_path_timer,
minfo->last_preq + rtw_min_preq_int_jiff(adapter) + 1);
break;
}
}
if (rtw_test_and_clear_bit(RTW_MESH_WORK_ROOT, &adapter->wrkq_flags))
rtw_ieee80211_mesh_rootpath(adapter);
}
#ifndef RTW_PER_CMD_SUPPORT_FW
static void rtw_update_metric_directly(_adapter *adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
u8 i;
for (i = 0; i < macid_ctl->num; i++) {
u8 role;
role = GET_H2CCMD_MSRRPT_PARM_ROLE(&macid_ctl->h2c_msr[i]);
if (role == H2C_MSR_ROLE_MESH) {
struct sta_info *sta = macid_ctl->sta[i];
u8 rate_idx, sgi, bw;
u32 rate;
if (!sta)
continue;
rate_idx = rtw_get_current_tx_rate(adapter, sta);
sgi = rtw_get_current_tx_sgi(adapter, sta);
bw = sta->cmn.bw_mode;
rate = rtw_desc_rate_to_bitrate(bw, rate_idx, sgi);
sta->metrics.data_rate = rate;
}
}
}
#endif
void rtw_mesh_atlm_param_req_timer(void *ctx)
{
_adapter *adapter = (_adapter *)ctx;
u8 ret = _FAIL;
#ifdef RTW_PER_CMD_SUPPORT_FW
ret = rtw_req_per_cmd(adapter);
if (ret == _FAIL)
RTW_HWMP_INFO("rtw_req_per_cmd fail\n");
#else
rtw_update_metric_directly(adapter);
#endif
_set_timer(&adapter->mesh_atlm_param_req_timer, RTW_ATLM_REQ_CYCLE);
}
#endif /* CONFIG_RTW_MESH */
Reference in New Issue View Git Blame Copy Permalink