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

qcacmn: Update stats in monitor peer in Tx HTT and Rx monitor path

Browse Source 
Update stats in monitor peer in Tx HTT PPDU completion and
Rx monitor PPDU indication path.

Change-Id: Icfeb49fc6f1fa2c1f2648a9b4576f31a927c7ecd
CRs-Fixed: 3092123
This commit is contained in:
Harsh Kumar Bijlani
2021-11-02 14:01:40 +05:30
committed by Madan Koyyalamudi
parent 93cd9e0af8
commit ce45e71913
6 changed files with 237 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
dp/wifi3.0/monitor/2.0/dp_mon_2.0.c
View File

@@ -383,7 +383,7 @@ QDF_STATUS dp_vdev_set_monitor_mode_rings_2_0(struct dp_pdev *pdev,
#if defined(QCA_ENHANCED_STATS_SUPPORT) && defined(WLAN_FEATURE_11BE)
void
dp_mon_tx_stats_update_2_0(struct dp_peer *peer,
dp_mon_tx_stats_update_2_0(struct dp_mon_peer *mon_peer,
struct cdp_tx_completion_ppdu_user *ppdu)
{
uint8_t preamble;
@@ -392,38 +392,38 @@ dp_mon_tx_stats_update_2_0(struct dp_peer *peer,
preamble = ppdu->preamble;
mcs = ppdu->mcs;
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1],
ppdu->num_msdu,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_BE)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs],
ppdu->num_msdu,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_BE)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.su_be_ppdu_cnt.mcs_count[MAX_MCS - 1], 1,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_BE) &&
(ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_SU)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.su_be_ppdu_cnt.mcs_count[mcs], 1,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_BE) &&
(ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_SU)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
@@ -433,7 +433,7 @@ dp_mon_tx_stats_update_2_0(struct dp_peer *peer,
#if defined(QCA_ENHANCED_STATS_SUPPORT) && !defined(WLAN_FEATURE_11BE)
void
dp_mon_tx_stats_update_2_0(struct dp_peer *peer,
dp_mon_tx_stats_update_2_0(struct dp_mon_peer *mon_peer,
struct cdp_tx_completion_ppdu_user *ppdu)
{
}

28
dp/wifi3.0/monitor/2.0/dp_rx_mon_2.0.c
View File

@@ -230,7 +230,7 @@ dp_rx_mon_populate_ppdu_usr_info_2_0(struct mon_rx_user_status *rx_user_status,
}
#ifdef WLAN_FEATURE_11BE
void dp_rx_mon_stats_update_2_0(struct dp_peer *peer,
void dp_rx_mon_stats_update_2_0(struct dp_mon_peer *mon_peer,
struct cdp_rx_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user)
{
@@ -243,32 +243,32 @@ void dp_rx_mon_stats_update_2_0(struct dp_peer *peer,
else
mcs = ppdu_user->mcs;
DP_STATS_INC(peer, rx.mpdu_retry_cnt, ppdu_user->mpdu_retries);
DP_STATS_INCC(peer,
DP_STATS_INC(mon_peer, rx.mpdu_retry_cnt, ppdu_user->mpdu_retries);
DP_STATS_INCC(mon_peer,
rx.su_be_ppdu_cnt.mcs_count[MAX_MCS - 1], 1,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.su_be_ppdu_cnt.mcs_count[mcs], 1,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer,
rx.rx_mu_be[TXRX_TYPE_MU_OFDMA].mcs_count[MAX_MCS - 1],
DP_STATS_INCC(mon_peer,
rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer,
rx.rx_mu_be[TXRX_TYPE_MU_OFDMA].mcs_count[mcs],
DP_STATS_INCC(mon_peer,
rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer,
rx.rx_mu_be[TXRX_TYPE_MU_MIMO].mcs_count[MAX_MCS - 1],
DP_STATS_INCC(mon_peer,
rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO)));
DP_STATS_INCC(peer,
rx.rx_mu_be[TXRX_TYPE_MU_MIMO].mcs_count[mcs],
DP_STATS_INCC(mon_peer,
rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO)));
@@ -281,11 +281,11 @@ dp_rx_mon_populate_ppdu_info_2_0(struct hal_rx_ppdu_info *hal_ppdu_info,
ppdu->punc_bw = hal_ppdu_info->rx_status.punctured_bw;
}
#else
void dp_rx_mon_stats_update_2_0(struct dp_peer *peer,
void dp_rx_mon_stats_update_2_0(struct dp_mon_peer *mon_peer,
struct cdp_rx_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user)
{
DP_STATS_INC(peer, rx.mpdu_retry_cnt, ppdu_user->mpdu_retries);
DP_STATS_INC(mon_peer, rx.mpdu_retry_cnt, ppdu_user->mpdu_retries);
}
void

4
dp/wifi3.0/monitor/2.0/dp_rx_mon_2.0.h
View File

@@ -90,13 +90,13 @@ void dp_rx_mon_process_status_tlv(struct dp_soc *soc,
/**
* dp_rx_mon_stats_update_2_0 () - update rx stats
*
* @peer: peer handle
* @peer: monitor peer handle
* @ppdu: Rx PPDU status metadata object
* @ppdu_user: Rx PPDU user status metadata object
*
* Return: Void
*/
void dp_rx_mon_stats_update_2_0(struct dp_peer *peer,
void dp_rx_mon_stats_update_2_0(struct dp_mon_peer *mon_peer,
struct cdp_rx_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user);

188
dp/wifi3.0/monitor/dp_mon.c
View File

@@ -1084,34 +1084,49 @@ void dp_pktlogmod_exit(struct dp_pdev *pdev)
}
#endif /*DP_CON_MON*/
#ifdef WDI_EVENT_ENABLE
#if defined(WDI_EVENT_ENABLE) && defined(QCA_ENHANCED_STATS_SUPPORT)
QDF_STATUS dp_peer_stats_notify(struct dp_pdev *dp_pdev, struct dp_peer *peer)
{
struct cdp_interface_peer_stats peer_stats_intf;
struct cdp_peer_stats *peer_stats = &peer->stats;
struct dp_mon_peer_stats *mon_peer_stats = NULL;
struct dp_peer *tgt_peer = NULL;
struct dp_txrx_peer *txrx_peer = NULL;
if (!peer->vdev)
if (!peer || !peer->vdev || !peer->monitor_peer)
return QDF_STATUS_E_FAULT;
tgt_peer = dp_get_tgt_peer_from_peer(peer);
if (!tgt_peer)
return QDF_STATUS_E_FAULT;
txrx_peer = tgt_peer->txrx_peer;
if (!txrx_peer)
return QDF_STATUS_E_FAULT;
mon_peer_stats = &peer->monitor_peer->stats;
qdf_mem_zero(&peer_stats_intf, sizeof(peer_stats_intf));
if (peer_stats->rx.last_snr != peer_stats->rx.snr)
if (mon_peer_stats->rx.last_snr != mon_peer_stats->rx.snr)
peer_stats_intf.rssi_changed = true;
if ((peer_stats->rx.snr && peer_stats_intf.rssi_changed) ||
(peer_stats->tx.tx_rate &&
peer_stats->tx.tx_rate != peer_stats->tx.last_tx_rate)) {
if ((mon_peer_stats->rx.snr && peer_stats_intf.rssi_changed) ||
(mon_peer_stats->tx.tx_rate &&
mon_peer_stats->tx.tx_rate != mon_peer_stats->tx.last_tx_rate)) {
qdf_mem_copy(peer_stats_intf.peer_mac, peer->mac_addr.raw,
QDF_MAC_ADDR_SIZE);
peer_stats_intf.vdev_id = peer->vdev->vdev_id;
peer_stats_intf.last_peer_tx_rate = peer_stats->tx.last_tx_rate;
peer_stats_intf.peer_tx_rate = peer_stats->tx.tx_rate;
peer_stats_intf.peer_rssi = peer_stats->rx.snr;
peer_stats_intf.tx_packet_count = peer_stats->tx.ucast.num;
peer_stats_intf.rx_packet_count = peer_stats->rx.to_stack.num;
peer_stats_intf.tx_byte_count = peer_stats->tx.tx_success.bytes;
peer_stats_intf.rx_byte_count = peer_stats->rx.to_stack.bytes;
peer_stats_intf.per = peer_stats->tx.last_per;
peer_stats_intf.ack_rssi = peer_stats->tx.last_ack_rssi;
peer_stats_intf.last_peer_tx_rate =
mon_peer_stats->tx.last_tx_rate;
peer_stats_intf.peer_tx_rate = mon_peer_stats->tx.tx_rate;
peer_stats_intf.peer_rssi = mon_peer_stats->rx.snr;
peer_stats_intf.ack_rssi = mon_peer_stats->tx.last_ack_rssi;
peer_stats_intf.rx_packet_count = txrx_peer->to_stack.num;
peer_stats_intf.rx_byte_count = txrx_peer->to_stack.bytes;
peer_stats_intf.tx_packet_count =
txrx_peer->stats.per_pkt_stats.tx.ucast.num;
peer_stats_intf.tx_byte_count =
txrx_peer->stats.per_pkt_stats.tx.tx_success.bytes;
peer_stats_intf.per = tgt_peer->stats.tx.last_per;
peer_stats_intf.free_buff = INVALID_FREE_BUFF;
dp_wdi_event_handler(WDI_EVENT_PEER_STATS, dp_pdev->soc,
(void *)&peer_stats_intf, 0,
@@ -2283,6 +2298,7 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
uint32_t rix;
uint16_t ratecode = 0;
enum PUNCTURED_MODES punc_mode = NO_PUNCTURE;
struct dp_mon_peer *mon_peer = NULL;
if (!peer || !ppdu)
return;
@@ -2290,6 +2306,10 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK)
return;
mon_peer = peer->monitor_peer;
if (!mon_peer)
return;
ratekbps = dp_getrateindex(ppdu->gi,
ppdu->mcs,
ppdu->nss,
@@ -2299,7 +2319,7 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
&rix,
&ratecode);
DP_STATS_UPD(peer, tx.last_tx_rate, ratekbps);
DP_STATS_UPD(mon_peer, tx.last_tx_rate, ratekbps);
if (!ratekbps)
return;
@@ -2315,16 +2335,16 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
ppdu->rix = rix;
ppdu->tx_ratekbps = ratekbps;
ppdu->tx_ratecode = ratecode;
peer->stats.tx.avg_tx_rate =
dp_ath_rate_lpf(peer->stats.tx.avg_tx_rate, ratekbps);
ppdu_tx_rate = dp_ath_rate_out(peer->stats.tx.avg_tx_rate);
DP_STATS_UPD(peer, tx.rnd_avg_tx_rate, ppdu_tx_rate);
mon_peer->stats.tx.avg_tx_rate =
dp_ath_rate_lpf(mon_peer->stats.tx.avg_tx_rate, ratekbps);
ppdu_tx_rate = dp_ath_rate_out(mon_peer->stats.tx.avg_tx_rate);
DP_STATS_UPD(mon_peer, tx.rnd_avg_tx_rate, ppdu_tx_rate);
peer->stats.tx.bw_info = ppdu->bw;
peer->stats.tx.gi_info = ppdu->gi;
peer->stats.tx.nss_info = ppdu->nss;
peer->stats.tx.mcs_info = ppdu->mcs;
peer->stats.tx.preamble_info = ppdu->preamble;
mon_peer->stats.tx.bw_info = ppdu->bw;
mon_peer->stats.tx.gi_info = ppdu->gi;
mon_peer->stats.tx.nss_info = ppdu->nss;
mon_peer->stats.tx.mcs_info = ppdu->mcs;
mon_peer->stats.tx.preamble_info = ppdu->preamble;
if (peer->vdev) {
/*
* In STA mode:
@@ -2345,19 +2365,31 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
}
#if defined(FEATURE_PERPKT_INFO) && defined(WDI_EVENT_ENABLE)
static inline void dp_send_stats_event(struct dp_pdev *pdev,
struct dp_peer *peer,
u_int16_t peer_id)
void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
uint16_t peer_id)
{
dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
&peer->stats, peer_id,
UPDATE_PEER_STATS, pdev->pdev_id);
struct cdp_interface_peer_stats peer_stats_intf;
struct dp_mon_peer *mon_peer = peer->monitor_peer;
struct dp_txrx_peer *txrx_peer = NULL;
if (!mon_peer)
return;
qdf_mem_zero(&peer_stats_intf,
sizeof(struct cdp_interface_peer_stats));
mon_peer->stats.rx.rx_snr_measured_time = qdf_system_ticks();
peer_stats_intf.rx_avg_snr = mon_peer->stats.rx.avg_snr;
txrx_peer = dp_get_txrx_peer(peer);
if (txrx_peer) {
peer_stats_intf.rx_byte_count = txrx_peer->to_stack.bytes;
peer_stats_intf.tx_byte_count =
txrx_peer->stats.per_pkt_stats.tx.tx_success.bytes;
}
#else
static inline void dp_send_stats_event(struct dp_pdev *pdev,
struct dp_peer *peer,
u_int16_t peer_id)
{
dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
&peer_stats_intf, peer_id,
UPDATE_PEER_STATS, pdev->pdev_id);
}
#endif
@@ -2482,6 +2514,7 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
uint16_t mpdu_failed;
struct dp_mon_ops *mon_ops;
enum cdp_ru_index ru_index;
struct dp_mon_peer *mon_peer = NULL;
preamble = ppdu->preamble;
mcs = ppdu->mcs;
@@ -2497,6 +2530,10 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
if (pdev->soc->process_tx_status)
return;
mon_peer = peer->monitor_peer;
if (!mon_peer)
return;
if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK) {
/*
* All failed mpdu will be retried, so incrementing
@@ -2504,13 +2541,12 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
* ack failure i.e for long retries we get
* mpdu failed equal mpdu tried.
*/
DP_STATS_INC(peer, tx.retries, mpdu_failed);
DP_STATS_INC(peer, tx.tx_failed, ppdu->failed_msdus);
DP_STATS_INC(mon_peer, tx.retries, mpdu_failed);
return;
}
if (ppdu->is_ppdu_cookie_valid)
DP_STATS_INC(peer, tx.num_ppdu_cookie_valid, 1);
DP_STATS_INC(mon_peer, tx.num_ppdu_cookie_valid, 1);
if (ppdu->mu_group_id <= MAX_MU_GROUP_ID &&
ppdu->ppdu_type != HTT_PPDU_STATS_PPDU_TYPE_SU) {
@@ -2518,21 +2554,21 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"mu_group_id out of bound!!\n");
else
DP_STATS_UPD(peer, tx.mu_group_id[ppdu->mu_group_id],
DP_STATS_UPD(mon_peer, tx.mu_group_id[ppdu->mu_group_id],
(ppdu->user_pos + 1));
}
if (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA ||
ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO_OFDMA) {
DP_STATS_UPD(peer, tx.ru_tones, ppdu->ru_tones);
DP_STATS_UPD(peer, tx.ru_start, ppdu->ru_start);
DP_STATS_UPD(mon_peer, tx.ru_tones, ppdu->ru_tones);
DP_STATS_UPD(mon_peer, tx.ru_start, ppdu->ru_start);
ru_index = dp_get_ru_index_frm_ru_tones(ppdu->ru_tones);
if (ru_index != RU_INDEX_MAX) {
DP_STATS_INC(peer, tx.ru_loc[ru_index].num_msdu,
DP_STATS_INC(mon_peer, tx.ru_loc[ru_index].num_msdu,
num_msdu);
DP_STATS_INC(peer, tx.ru_loc[ru_index].num_mpdu,
DP_STATS_INC(mon_peer, tx.ru_loc[ru_index].num_mpdu,
num_mpdu);
DP_STATS_INC(peer, tx.ru_loc[ru_index].mpdu_tried,
DP_STATS_INC(mon_peer, tx.ru_loc[ru_index].mpdu_tried,
mpdu_tried);
}
}
@@ -2543,65 +2579,67 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
* ack failure i.e for long retries we get
* mpdu failed equal mpdu tried.
*/
DP_STATS_INC(peer, tx.retries, mpdu_failed);
DP_STATS_INC(peer, tx.tx_failed, ppdu->failed_msdus);
DP_STATS_INC(mon_peer, tx.retries, mpdu_failed);
DP_STATS_INC(peer, tx.transmit_type[ppdu->ppdu_type].num_msdu,
DP_STATS_INC(mon_peer, tx.transmit_type[ppdu->ppdu_type].num_msdu,
num_msdu);
DP_STATS_INC(peer, tx.transmit_type[ppdu->ppdu_type].num_mpdu,
DP_STATS_INC(mon_peer, tx.transmit_type[ppdu->ppdu_type].num_mpdu,
num_mpdu);
DP_STATS_INC(peer, tx.transmit_type[ppdu->ppdu_type].mpdu_tried,
DP_STATS_INC(mon_peer, tx.transmit_type[ppdu->ppdu_type].mpdu_tried,
mpdu_tried);
DP_STATS_UPD(peer, tx.tx_rate, ppdu->tx_rate);
DP_STATS_INC(peer, tx.sgi_count[ppdu->gi], num_msdu);
DP_STATS_INC(peer, tx.bw[ppdu->bw], num_msdu);
DP_STATS_INC(peer, tx.nss[ppdu->nss], num_msdu);
DP_STATS_UPD(mon_peer, tx.tx_rate, ppdu->tx_rate);
DP_STATS_INC(mon_peer, tx.sgi_count[ppdu->gi], num_msdu);
DP_STATS_INC(mon_peer, tx.bw[ppdu->bw], num_msdu);
DP_STATS_INC(mon_peer, tx.nss[ppdu->nss], num_msdu);
if (ppdu->tid < CDP_DATA_TID_MAX)
DP_STATS_INC(peer, tx.wme_ac_type[TID_TO_WME_AC(ppdu->tid)],
DP_STATS_INC(mon_peer, tx.wme_ac_type[TID_TO_WME_AC(ppdu->tid)],
num_msdu);
DP_STATS_INCC(peer, tx.stbc, num_msdu, ppdu->stbc);
DP_STATS_INCC(peer, tx.ldpc, num_msdu, ppdu->ldpc);
DP_STATS_INCC(mon_peer, tx.stbc, num_msdu, ppdu->stbc);
DP_STATS_INCC(mon_peer, tx.ldpc, num_msdu, ppdu->ldpc);
if (!(ppdu->is_mcast) && ppdu->ack_rssi_valid)
DP_STATS_UPD(peer, tx.last_ack_rssi, ack_rssi);
DP_STATS_UPD(mon_peer, tx.last_ack_rssi, ack_rssi);
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11A) && (preamble == DOT11_A)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11A) && (preamble == DOT11_A)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11B) && (preamble == DOT11_B)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < (MAX_MCS_11B)) && (preamble == DOT11_B)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11A) && (preamble == DOT11_N)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11A) && (preamble == DOT11_N)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX)));
DP_STATS_INCC(peer, tx.ampdu_cnt, num_mpdu, ppdu->is_ampdu);
DP_STATS_INCC(peer, tx.non_ampdu_cnt, num_mpdu, !(ppdu->is_ampdu));
DP_STATS_INCC(peer, tx.pream_punct_cnt, 1, ppdu->pream_punct);
DP_STATS_INCC(mon_peer, tx.ampdu_cnt, num_mpdu, ppdu->is_ampdu);
DP_STATS_INCC(mon_peer, tx.non_ampdu_cnt, num_mpdu, !(ppdu->is_ampdu));
DP_STATS_INCC(mon_peer, tx.pream_punct_cnt, 1, ppdu->pream_punct);
DP_STATS_INC(mon_peer, tx.tx_ppdus, 1);
DP_STATS_INC(mon_peer, tx.tx_mpdus_success, num_mpdu);
DP_STATS_INC(mon_peer, tx.tx_mpdus_tried, mpdu_tried);
mon_ops = dp_mon_ops_get(pdev->soc);
if (mon_ops && mon_ops->mon_tx_stats_update)
mon_ops->mon_tx_stats_update(peer, ppdu);
mon_ops->mon_tx_stats_update(mon_peer, ppdu);
dp_peer_stats_notify(pdev, peer);
@@ -3413,6 +3451,7 @@ dp_process_ppdu_stats_user_compltn_flush_tlv(struct dp_pdev *pdev,
uint8_t tid;
struct dp_peer *peer;
struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
struct dp_mon_peer *mon_peer = NULL;
ppdu_desc = (struct cdp_tx_completion_ppdu *)
qdf_nbuf_data(ppdu_info->nbuf);
@@ -3443,7 +3482,8 @@ dp_process_ppdu_stats_user_compltn_flush_tlv(struct dp_pdev *pdev,
goto add_ppdu_to_sched_list;
if (ppdu_desc->drop_reason == HTT_FLUSH_EXCESS_RETRIES) {
DP_STATS_INC(peer,
mon_peer = peer->monitor_peer;
DP_STATS_INC(mon_peer,
tx.excess_retries_per_ac[TID_TO_WME_AC(tid)],
ppdu_desc->num_msdu);
}

17
dp/wifi3.0/monitor/dp_mon.h
View File

@@ -586,7 +586,7 @@ struct dp_mon_ops {
#ifdef QCA_ENHANCED_STATS_SUPPORT
void (*mon_filter_setup_enhanced_stats)(struct dp_pdev *pdev);
void (*mon_filter_reset_enhanced_stats)(struct dp_pdev *pdev);
void (*mon_tx_stats_update)(struct dp_peer *peer,
void (*mon_tx_stats_update)(struct dp_mon_peer *mon_peer,
struct cdp_tx_completion_ppdu_user *ppdu);
#endif
#ifdef QCA_MCOPY_SUPPORT
@@ -648,7 +648,7 @@ struct dp_mon_ops {
#endif
void (*mon_register_feature_ops)(struct dp_soc *soc);
#ifdef QCA_ENHANCED_STATS_SUPPORT
void (*mon_rx_stats_update)(struct dp_peer *peer,
void (*mon_rx_stats_update)(struct dp_mon_peer *mon_peer,
struct cdp_rx_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user);
void (*mon_rx_populate_ppdu_usr_info)(struct mon_rx_user_status *rx_user_status,
@@ -1053,7 +1053,7 @@ dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn)
}
#endif
#ifdef WDI_EVENT_ENABLE
#if defined(WDI_EVENT_ENABLE) && defined(QCA_ENHANCED_STATS_SUPPORT)
QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev, struct dp_peer *peer);
#else
static inline QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev,
@@ -1063,6 +1063,17 @@ static inline QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev,
}
#endif
#if defined(FEATURE_PERPKT_INFO) && defined(WDI_EVENT_ENABLE)
void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
uint16_t peer_id);
#else
static inline
void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
uint16_t peer_id)
{
}
#endif
#ifndef WLAN_TX_PKT_CAPTURE_ENH
/**
* dp_tx_ppdu_stats_process - Deferred PPDU stats handler

137
dp/wifi3.0/monitor/dp_rx_mon.c
View File

@@ -647,12 +647,17 @@ static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
uint16_t ratecode = 0;
struct cdp_rx_stats_ppdu_user *ppdu_user = NULL;
enum PUNCTURED_MODES punc_mode = NO_PUNCTURE;
struct dp_mon_peer *mon_peer = NULL;
if (!peer || !ppdu)
return;
mon_peer = peer->monitor_peer;
ppdu_user = &ppdu->user[user];
if (!mon_peer)
return;
if (ppdu->u.ppdu_type != HAL_RX_TYPE_SU) {
if (ppdu_user->nss == 0)
nss = 0;
@@ -660,12 +665,17 @@ static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
nss = ppdu_user->nss - 1;
mcs = ppdu_user->mcs;
mon_peer->stats.rx.nss_info = ppdu_user->nss;
mon_peer->stats.rx.mcs_info = ppdu_user->mcs;
} else {
if (ppdu->u.nss == 0)
nss = 0;
else
nss = ppdu->u.nss - 1;
mcs = ppdu->u.mcs;
mon_peer->stats.rx.nss_info = ppdu->u.nss;
mon_peer->stats.rx.mcs_info = ppdu->u.mcs;
}
ratekbps = dp_getrateindex(ppdu->u.gi,
@@ -685,12 +695,16 @@ static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
return;
}
mon_peer->stats.rx.bw_info = ppdu->u.bw;
mon_peer->stats.rx.gi_info = ppdu->u.gi;
mon_peer->stats.rx.preamble_info = ppdu->u.preamble;
ppdu->rix = rix;
DP_STATS_UPD(peer, rx.last_rx_rate, ratekbps);
peer->stats.rx.avg_rx_rate =
dp_ath_rate_lpf(peer->stats.rx.avg_rx_rate, ratekbps);
ppdu_rx_rate = dp_ath_rate_out(peer->stats.rx.avg_rx_rate);
DP_STATS_UPD(peer, rx.rnd_avg_rx_rate, ppdu_rx_rate);
DP_STATS_UPD(mon_peer, rx.last_rx_rate, ratekbps);
mon_peer->stats.rx.avg_rx_rate =
dp_ath_rate_lpf(mon_peer->stats.rx.avg_rx_rate, ratekbps);
ppdu_rx_rate = dp_ath_rate_out(mon_peer->stats.rx.avg_rx_rate);
DP_STATS_UPD(mon_peer, rx.rnd_avg_rx_rate, ppdu_rx_rate);
ppdu->rx_ratekbps = ratekbps;
ppdu->rx_ratecode = ratecode;
ppdu_user->rx_ratekbps = ratekbps;
@@ -766,10 +780,12 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
uint16_t num_msdu;
uint8_t pkt_bw_offset;
struct dp_peer *peer;
struct dp_mon_peer *mon_peer;
struct cdp_rx_stats_ppdu_user *ppdu_user;
uint32_t i;
enum cdp_mu_packet_type mu_pkt_type;
struct dp_mon_ops *mon_ops;
struct dp_mon_pdev *mon_pdev = NULL;
if (pdev)
soc = pdev->soc;
@@ -779,6 +795,8 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
if (!soc || soc->process_rx_status)
return;
mon_pdev = pdev->monitor_pdev;
preamble = ppdu->u.preamble;
ppdu_type = ppdu->u.ppdu_type;
@@ -789,7 +807,17 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
DP_MOD_ID_RX_PPDU_STATS);
if (!peer)
peer = pdev->invalid_peer;
mon_peer = mon_pdev->invalid_mon_peer;
else
mon_peer = peer->monitor_peer;
if (!mon_peer) {
if (peer)
dp_peer_unref_delete(peer,
DP_MOD_ID_RX_PPDU_STATS);
continue;
}
if ((preamble == DOT11_A) || (preamble == DOT11_B))
ppdu->u.nss = 1;
@@ -805,24 +833,24 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
num_msdu = ppdu_user->num_msdu;
pkt_bw_offset = dp_get_bw_offset_frm_bw(soc, ppdu->u.bw);
DP_STATS_UPD(peer, rx.snr, (ppdu->rssi + pkt_bw_offset));
DP_STATS_UPD(mon_peer, rx.snr, (ppdu->rssi + pkt_bw_offset));
if (peer->stats.rx.avg_snr == CDP_INVALID_SNR)
peer->stats.rx.avg_snr =
CDP_SNR_IN(peer->stats.rx.snr);
if (mon_peer->stats.rx.avg_snr == CDP_INVALID_SNR)
mon_peer->stats.rx.avg_snr =
CDP_SNR_IN(mon_peer->stats.rx.snr);
else
CDP_SNR_UPDATE_AVG(peer->stats.rx.avg_snr,
peer->stats.rx.snr);
CDP_SNR_UPDATE_AVG(mon_peer->stats.rx.avg_snr,
mon_peer->stats.rx.snr);
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(mon_peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(mon_peer, rx.ppdu_nss[nss - 1], 1);
}
DP_STATS_INC(peer, rx.mpdu_cnt_fcs_ok,
DP_STATS_INC(mon_peer, rx.mpdu_cnt_fcs_ok,
ppdu_user->mpdu_cnt_fcs_ok);
DP_STATS_INC(peer, rx.mpdu_cnt_fcs_err,
DP_STATS_INC(mon_peer, rx.mpdu_cnt_fcs_err,
ppdu_user->mpdu_cnt_fcs_err);
}
@@ -834,84 +862,84 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
mu_pkt_type = TXRX_TYPE_MU_OFDMA;
if (nss) {
DP_STATS_INC(peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(peer,
DP_STATS_INC(mon_peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(mon_peer,
rx.rx_mu[mu_pkt_type].ppdu_nss[nss - 1],
1);
}
DP_STATS_INC(peer,
DP_STATS_INC(mon_peer,
rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_ok,
ppdu_user->mpdu_cnt_fcs_ok);
DP_STATS_INC(peer,
DP_STATS_INC(mon_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],
DP_STATS_INC(mon_peer, rx.sgi_count[ppdu->u.gi], num_msdu);
DP_STATS_INC(mon_peer, rx.bw[ppdu->u.bw], num_msdu);
DP_STATS_INC(mon_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,
DP_STATS_INC(mon_peer, rx.ppdu_cnt[ppdu->u.ppdu_type], 1);
DP_STATS_INCC(mon_peer, rx.ampdu_cnt, num_msdu,
ppdu_user->is_ampdu);
DP_STATS_INCC(peer, rx.non_ampdu_cnt, num_msdu,
DP_STATS_INCC(mon_peer, rx.non_ampdu_cnt, num_msdu,
!(ppdu_user->is_ampdu));
DP_STATS_UPD(peer, rx.rx_rate, mcs);
DP_STATS_INCC(peer,
DP_STATS_UPD(mon_peer, rx.rx_rate, mcs);
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11A) && (preamble == DOT11_A)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11A) && (preamble == DOT11_A)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11B) && (preamble == DOT11_B)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11B) && (preamble == DOT11_B)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11A) && (preamble == DOT11_N)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11A) && (preamble == DOT11_N)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.su_ax_ppdu_cnt.mcs_count[MAX_MCS - 1], 1,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.su_ax_ppdu_cnt.mcs_count[mcs], 1,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer,
DP_STATS_INCC(mon_peer,
rx.rx_mu[TXRX_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,
DP_STATS_INCC(mon_peer,
rx.rx_mu[TXRX_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,
DP_STATS_INCC(mon_peer,
rx.rx_mu[TXRX_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,
DP_STATS_INCC(mon_peer,
rx.rx_mu[TXRX_TYPE_MU_MIMO].ppdu.mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_AX) &&
@@ -924,27 +952,30 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
ac = TID_TO_WME_AC(ppdu_user->tid);
if (ppdu->tid != HAL_TID_INVALID)
DP_STATS_INC(peer, rx.wme_ac_type[ac], num_msdu);
DP_STATS_INC(mon_peer, rx.wme_ac_type[ac], num_msdu);
DP_STATS_INC(mon_peer, rx.rx_ppdus, 1);
DP_STATS_INC(mon_peer, rx.rx_mpdus,
(ppdu_user->mpdu_cnt_fcs_ok + ppdu_user->mpdu_cnt_fcs_err));
mon_ops = dp_mon_ops_get(soc);
if (mon_ops && mon_ops->mon_rx_stats_update)
mon_ops->mon_rx_stats_update(peer, ppdu, ppdu_user);
mon_ops->mon_rx_stats_update(mon_peer, ppdu, ppdu_user);
if (!peer)
continue;
dp_peer_stats_notify(pdev, peer);
DP_STATS_UPD(peer, rx.last_snr, (ppdu->rssi + pkt_bw_offset));
DP_STATS_UPD(mon_peer, rx.last_snr,
(ppdu->rssi + pkt_bw_offset));
dp_peer_qos_stats_notify(pdev, ppdu_user);
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
dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
&peer->stats, ppdu->peer_id,
UPDATE_PEER_STATS, pdev->pdev_id);
#endif
dp_send_stats_event(pdev, peer, ppdu_user->peer_id);
dp_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS);
}
}