samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Add stats on OFDMA and MU-MIMO packet

Browse Source 
Add MCS, NSS, MPDU FCS OK, MPDU FCS ERR stats
classified by SU, OFDMA and MU-MIMO.

Change-Id: I3ade03acc06bd924fdeb8dfcaf6b18fb01f01d68
This commit is contained in:
Kai Chen
2019-10-14 17:42:24 -07:00
committed by nshrivas
parent 7ce41f14c1
commit a8cf59455e
6 changed files with 437 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
dp/inc/cdp_txrx_cmn_struct.h
View File

@@ -1622,7 +1622,7 @@ struct cdp_tx_completion_msdu {
* @peer_id: Peer ID * @peer_id: Peer ID
* @vdev_id: VAP ID * @vdev_id: VAP ID
* @is_ampdu: mpdu aggregate or non-aggregate? * @is_ampdu: mpdu aggregate or non-aggregate?
* @ofdma_info_valid: RU info valid * @mu_ul_info_valid: MU UL info valid
* @ofdma_ru_start_index: RU index number(0-73) * @ofdma_ru_start_index: RU index number(0-73)
* @ofdma_ru_width: size of RU in units of 1(26tone)RU * @ofdma_ru_width: size of RU in units of 1(26tone)RU
* @nss: NSS 1,2, ...8 * @nss: NSS 1,2, ...8
@@ -1652,7 +1652,7 @@ struct cdp_rx_stats_ppdu_user {
uint16_t peer_id; uint16_t peer_id;
uint8_t vdev_id; uint8_t vdev_id;
bool is_ampdu; bool is_ampdu;
uint32_t ofdma_info_valid:1, uint32_t mu_ul_info_valid:1,
ofdma_ru_start_index:7, ofdma_ru_start_index:7,
ofdma_ru_width:7, ofdma_ru_width:7,
nss:4, nss:4,
@@ -1661,6 +1661,7 @@ struct cdp_rx_stats_ppdu_user {
uint8_t user_index; uint8_t user_index;
uint32_t ast_index; uint32_t ast_index;
uint32_t tid; uint32_t tid;
uint32_t num_msdu;
uint16_t tcp_msdu_count; uint16_t tcp_msdu_count;
uint16_t udp_msdu_count; uint16_t udp_msdu_count;
uint16_t other_msdu_count; uint16_t other_msdu_count;

40
dp/inc/cdp_txrx_stats_struct.h
View File

@@ -195,6 +195,18 @@ enum cdp_packet_type {
DOT11_MAX = 5, DOT11_MAX = 5,
}; };
/*
* cdp_mu_packet_type: MU Rx type index
* RX_TYPE_MU_MIMO: MU MIMO Rx type index
* RX_TYPE_MU_OFDMA: MU OFDMA Rx type index
* MU_MIMO_OFDMA: MU Rx MAX type index
*/
enum cdp_mu_packet_type {
RX_TYPE_MU_MIMO = 0,
RX_TYPE_MU_OFDMA = 1,
RX_TYPE_MU_MAX = 2,
};
enum WDI_EVENT { enum WDI_EVENT {
WDI_EVENT_TX_STATUS = WDI_EVENT_BASE, WDI_EVENT_TX_STATUS = WDI_EVENT_BASE,
WDI_EVENT_OFFLOAD_ALL, WDI_EVENT_OFFLOAD_ALL,
@@ -445,6 +457,20 @@ struct cdp_pkt_type {
uint32_t mcs_count[MAX_MCS]; uint32_t mcs_count[MAX_MCS];
}; };
/*
* struct cdp_rx_mu - Rx MU Stats
* @ppdu_nss[SS_COUNT]: Packet Count in spatial streams
* @mpdu_cnt_fcs_ok: Rx success mpdu count
* @mpdu_cnt_fcs_err: Rx fail mpdu count
* @cdp_pkt_type: counter array for each MCS index
*/
struct cdp_rx_mu {
uint32_t ppdu_nss[SS_COUNT];
uint32_t mpdu_cnt_fcs_ok;
uint32_t mpdu_cnt_fcs_err;
struct cdp_pkt_type ppdu;
};
/* struct cdp_tx_pkt_info - tx packet info /* struct cdp_tx_pkt_info - tx packet info
* num_msdu - successful msdu * num_msdu - successful msdu
* num_mpdu - successful mpdu from compltn common * num_mpdu - successful mpdu from compltn common
@@ -706,7 +732,13 @@ struct cdp_tx_stats {
* @reception_type[MAX_RECEPTION_TYPES]: Reception type os packets * @reception_type[MAX_RECEPTION_TYPES]: Reception type os packets
* @mcs_count[MAX_MCS]: mcs count * @mcs_count[MAX_MCS]: mcs count
* @sgi_count[MAX_GI]: sgi count * @sgi_count[MAX_GI]: sgi count
* @nss[SS_COUNT]: Packet count in spatiel Streams * @nss[SS_COUNT]: packet count in spatiel Streams
* @ppdu_nss[SS_COUNT]: PPDU packet count in spatial streams
* @mpdu_cnt_fcs_ok: SU Rx success mpdu count
* @mpdu_cnt_fcs_err: SU Rx fail mpdu count
* @su_ax_ppdu_cnt: SU Rx packet count
* @ppdu_cnt[MAX_RECEPTION_TYPES]: PPDU packet count in reception type
* @rx_mu[RX_TYPE_MU_MAX]: Rx MU stats
* @bw[MAX_BW]: Packet Count in different bandwidths * @bw[MAX_BW]: Packet Count in different bandwidths
* @non_ampdu_cnt: Number of MSDUs with no MPDU level aggregation * @non_ampdu_cnt: Number of MSDUs with no MPDU level aggregation
* @ampdu_cnt: Number of MSDUs part of AMSPU * @ampdu_cnt: Number of MSDUs part of AMSPU
@@ -767,6 +799,12 @@ struct cdp_rx_stats {
struct cdp_pkt_type pkt_type[DOT11_MAX]; struct cdp_pkt_type pkt_type[DOT11_MAX];
uint32_t sgi_count[MAX_GI]; uint32_t sgi_count[MAX_GI];
uint32_t nss[SS_COUNT]; uint32_t nss[SS_COUNT];
uint32_t ppdu_nss[SS_COUNT];
uint32_t mpdu_cnt_fcs_ok;
uint32_t mpdu_cnt_fcs_err;
struct cdp_pkt_type su_ax_ppdu_cnt;
uint32_t ppdu_cnt[MAX_RECEPTION_TYPES];
struct cdp_rx_mu rx_mu[RX_TYPE_MU_MAX];
uint32_t bw[MAX_BW]; uint32_t bw[MAX_BW];
uint32_t non_ampdu_cnt; uint32_t non_ampdu_cnt;
uint32_t ampdu_cnt; uint32_t ampdu_cnt;

326
dp/wifi3.0/dp_rx_mon_status.c
View File

@@ -116,7 +116,7 @@ dp_rx_inc_rusize_cnt(struct dp_pdev *pdev,
uint32_t ru_size; uint32_t ru_size;
bool is_data; bool is_data;
ru_size = rx_user_status->dl_ofdma_ru_size; ru_size = rx_user_status->ofdma_ru_size;
if (dp_is_subtype_data(rx_user_status->frame_control)) { if (dp_is_subtype_data(rx_user_status->frame_control)) {
DP_STATS_INC(pdev, DP_STATS_INC(pdev,
@@ -169,19 +169,19 @@ dp_rx_populate_cdp_indication_ppdu_user(struct dp_pdev *pdev,
ast_index = rx_user_status->ast_index; ast_index = rx_user_status->ast_index;
if (ast_index >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) { if (ast_index >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
rx_stats_peruser->peer_id = HTT_INVALID_PEER; rx_stats_peruser->peer_id = HTT_INVALID_PEER;
return; continue;
} }
ast_entry = soc->ast_table[ast_index]; ast_entry = soc->ast_table[ast_index];
if (!ast_entry) { if (!ast_entry) {
rx_stats_peruser->peer_id = HTT_INVALID_PEER; rx_stats_peruser->peer_id = HTT_INVALID_PEER;
return; continue;
} }
peer = ast_entry->peer; peer = ast_entry->peer;
if (!peer || peer->peer_ids[0] == HTT_INVALID_PEER) { if (!peer || peer->peer_ids[0] == HTT_INVALID_PEER) {
rx_stats_peruser->peer_id = HTT_INVALID_PEER; rx_stats_peruser->peer_id = HTT_INVALID_PEER;
return; continue;
} }
rx_stats_peruser->first_data_seq_ctrl = rx_stats_peruser->first_data_seq_ctrl =
@@ -198,6 +198,12 @@ dp_rx_populate_cdp_indication_ppdu_user(struct dp_pdev *pdev,
rx_user_status->udp_msdu_count; rx_user_status->udp_msdu_count;
rx_stats_peruser->other_msdu_count = rx_stats_peruser->other_msdu_count =
rx_user_status->other_msdu_count; rx_user_status->other_msdu_count;
rx_stats_peruser->num_msdu =
rx_stats_peruser->tcp_msdu_count +
rx_stats_peruser->udp_msdu_count +
rx_stats_peruser->other_msdu_count;
rx_stats_peruser->preamble_type = rx_stats_peruser->preamble_type =
rx_user_status->preamble_type; rx_user_status->preamble_type;
rx_stats_peruser->mpdu_cnt_fcs_ok = rx_stats_peruser->mpdu_cnt_fcs_ok =
@@ -214,10 +220,7 @@ dp_rx_populate_cdp_indication_ppdu_user(struct dp_pdev *pdev,
rx_user_status->mpdu_err_byte_count; rx_user_status->mpdu_err_byte_count;
cdp_rx_ppdu->num_mpdu += rx_user_status->mpdu_cnt_fcs_ok; cdp_rx_ppdu->num_mpdu += rx_user_status->mpdu_cnt_fcs_ok;
cdp_rx_ppdu->num_msdu += cdp_rx_ppdu->num_msdu += rx_stats_peruser->num_msdu;
(rx_stats_peruser->tcp_msdu_count +
rx_stats_peruser->udp_msdu_count +
rx_stats_peruser->other_msdu_count);
rx_stats_peruser->retries = rx_stats_peruser->retries =
CDP_FC_IS_RETRY_SET(rx_stats_peruser->frame_control) ? CDP_FC_IS_RETRY_SET(rx_stats_peruser->frame_control) ?
rx_stats_peruser->mpdu_cnt_fcs_ok : 0; rx_stats_peruser->mpdu_cnt_fcs_ok : 0;
@@ -234,20 +237,21 @@ dp_rx_populate_cdp_indication_ppdu_user(struct dp_pdev *pdev,
rx_stats_peruser->peer_id = peer->peer_ids[0]; rx_stats_peruser->peer_id = peer->peer_ids[0];
cdp_rx_ppdu->vdev_id = peer->vdev->vdev_id; cdp_rx_ppdu->vdev_id = peer->vdev->vdev_id;
rx_stats_peruser->vdev_id = peer->vdev->vdev_id; rx_stats_peruser->vdev_id = peer->vdev->vdev_id;
rx_stats_peruser->ofdma_info_valid = 0; rx_stats_peruser->mu_ul_info_valid = 0;
if (cdp_rx_ppdu->u.ppdu_type == HAL_RX_TYPE_MU_OFDMA) { if (cdp_rx_ppdu->u.ppdu_type == HAL_RX_TYPE_MU_OFDMA ||
if (rx_user_status->ofdma_info_valid) { cdp_rx_ppdu->u.ppdu_type == HAL_RX_TYPE_MU_MIMO) {
if (rx_user_status->mu_ul_info_valid) {
rx_stats_peruser->nss = rx_user_status->nss; rx_stats_peruser->nss = rx_user_status->nss;
rx_stats_peruser->mcs = rx_user_status->mcs; rx_stats_peruser->mcs = rx_user_status->mcs;
rx_stats_peruser->ofdma_info_valid = rx_stats_peruser->mu_ul_info_valid =
rx_user_status->ofdma_info_valid; rx_user_status->mu_ul_info_valid;
rx_stats_peruser->ofdma_ru_start_index = rx_stats_peruser->ofdma_ru_start_index =
rx_user_status->dl_ofdma_ru_start_index; rx_user_status->ofdma_ru_start_index;
rx_stats_peruser->ofdma_ru_width = rx_stats_peruser->ofdma_ru_width =
rx_user_status->dl_ofdma_ru_width; rx_user_status->ofdma_ru_width;
rx_stats_peruser->user_index = i; rx_stats_peruser->user_index = i;
ru_size = rx_user_status->dl_ofdma_ru_size; ru_size = rx_user_status->ofdma_ru_size;
/* /*
* max RU size will be equal to * max RU size will be equal to
* HTT_UL_OFDMA_V0_RU_SIZE_RU_996x2 * HTT_UL_OFDMA_V0_RU_SIZE_RU_996x2
@@ -396,24 +400,28 @@ dp_rx_populate_cdp_indication_ppdu(struct dp_pdev *pdev,
*/ */
#ifdef FEATURE_PERPKT_INFO #ifdef FEATURE_PERPKT_INFO
static inline void dp_rx_rate_stats_update(struct dp_peer *peer, static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
struct cdp_rx_indication_ppdu *ppdu) struct cdp_rx_indication_ppdu *ppdu,
uint32_t user)
{ {
uint32_t ratekbps = 0; uint32_t ratekbps = 0;
uint32_t ppdu_rx_rate = 0; uint32_t ppdu_rx_rate = 0;
uint32_t nss = 0; uint32_t nss = 0;
uint32_t rix; uint32_t rix;
uint16_t ratecode; uint16_t ratecode;
struct cdp_rx_stats_ppdu_user *ppdu_user;
if (!peer || !ppdu) if (!peer || !ppdu)
return; return;
if (ppdu->u.nss == 0) ppdu_user = &ppdu->user[user];
if (ppdu_user->nss == 0)
nss = 0; nss = 0;
else else
nss = ppdu->u.nss - 1; nss = ppdu_user->nss - 1;
ratekbps = dp_getrateindex(ppdu->u.gi, ratekbps = dp_getrateindex(ppdu->u.gi,
ppdu->u.mcs, ppdu_user->mcs,
nss, nss,
ppdu->u.preamble, ppdu->u.preamble,
ppdu->u.bw, ppdu->u.bw,
@@ -435,123 +443,205 @@ static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
peer->vdev->stats.rx.last_rx_rate = ratekbps; peer->vdev->stats.rx.last_rx_rate = ratekbps;
} }
static void dp_rx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer, static void dp_rx_stats_update(struct dp_pdev *pdev,
struct cdp_rx_indication_ppdu *ppdu) struct cdp_rx_indication_ppdu *ppdu)
{ {
struct dp_soc *soc = NULL; struct dp_soc *soc = NULL;
uint8_t mcs, preamble, ac = 0; uint8_t mcs, preamble, ac = 0, nss, ppdu_type;
uint16_t num_msdu; uint16_t num_msdu;
bool is_invalid_peer = false;
uint8_t pkt_bw_offset; uint8_t pkt_bw_offset;
struct dp_peer *peer;
mcs = ppdu->u.mcs; struct cdp_rx_stats_ppdu_user *ppdu_user;
preamble = ppdu->u.preamble; uint32_t i;
num_msdu = ppdu->num_msdu; enum cdp_mu_packet_type mu_pkt_type;
if (pdev) if (pdev)
soc = pdev->soc; soc = pdev->soc;
else else
return; return;
if (!peer) {
is_invalid_peer = true;
peer = pdev->invalid_peer;
}
if (!soc || soc->process_rx_status) if (!soc || soc->process_rx_status)
return; return;
switch (ppdu->u.bw) { preamble = ppdu->u.preamble;
case CMN_BW_20MHZ: ppdu_type = ppdu->u.ppdu_type;
pkt_bw_offset = PKT_BW_GAIN_20MHZ;
break;
case CMN_BW_40MHZ:
pkt_bw_offset = PKT_BW_GAIN_40MHZ;
break;
case CMN_BW_80MHZ:
pkt_bw_offset = PKT_BW_GAIN_80MHZ;
break;
case CMN_BW_160MHZ:
pkt_bw_offset = PKT_BW_GAIN_160MHZ;
break;
default:
pkt_bw_offset = 0;
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
"Invalid BW index = %d", ppdu->u.bw);
}
DP_STATS_UPD(peer, rx.rssi, (ppdu->rssi + pkt_bw_offset)); for (i = 0; i < ppdu->num_users; i++) {
ppdu_user = &ppdu->user[i];
peer = dp_peer_find_by_id(soc, ppdu_user->peer_id);
if (peer->stats.rx.avg_rssi == INVALID_RSSI) if (!peer)
peer->stats.rx.avg_rssi = peer->stats.rx.rssi; peer = pdev->invalid_peer;
else
peer->stats.rx.avg_rssi =
DP_GET_AVG_RSSI(peer->stats.rx.avg_rssi,
peer->stats.rx.rssi);
if ((preamble == DOT11_A) || (preamble == DOT11_B)) ppdu->cookie = (void *)peer->wlanstats_ctx;
ppdu->u.nss = 1;
if (ppdu->u.nss) if (ppdu_type == HAL_RX_TYPE_SU) {
DP_STATS_INC(peer, rx.nss[ppdu->u.nss - 1], num_msdu); mcs = ppdu->u.mcs;
nss = ppdu->u.nss;
} else {
mcs = ppdu_user->mcs;
nss = ppdu_user->nss;
}
DP_STATS_INC(peer, rx.sgi_count[ppdu->u.gi], num_msdu); num_msdu = ppdu_user->num_msdu;
DP_STATS_INC(peer, rx.bw[ppdu->u.bw], num_msdu); switch (ppdu->u.bw) {
DP_STATS_INC(peer, rx.reception_type[ppdu->u.ppdu_type], num_msdu); case CMN_BW_20MHZ:
DP_STATS_INCC(peer, rx.ampdu_cnt, num_msdu, ppdu->is_ampdu); pkt_bw_offset = PKT_BW_GAIN_20MHZ;
DP_STATS_INCC(peer, rx.non_ampdu_cnt, num_msdu, !(ppdu->is_ampdu)); break;
DP_STATS_UPD(peer, rx.rx_rate, mcs); case CMN_BW_40MHZ:
DP_STATS_INCC(peer, pkt_bw_offset = PKT_BW_GAIN_40MHZ;
break;
case CMN_BW_80MHZ:
pkt_bw_offset = PKT_BW_GAIN_80MHZ;
break;
case CMN_BW_160MHZ:
pkt_bw_offset = PKT_BW_GAIN_160MHZ;
break;
default:
pkt_bw_offset = 0;
QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
"Invalid BW index = %d", ppdu->u.bw);
}
DP_STATS_UPD(peer, rx.rssi, (ppdu->rssi + pkt_bw_offset));
if (peer->stats.rx.avg_rssi == INVALID_RSSI)
peer->stats.rx.avg_rssi = ppdu->rssi;
else
peer->stats.rx.avg_rssi =
DP_GET_AVG_RSSI(peer->stats.rx.avg_rssi,
ppdu->rssi);
if ((preamble == DOT11_A) || (preamble == DOT11_B))
nss = 1;
if (ppdu_type == HAL_RX_TYPE_SU) {
if (nss) {
DP_STATS_INC(peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(peer, rx.ppdu_nss[nss - 1], 1);
}
DP_STATS_INC(peer, rx.mpdu_cnt_fcs_ok,
ppdu_user->mpdu_cnt_fcs_ok);
DP_STATS_INC(peer, rx.mpdu_cnt_fcs_err,
ppdu_user->mpdu_cnt_fcs_err);
}
if (ppdu_type >= HAL_RX_TYPE_MU_MIMO &&
ppdu_type <= HAL_RX_TYPE_MU_OFDMA) {
if (ppdu_type == HAL_RX_TYPE_MU_MIMO)
mu_pkt_type = RX_TYPE_MU_MIMO;
else
mu_pkt_type = RX_TYPE_MU_OFDMA;
if (nss) {
DP_STATS_INC(peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(peer,
rx.rx_mu[mu_pkt_type].ppdu_nss[nss - 1],
1);
}
DP_STATS_INC(peer,
rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_ok,
ppdu_user->mpdu_cnt_fcs_ok);
DP_STATS_INC(peer,
rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_err,
ppdu_user->mpdu_cnt_fcs_err);
}
DP_STATS_INC(peer, rx.sgi_count[ppdu->u.gi], num_msdu);
DP_STATS_INC(peer, rx.bw[ppdu->u.bw], num_msdu);
DP_STATS_INC(peer, rx.reception_type[ppdu->u.ppdu_type],
num_msdu);
DP_STATS_INC(peer, rx.ppdu_cnt[ppdu->u.ppdu_type], 1);
DP_STATS_INCC(peer, rx.ampdu_cnt, num_msdu,
ppdu_user->is_ampdu);
DP_STATS_INCC(peer, rx.non_ampdu_cnt, num_msdu,
!(ppdu_user->is_ampdu));
DP_STATS_UPD(peer, rx.rx_rate, mcs);
DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11A) && (preamble == DOT11_A))); ((mcs >= MAX_MCS_11A) && (preamble == DOT11_A)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu, rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11A) && (preamble == DOT11_A))); ((mcs < MAX_MCS_11A) && (preamble == DOT11_A)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11B) && (preamble == DOT11_B))); ((mcs >= MAX_MCS_11B) && (preamble == DOT11_B)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu, rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11B) && (preamble == DOT11_B))); ((mcs < MAX_MCS_11B) && (preamble == DOT11_B)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11A) && (preamble == DOT11_N))); ((mcs >= MAX_MCS_11A) && (preamble == DOT11_N)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu, rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11A) && (preamble == DOT11_N))); ((mcs < MAX_MCS_11A) && (preamble == DOT11_N)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC))); ((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu, rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC))); ((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX))); ((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX)));
DP_STATS_INCC(peer, DP_STATS_INCC(peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu, rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX))); ((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX)));
/* DP_STATS_INCC(peer,
* If invalid TID, it could be a non-qos frame, hence do not update rx.su_ax_ppdu_cnt.mcs_count[MAX_MCS - 1], 1,
* any AC counters ((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX) &&
*/ (ppdu_type == HAL_RX_TYPE_SU)));
ac = TID_TO_WME_AC(ppdu->tid); DP_STATS_INCC(peer,
if (ppdu->tid != HAL_TID_INVALID) rx.su_ax_ppdu_cnt.mcs_count[mcs], 1,
DP_STATS_INC(peer, rx.wme_ac_type[ac], num_msdu); ((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX) &&
dp_peer_stats_notify(pdev, peer); (ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_UPD(peer, rx.last_rssi, ppdu->rssi); DP_STATS_INCC(peer,
rx.rx_mu[RX_TYPE_MU_OFDMA].ppdu.mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer,
rx.rx_mu[RX_TYPE_MU_OFDMA].ppdu.mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer,
rx.rx_mu[RX_TYPE_MU_MIMO].ppdu.mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO)));
DP_STATS_INCC(peer,
rx.rx_mu[RX_TYPE_MU_MIMO].ppdu.mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO)));
if (is_invalid_peer) /*
return; * If invalid TID, it could be a non-qos frame, hence do not
* update any AC counters
*/
ac = TID_TO_WME_AC(ppdu_user->tid);
if (dp_is_subtype_data(ppdu->frame_ctrl)) if (ppdu->tid != HAL_TID_INVALID)
dp_rx_rate_stats_update(peer, ppdu); DP_STATS_INC(peer, rx.wme_ac_type[ac], num_msdu);
dp_peer_stats_notify(pdev, peer);
DP_STATS_UPD(peer, rx.last_rssi, ppdu->rssi);
if (peer == pdev->invalid_peer)
continue;
if (dp_is_subtype_data(ppdu->frame_ctrl))
dp_rx_rate_stats_update(peer, ppdu, i);
#if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE
dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc, dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
&peer->stats, ppdu->peer_id, &peer->stats, ppdu->peer_id,
UPDATE_PEER_STATS, pdev->pdev_id); UPDATE_PEER_STATS, pdev->pdev_id);
#endif #endif
dp_peer_unref_del_find_by_id(peer);
}
} }
#endif #endif
@@ -811,7 +901,6 @@ dp_rx_handle_ppdu_stats(struct dp_soc *soc, struct dp_pdev *pdev,
struct hal_rx_ppdu_info *ppdu_info) struct hal_rx_ppdu_info *ppdu_info)
{ {
qdf_nbuf_t ppdu_nbuf; qdf_nbuf_t ppdu_nbuf;
struct dp_peer *peer;
struct cdp_rx_indication_ppdu *cdp_rx_ppdu; struct cdp_rx_indication_ppdu *cdp_rx_ppdu;
/* /*
@@ -862,12 +951,8 @@ dp_rx_handle_ppdu_stats(struct dp_soc *soc, struct dp_pdev *pdev,
qdf_nbuf_put_tail(ppdu_nbuf, qdf_nbuf_put_tail(ppdu_nbuf,
sizeof(struct cdp_rx_indication_ppdu)); sizeof(struct cdp_rx_indication_ppdu));
cdp_rx_ppdu = (struct cdp_rx_indication_ppdu *)ppdu_nbuf->data; cdp_rx_ppdu = (struct cdp_rx_indication_ppdu *)ppdu_nbuf->data;
peer = dp_peer_find_by_id(soc, cdp_rx_ppdu->peer_id); dp_rx_stats_update(pdev, cdp_rx_ppdu);
if (peer) {
cdp_rx_ppdu->cookie = (void *)peer->wlanstats_ctx;
dp_rx_stats_update(pdev, peer, cdp_rx_ppdu);
dp_peer_unref_del_find_by_id(peer);
}
if (cdp_rx_ppdu->peer_id != HTT_INVALID_PEER) { if (cdp_rx_ppdu->peer_id != HTT_INVALID_PEER) {
dp_wdi_event_handler(WDI_EVENT_RX_PPDU_DESC, dp_wdi_event_handler(WDI_EVENT_RX_PPDU_DESC,
soc, ppdu_nbuf, soc, ppdu_nbuf,
@@ -967,17 +1052,18 @@ dp_rx_ul_ofdma_ru_size_to_width(
} }
static inline void static inline void
dp_rx_mon_handle_ofdma_info(struct hal_rx_ppdu_info *ppdu_info) dp_rx_mon_handle_mu_ul_info(struct hal_rx_ppdu_info *ppdu_info)
{ {
struct mon_rx_user_status *mon_rx_user_status; struct mon_rx_user_status *mon_rx_user_status;
uint32_t num_users; uint32_t num_users;
uint32_t i; uint32_t i;
uint32_t ul_ofdma_user_v0_word0; uint32_t mu_ul_user_v0_word0;
uint32_t ul_ofdma_user_v0_word1; uint32_t mu_ul_user_v0_word1;
uint32_t ru_width; uint32_t ru_width;
uint32_t ru_size; uint32_t ru_size;
if (ppdu_info->rx_status.reception_type != HAL_RX_TYPE_MU_OFDMA) if (!(ppdu_info->rx_status.reception_type == HAL_RX_TYPE_MU_OFDMA ||
ppdu_info->rx_status.reception_type == HAL_RX_TYPE_MU_MIMO))
return; return;
num_users = ppdu_info->com_info.num_users; num_users = ppdu_info->com_info.num_users;
@@ -985,39 +1071,39 @@ dp_rx_mon_handle_ofdma_info(struct hal_rx_ppdu_info *ppdu_info)
num_users = HAL_MAX_UL_MU_USERS; num_users = HAL_MAX_UL_MU_USERS;
for (i = 0; i < num_users; i++) { for (i = 0; i < num_users; i++) {
mon_rx_user_status = &ppdu_info->rx_user_status[i]; mon_rx_user_status = &ppdu_info->rx_user_status[i];
ul_ofdma_user_v0_word0 = mu_ul_user_v0_word0 =
mon_rx_user_status->ul_ofdma_user_v0_word0; mon_rx_user_status->mu_ul_user_v0_word0;
ul_ofdma_user_v0_word1 = mu_ul_user_v0_word1 =
mon_rx_user_status->ul_ofdma_user_v0_word1; mon_rx_user_status->mu_ul_user_v0_word1;
if (HTT_UL_OFDMA_USER_INFO_V0_W0_VALID_GET( if (HTT_UL_OFDMA_USER_INFO_V0_W0_VALID_GET(
ul_ofdma_user_v0_word0) && mu_ul_user_v0_word0) &&
!HTT_UL_OFDMA_USER_INFO_V0_W0_VER_GET( !HTT_UL_OFDMA_USER_INFO_V0_W0_VER_GET(
ul_ofdma_user_v0_word0)) { mu_ul_user_v0_word0)) {
mon_rx_user_status->mcs = mon_rx_user_status->mcs =
HTT_UL_OFDMA_USER_INFO_V0_W1_MCS_GET( HTT_UL_OFDMA_USER_INFO_V0_W1_MCS_GET(
ul_ofdma_user_v0_word1); mu_ul_user_v0_word1);
mon_rx_user_status->nss = mon_rx_user_status->nss =
HTT_UL_OFDMA_USER_INFO_V0_W1_NSS_GET( HTT_UL_OFDMA_USER_INFO_V0_W1_NSS_GET(
ul_ofdma_user_v0_word1) + 1; mu_ul_user_v0_word1) + 1;
mon_rx_user_status->ofdma_info_valid = 1; mon_rx_user_status->mu_ul_info_valid = 1;
mon_rx_user_status->dl_ofdma_ru_start_index = mon_rx_user_status->ofdma_ru_start_index =
HTT_UL_OFDMA_USER_INFO_V0_W1_RU_START_GET( HTT_UL_OFDMA_USER_INFO_V0_W1_RU_START_GET(
ul_ofdma_user_v0_word1); mu_ul_user_v0_word1);
ru_size = ru_size =
HTT_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE_GET( HTT_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE_GET(
ul_ofdma_user_v0_word1); mu_ul_user_v0_word1);
dp_rx_ul_ofdma_ru_size_to_width(ru_size, &ru_width); dp_rx_ul_ofdma_ru_size_to_width(ru_size, &ru_width);
mon_rx_user_status->dl_ofdma_ru_width = ru_width; mon_rx_user_status->ofdma_ru_width = ru_width;
mon_rx_user_status->dl_ofdma_ru_size = ru_size; mon_rx_user_status->ofdma_ru_size = ru_size;
} }
} }
} }
#else #else
static inline void static inline void
dp_rx_mon_handle_ofdma_info(struct hal_rx_ppdu_info *ppdu_info) dp_rx_mon_handle_mu_ul_info(struct hal_rx_ppdu_info *ppdu_info)
{ {
} }
#endif #endif
@@ -1132,7 +1218,7 @@ dp_rx_mon_status_process_tlv(struct dp_soc *soc, uint32_t mac_id,
dp_rx_mon_deliver_non_std(soc, mac_id); dp_rx_mon_deliver_non_std(soc, mac_id);
} else if (tlv_status == HAL_TLV_STATUS_PPDU_DONE) { } else if (tlv_status == HAL_TLV_STATUS_PPDU_DONE) {
rx_mon_stats->status_ppdu_done++; rx_mon_stats->status_ppdu_done++;
dp_rx_mon_handle_ofdma_info(ppdu_info); dp_rx_mon_handle_mu_ul_info(ppdu_info);
if (pdev->enhanced_stats_en || if (pdev->enhanced_stats_en ||
pdev->mcopy_mode || pdev->neighbour_peers_added) pdev->mcopy_mode || pdev->neighbour_peers_added)
dp_rx_handle_ppdu_stats(soc, pdev, ppdu_info); dp_rx_handle_ppdu_stats(soc, pdev, ppdu_info);

185
dp/wifi3.0/dp_stats.c
View File

@@ -56,7 +56,7 @@
#define DP_NSS_LENGTH (6 * SS_COUNT) #define DP_NSS_LENGTH (6 * SS_COUNT)
#define DP_MU_GROUP_LENGTH (6 * DP_MU_GROUP_SHOW) #define DP_MU_GROUP_LENGTH (6 * DP_MU_GROUP_SHOW)
#define DP_MU_GROUP_SHOW 16 #define DP_MU_GROUP_SHOW 16
#define DP_MAX_MCS_STRING_LEN 30 #define DP_MAX_MCS_STRING_LEN 34
#define DP_RXDMA_ERR_LENGTH (6 * HAL_RXDMA_ERR_MAX) #define DP_RXDMA_ERR_LENGTH (6 * HAL_RXDMA_ERR_MAX)
#define DP_REO_ERR_LENGTH (6 * HAL_REO_ERR_MAX) #define DP_REO_ERR_LENGTH (6 * HAL_REO_ERR_MAX)
#define STATS_PROC_TIMEOUT (HZ / 1000) #define STATS_PROC_TIMEOUT (HZ / 1000)
@@ -153,6 +153,61 @@ static const struct dp_rate_debug dp_rate_string[DOT11_MAX][MAX_MCS] = {
} }
}; };
static const struct dp_rate_debug dp_ppdu_rate_string[DOT11_MAX][MAX_MCS] = {
{
{"HE MCS 0 (BPSK 1/2) ", MCS_VALID},
{"HE MCS 1 (QPSK 1/2) ", MCS_VALID},
{"HE MCS 2 (QPSK 3/4) ", MCS_VALID},
{"HE MCS 3 (16-QAM 1/2) ", MCS_VALID},
{"HE MCS 4 (16-QAM 3/4) ", MCS_VALID},
{"HE MCS 5 (64-QAM 2/3) ", MCS_VALID},
{"HE MCS 6 (64-QAM 3/4) ", MCS_VALID},
{"HE MCS 7 (64-QAM 5/6) ", MCS_VALID},
{"HE MCS 8 (256-QAM 3/4) ", MCS_VALID},
{"HE MCS 9 (256-QAM 5/6) ", MCS_VALID},
{"HE MCS 10 (1024-QAM 3/4)", MCS_VALID},
{"HE MCS 11 (1024-QAM 5/6)", MCS_VALID},
{"INVALID ", MCS_VALID},
}
};
static const struct dp_rate_debug dp_mu_rate_string[RX_TYPE_MU_MAX][MAX_MCS] = {
{
{"HE MU-MIMO MCS 0 (BPSK 1/2) ", MCS_VALID},
{"HE MU-MIMO MCS 1 (QPSK 1/2) ", MCS_VALID},
{"HE MU-MIMO MCS 2 (QPSK 3/4) ", MCS_VALID},
{"HE MU-MIMO MCS 3 (16-QAM 1/2) ", MCS_VALID},
{"HE MU-MIMO MCS 4 (16-QAM 3/4) ", MCS_VALID},
{"HE MU-MIMO MCS 5 (64-QAM 2/3) ", MCS_VALID},
{"HE MU-MIMO MCS 6 (64-QAM 3/4) ", MCS_VALID},
{"HE MU-MIMO MCS 7 (64-QAM 5/6) ", MCS_VALID},
{"HE MU-MIMO MCS 8 (256-QAM 3/4) ", MCS_VALID},
{"HE MU-MIMO MCS 9 (256-QAM 5/6) ", MCS_VALID},
{"HE MU-MIMO MCS 10 (1024-QAM 3/4)", MCS_VALID},
{"HE MU-MIMO MCS 11 (1024-QAM 5/6)", MCS_VALID},
{"INVALID ", MCS_VALID},
},
{
{"HE OFDMA MCS 0 (BPSK 1/2) ", MCS_VALID},
{"HE OFDMA MCS 1 (QPSK 1/2) ", MCS_VALID},
{"HE OFDMA MCS 2 (QPSK 3/4) ", MCS_VALID},
{"HE OFDMA MCS 3 (16-QAM 1/2) ", MCS_VALID},
{"HE OFDMA MCS 4 (16-QAM 3/4) ", MCS_VALID},
{"HE OFDMA MCS 5 (64-QAM 2/3) ", MCS_VALID},
{"HE OFDMA MCS 6 (64-QAM 3/4) ", MCS_VALID},
{"HE OFDMA MCS 7 (64-QAM 5/6) ", MCS_VALID},
{"HE OFDMA MCS 8 (256-QAM 3/4) ", MCS_VALID},
{"HE OFDMA MCS 9 (256-QAM 5/6) ", MCS_VALID},
{"HE OFDMA MCS 10 (1024-QAM 3/4)", MCS_VALID},
{"HE OFDMA MCS 11 (1024-QAM 5/6)", MCS_VALID},
{"INVALID ", MCS_VALID},
},
};
const char *mu_reception_mode[RX_TYPE_MU_MAX] = {
"MU MIMO", "MU OFDMA"
};
#ifdef QCA_ENH_V3_STATS_SUPPORT #ifdef QCA_ENH_V3_STATS_SUPPORT
const char *fw_to_hw_delay_bucket[CDP_DELAY_BUCKET_MAX + 1] = { const char *fw_to_hw_delay_bucket[CDP_DELAY_BUCKET_MAX + 1] = {
"0 to 10 ms", "11 to 20 ms", "0 to 10 ms", "11 to 20 ms",
@@ -4790,6 +4845,7 @@ dp_print_common_rates_info(struct cdp_pkt_type *pkt_type_array)
{ {
uint8_t mcs, pkt_type; uint8_t mcs, pkt_type;
DP_PRINT_STATS("MSDU Count");
for (pkt_type = 0; pkt_type < DOT11_MAX; pkt_type++) { for (pkt_type = 0; pkt_type < DOT11_MAX; pkt_type++) {
for (mcs = 0; mcs < MAX_MCS; mcs++) { for (mcs = 0; mcs < MAX_MCS; mcs++) {
if (!dp_rate_string[pkt_type][mcs].valid) if (!dp_rate_string[pkt_type][mcs].valid)
@@ -4804,6 +4860,56 @@ dp_print_common_rates_info(struct cdp_pkt_type *pkt_type_array)
} }
} }
/**
* dp_print_common_ppdu_rates_info(): Print common rate for tx or rx
* @pkt_type_array: rate type array contains rate info
*
* Return:void
*/
static inline void
dp_print_common_ppdu_rates_info(struct cdp_pkt_type *pkt_type_array)
{
uint8_t mcs;
DP_PRINT_STATS("PPDU Count");
for (mcs = 0; mcs < MAX_MCS; mcs++) {
if (!dp_ppdu_rate_string[0][mcs].valid)
continue;
DP_PRINT_STATS(" %s = %d",
dp_ppdu_rate_string[0][mcs].mcs_type,
pkt_type_array->mcs_count[mcs]);
}
DP_PRINT_STATS("\n");
}
/**
* dp_print_mu_ppdu_rates_info(): Print mu rate for tx or rx
* @rx_mu: rx MU stats array
*
* Return:void
*/
static inline void
dp_print_mu_ppdu_rates_info(struct cdp_rx_mu *rx_mu)
{
uint8_t mcs, pkt_type;
DP_PRINT_STATS("PPDU Count");
for (pkt_type = 0; pkt_type < RX_TYPE_MU_MAX; pkt_type++) {
for (mcs = 0; mcs < MAX_MCS; mcs++) {
if (!dp_mu_rate_string[pkt_type][mcs].valid)
continue;
DP_PRINT_STATS(" %s = %d",
dp_mu_rate_string[pkt_type][mcs].mcs_type,
rx_mu[pkt_type].ppdu.mcs_count[mcs]);
}
DP_PRINT_STATS("\n");
}
}
void dp_print_rx_rates(struct dp_vdev *vdev) void dp_print_rx_rates(struct dp_vdev *vdev)
{ {
struct dp_pdev *pdev = (struct dp_pdev *)vdev->pdev; struct dp_pdev *pdev = (struct dp_pdev *)vdev->pdev;
@@ -4881,6 +4987,26 @@ void dp_print_tx_rates(struct dp_vdev *vdev)
pdev->stats.tx.non_amsdu_cnt); pdev->stats.tx.non_amsdu_cnt);
} }
/**
* dp_print_nss(): Print nss count
* @nss: printable nss count array
* @pnss: nss count array
* @ss_count: number of nss
*
* Return:void
*/
static void dp_print_nss(char *nss, uint32_t *pnss, uint32_t ss_count)
{
uint32_t index;
uint8_t i;
index = 0;
for (i = 0; i < ss_count; i++) {
index += qdf_snprint(&nss[index], DP_NSS_LENGTH - index,
" %d", *(pnss + i));
}
}
void dp_print_peer_stats(struct dp_peer *peer) void dp_print_peer_stats(struct dp_peer *peer)
{ {
uint8_t i; uint8_t i;
@@ -4889,6 +5015,9 @@ void dp_print_peer_stats(struct dp_peer *peer)
char nss[DP_NSS_LENGTH]; char nss[DP_NSS_LENGTH];
char mu_group_id[DP_MU_GROUP_LENGTH]; char mu_group_id[DP_MU_GROUP_LENGTH];
struct dp_pdev *pdev; struct dp_pdev *pdev;
uint32_t *pnss;
enum cdp_mu_packet_type rx_mu_type;
struct cdp_rx_mu *rx_mu;
pdev = peer->vdev->pdev; pdev = peer->vdev->pdev;
@@ -4972,11 +5101,9 @@ void dp_print_peer_stats(struct dp_peer *peer)
peer->stats.tx.bw[0], peer->stats.tx.bw[1], peer->stats.tx.bw[0], peer->stats.tx.bw[1],
peer->stats.tx.bw[2], peer->stats.tx.bw[3]); peer->stats.tx.bw[2], peer->stats.tx.bw[3]);
index = 0; pnss = &peer->stats.tx.nss[0];
for (i = 0; i < SS_COUNT; i++) { dp_print_nss(nss, pnss, SS_COUNT);
index += qdf_snprint(&nss[index], DP_NSS_LENGTH - index,
" %d", peer->stats.tx.nss[i]);
}
DP_PRINT_STATS("NSS(1-8) = %s", nss); DP_PRINT_STATS("NSS(1-8) = %s", nss);
DP_PRINT_STATS("Transmit Type :"); DP_PRINT_STATS("Transmit Type :");
@@ -5080,21 +5207,53 @@ void dp_print_peer_stats(struct dp_peer *peer)
DP_PRINT_STATS("BW Counts = 20MHZ %d 40MHZ %d 80MHZ %d 160MHZ %d", DP_PRINT_STATS("BW Counts = 20MHZ %d 40MHZ %d 80MHZ %d 160MHZ %d",
peer->stats.rx.bw[0], peer->stats.rx.bw[1], peer->stats.rx.bw[0], peer->stats.rx.bw[1],
peer->stats.rx.bw[2], peer->stats.rx.bw[3]); peer->stats.rx.bw[2], peer->stats.rx.bw[3]);
DP_PRINT_STATS("Reception Type = SU %d MU_MIMO %d MU_OFDMA %d MU_OFDMA_MIMO %d", DP_PRINT_STATS("MSDU Reception Type");
DP_PRINT_STATS("SU %d MU_MIMO %d MU_OFDMA %d MU_OFDMA_MIMO %d",
peer->stats.rx.reception_type[0], peer->stats.rx.reception_type[0],
peer->stats.rx.reception_type[1], peer->stats.rx.reception_type[1],
peer->stats.rx.reception_type[2], peer->stats.rx.reception_type[2],
peer->stats.rx.reception_type[3]); peer->stats.rx.reception_type[3]);
DP_PRINT_STATS("PPDU Reception Type");
DP_PRINT_STATS("SU %d MU_MIMO %d MU_OFDMA %d MU_OFDMA_MIMO %d",
peer->stats.rx.ppdu_cnt[0],
peer->stats.rx.ppdu_cnt[1],
peer->stats.rx.ppdu_cnt[2],
peer->stats.rx.ppdu_cnt[3]);
dp_print_common_rates_info(peer->stats.rx.pkt_type); dp_print_common_rates_info(peer->stats.rx.pkt_type);
dp_print_common_ppdu_rates_info(&peer->stats.rx.su_ax_ppdu_cnt);
dp_print_mu_ppdu_rates_info(&peer->stats.rx.rx_mu[0]);
index = 0; pnss = &peer->stats.rx.nss[0];
for (i = 0; i < SS_COUNT; i++) { dp_print_nss(nss, pnss, SS_COUNT);
index += qdf_snprint(&nss[index], DP_NSS_LENGTH - index, DP_PRINT_STATS("MSDU Count");
" %d", peer->stats.rx.nss[i]); DP_PRINT_STATS(" NSS(1-8) = %s", nss);
DP_PRINT_STATS("reception mode SU");
pnss = &peer->stats.rx.ppdu_nss[0];
dp_print_nss(nss, pnss, SS_COUNT);
DP_PRINT_STATS(" PPDU Count");
DP_PRINT_STATS(" NSS(1-8) = %s", nss);
DP_PRINT_STATS(" MPDU OK = %d, MPDU Fail = %d",
peer->stats.rx.mpdu_cnt_fcs_ok,
peer->stats.rx.mpdu_cnt_fcs_err);
for (rx_mu_type = 0; rx_mu_type < RX_TYPE_MU_MAX; rx_mu_type++) {
DP_PRINT_STATS("reception mode %s",
mu_reception_mode[rx_mu_type]);
rx_mu = &peer->stats.rx.rx_mu[rx_mu_type];
pnss = &rx_mu->ppdu_nss[0];
dp_print_nss(nss, pnss, SS_COUNT);
DP_PRINT_STATS(" PPDU Count");
DP_PRINT_STATS(" NSS(1-8) = %s", nss);
DP_PRINT_STATS(" MPDU OK = %d, MPDU Fail = %d",
rx_mu->mpdu_cnt_fcs_ok,
rx_mu->mpdu_cnt_fcs_err);
} }
DP_PRINT_STATS("NSS(1-8) = %s",
nss);
DP_PRINT_STATS("Aggregation:"); DP_PRINT_STATS("Aggregation:");
DP_PRINT_STATS(" Msdu's Part of Ampdu = %d", DP_PRINT_STATS(" Msdu's Part of Ampdu = %d",

10
hal/wifi3.0/hal_generic_api.h
View File

@@ -219,15 +219,15 @@ hal_rx_handle_other_tlvs(uint32_t tlv_tag, void *rx_tlv,
defined(RX_PPDU_END_USER_STATS_22_SW_RESPONSE_REFERENCE_PTR_EXT_OFFSET) defined(RX_PPDU_END_USER_STATS_22_SW_RESPONSE_REFERENCE_PTR_EXT_OFFSET)
static inline void static inline void
hal_rx_handle_ofdma_info( hal_rx_handle_mu_ul_info(
void *rx_tlv, void *rx_tlv,
struct mon_rx_user_status *mon_rx_user_status) struct mon_rx_user_status *mon_rx_user_status)
{ {
mon_rx_user_status->ul_ofdma_user_v0_word0 = mon_rx_user_status->mu_ul_user_v0_word0 =
HAL_RX_GET(rx_tlv, RX_PPDU_END_USER_STATS_11, HAL_RX_GET(rx_tlv, RX_PPDU_END_USER_STATS_11,
SW_RESPONSE_REFERENCE_PTR); SW_RESPONSE_REFERENCE_PTR);
mon_rx_user_status->ul_ofdma_user_v0_word1 = mon_rx_user_status->mu_ul_user_v0_word1 =
HAL_RX_GET(rx_tlv, RX_PPDU_END_USER_STATS_22, HAL_RX_GET(rx_tlv, RX_PPDU_END_USER_STATS_22,
SW_RESPONSE_REFERENCE_PTR_EXT); SW_RESPONSE_REFERENCE_PTR_EXT);
} }
@@ -251,7 +251,7 @@ hal_rx_populate_byte_count(void *rx_tlv, void *ppduinfo,
} }
#else #else
static inline void static inline void
hal_rx_handle_ofdma_info(void *rx_tlv, hal_rx_handle_mu_ul_info(void *rx_tlv,
struct mon_rx_user_status *mon_rx_user_status) struct mon_rx_user_status *mon_rx_user_status)
{ {
} }
@@ -546,7 +546,7 @@ hal_rx_status_get_tlv_info_generic(void *rx_tlv_hdr, void *ppduinfo,
mon_rx_user_status = mon_rx_user_status =
&ppdu_info->rx_user_status[user_id]; &ppdu_info->rx_user_status[user_id];
hal_rx_handle_ofdma_info(rx_tlv, mon_rx_user_status); hal_rx_handle_mu_ul_info(rx_tlv, mon_rx_user_status);
ppdu_info->com_info.num_users++; ppdu_info->com_info.num_users++;

21
qdf/inc/qdf_nbuf.h
View File

@@ -328,9 +328,12 @@ struct mon_rx_status {
* extracted from hardware TLV. * extracted from hardware TLV.
* @mcs: MCS index of Rx frame * @mcs: MCS index of Rx frame
* @nss: Number of spatial streams * @nss: Number of spatial streams
* @ofdma_info_valid: OFDMA info below is valid * @mu_ul_info_valid: MU UL info below is valid
* @dl_ofdma_ru_start_index: OFDMA RU start index * @ofdma_ru_start_index: OFDMA RU start index
* @dl_ofdma_ru_width: OFDMA total RU width * @ofdma_ru_width: OFDMA total RU width
* @ofdma_ru_size: OFDMA RU size index
* @mu_ul_user_v0_word0: MU UL user info word 0
* @mu_ul_user_v0_word1: MU UL user info word 1
* @ast_index: AST table hash index * @ast_index: AST table hash index
* @tid: QoS traffic tid number * @tid: QoS traffic tid number
* @tcp_msdu_count: tcp protocol msdu count * @tcp_msdu_count: tcp protocol msdu count
@@ -355,12 +358,12 @@ struct mon_rx_status {
struct mon_rx_user_status { struct mon_rx_user_status {
uint32_t mcs:4, uint32_t mcs:4,
nss:3, nss:3,
ofdma_info_valid:1, mu_ul_info_valid:1,
dl_ofdma_ru_start_index:7, ofdma_ru_start_index:7,
dl_ofdma_ru_width:7, ofdma_ru_width:7,
dl_ofdma_ru_size:8; ofdma_ru_size:8;
uint32_t ul_ofdma_user_v0_word0; uint32_t mu_ul_user_v0_word0;
uint32_t ul_ofdma_user_v0_word1; uint32_t mu_ul_user_v0_word1;
uint32_t ast_index; uint32_t ast_index;
uint32_t tid; uint32_t tid;
uint16_t tcp_msdu_count; uint16_t tcp_msdu_count;