samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Koodi Ongelmat Pull-pyynnöt Actions Paketit Projektit Julkaisut Wiki Toiminta

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

Selaa lähdekoodia 
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
vanhempi 93cd9e0af8
commit ce45e71913
6 muutettua tiedostoa jossa 237 lisäystä ja 155 poistoa
Download Patch File Download Diff File Expand all files Collapse all files

20
dp/wifi3.0/monitor/2.0/dp_mon_2.0.c
Näytä tiedosto

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

28
dp/wifi3.0/monitor/2.0/dp_rx_mon_2.0.c
Näytä tiedosto

@@ -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 #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_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user) 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 else
mcs = ppdu_user->mcs; mcs = ppdu_user->mcs;
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);
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.su_be_ppdu_cnt.mcs_count[MAX_MCS - 1], 1, rx.su_be_ppdu_cnt.mcs_count[MAX_MCS - 1], 1,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_BE) && ((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_SU))); (ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.su_be_ppdu_cnt.mcs_count[mcs], 1, rx.su_be_ppdu_cnt.mcs_count[mcs], 1,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_BE) && ((mcs < (MAX_MCS - 1)) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_SU))); (ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.rx_mu_be[TXRX_TYPE_MU_OFDMA].mcs_count[MAX_MCS - 1], rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) && 1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_BE) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA))); (ppdu_type == HAL_RX_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.rx_mu_be[TXRX_TYPE_MU_OFDMA].mcs_count[mcs], rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_OFDMA].mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) && 1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_BE) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA))); (ppdu_type == HAL_RX_TYPE_MU_OFDMA)));
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.rx_mu_be[TXRX_TYPE_MU_MIMO].mcs_count[MAX_MCS - 1], rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) && 1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_BE) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO))); (ppdu_type == HAL_RX_TYPE_MU_MIMO)));
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.rx_mu_be[TXRX_TYPE_MU_MIMO].mcs_count[mcs], rx.mu_be_ppdu_cnt[TXRX_TYPE_MU_MIMO].mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) && 1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_BE) && (preamble == DOT11_BE) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO))); (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; ppdu->punc_bw = hal_ppdu_info->rx_status.punctured_bw;
} }
#else #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_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user) 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 void

4
dp/wifi3.0/monitor/2.0/dp_rx_mon_2.0.h
Näytä tiedosto

@@ -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 * dp_rx_mon_stats_update_2_0 () - update rx stats
* *
* @peer: peer handle * @peer: monitor peer handle
* @ppdu: Rx PPDU status metadata object * @ppdu: Rx PPDU status metadata object
* @ppdu_user: Rx PPDU user status metadata object * @ppdu_user: Rx PPDU user status metadata object
* *
* Return: Void * 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_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user); struct cdp_rx_stats_ppdu_user *ppdu_user);

186
dp/wifi3.0/monitor/dp_mon.c
Näytä tiedosto

@@ -1084,34 +1084,49 @@ void dp_pktlogmod_exit(struct dp_pdev *pdev)
} }
#endif /*DP_CON_MON*/ #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) 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_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; 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)); 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; peer_stats_intf.rssi_changed = true;
if ((peer_stats->rx.snr && peer_stats_intf.rssi_changed) || if ((mon_peer_stats->rx.snr && peer_stats_intf.rssi_changed) ||
(peer_stats->tx.tx_rate && (mon_peer_stats->tx.tx_rate &&
peer_stats->tx.tx_rate != peer_stats->tx.last_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_mem_copy(peer_stats_intf.peer_mac, peer->mac_addr.raw,
QDF_MAC_ADDR_SIZE); QDF_MAC_ADDR_SIZE);
peer_stats_intf.vdev_id = peer->vdev->vdev_id; 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.last_peer_tx_rate =
peer_stats_intf.peer_tx_rate = peer_stats->tx.tx_rate; mon_peer_stats->tx.last_tx_rate;
peer_stats_intf.peer_rssi = peer_stats->rx.snr; peer_stats_intf.peer_tx_rate = mon_peer_stats->tx.tx_rate;
peer_stats_intf.tx_packet_count = peer_stats->tx.ucast.num; peer_stats_intf.peer_rssi = mon_peer_stats->rx.snr;
peer_stats_intf.rx_packet_count = peer_stats->rx.to_stack.num; peer_stats_intf.ack_rssi = mon_peer_stats->tx.last_ack_rssi;
peer_stats_intf.tx_byte_count = peer_stats->tx.tx_success.bytes; peer_stats_intf.rx_packet_count = txrx_peer->to_stack.num;
peer_stats_intf.rx_byte_count = peer_stats->rx.to_stack.bytes; peer_stats_intf.rx_byte_count = txrx_peer->to_stack.bytes;
peer_stats_intf.per = peer_stats->tx.last_per; peer_stats_intf.tx_packet_count =
peer_stats_intf.ack_rssi = peer_stats->tx.last_ack_rssi; 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; peer_stats_intf.free_buff = INVALID_FREE_BUFF;
dp_wdi_event_handler(WDI_EVENT_PEER_STATS, dp_pdev->soc, dp_wdi_event_handler(WDI_EVENT_PEER_STATS, dp_pdev->soc,
(void *)&peer_stats_intf, 0, (void *)&peer_stats_intf, 0,
@@ -2283,6 +2298,7 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
uint32_t rix; uint32_t rix;
uint16_t ratecode = 0; uint16_t ratecode = 0;
enum PUNCTURED_MODES punc_mode = NO_PUNCTURE; enum PUNCTURED_MODES punc_mode = NO_PUNCTURE;
struct dp_mon_peer *mon_peer = NULL;
if (!peer || !ppdu) if (!peer || !ppdu)
return; return;
@@ -2290,6 +2306,10 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK) if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK)
return; return;
mon_peer = peer->monitor_peer;
if (!mon_peer)
return;
ratekbps = dp_getrateindex(ppdu->gi, ratekbps = dp_getrateindex(ppdu->gi,
ppdu->mcs, ppdu->mcs,
ppdu->nss, ppdu->nss,
@@ -2299,7 +2319,7 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
&rix, &rix,
&ratecode); &ratecode);
DP_STATS_UPD(peer, tx.last_tx_rate, ratekbps); DP_STATS_UPD(mon_peer, tx.last_tx_rate, ratekbps);
if (!ratekbps) if (!ratekbps)
return; return;
@@ -2315,16 +2335,16 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
ppdu->rix = rix; ppdu->rix = rix;
ppdu->tx_ratekbps = ratekbps; ppdu->tx_ratekbps = ratekbps;
ppdu->tx_ratecode = ratecode; ppdu->tx_ratecode = ratecode;
peer->stats.tx.avg_tx_rate = mon_peer->stats.tx.avg_tx_rate =
dp_ath_rate_lpf(peer->stats.tx.avg_tx_rate, ratekbps); dp_ath_rate_lpf(mon_peer->stats.tx.avg_tx_rate, ratekbps);
ppdu_tx_rate = dp_ath_rate_out(peer->stats.tx.avg_tx_rate); ppdu_tx_rate = dp_ath_rate_out(mon_peer->stats.tx.avg_tx_rate);
DP_STATS_UPD(peer, tx.rnd_avg_tx_rate, ppdu_tx_rate); DP_STATS_UPD(mon_peer, tx.rnd_avg_tx_rate, ppdu_tx_rate);
peer->stats.tx.bw_info = ppdu->bw; mon_peer->stats.tx.bw_info = ppdu->bw;
peer->stats.tx.gi_info = ppdu->gi; mon_peer->stats.tx.gi_info = ppdu->gi;
peer->stats.tx.nss_info = ppdu->nss; mon_peer->stats.tx.nss_info = ppdu->nss;
peer->stats.tx.mcs_info = ppdu->mcs; mon_peer->stats.tx.mcs_info = ppdu->mcs;
peer->stats.tx.preamble_info = ppdu->preamble; mon_peer->stats.tx.preamble_info = ppdu->preamble;
if (peer->vdev) { if (peer->vdev) {
/* /*
* In STA mode: * In STA mode:
@@ -2345,20 +2365,32 @@ dp_tx_rate_stats_update(struct dp_peer *peer,
} }
#if defined(FEATURE_PERPKT_INFO) && defined(WDI_EVENT_ENABLE) #if defined(FEATURE_PERPKT_INFO) && defined(WDI_EVENT_ENABLE)
static inline void dp_send_stats_event(struct dp_pdev *pdev, void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
struct dp_peer *peer, uint16_t peer_id)
u_int16_t peer_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;
}
dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc, dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
&peer->stats, peer_id, &peer_stats_intf, peer_id,
UPDATE_PEER_STATS, pdev->pdev_id); UPDATE_PEER_STATS, pdev->pdev_id);
} }
#else
static inline void dp_send_stats_event(struct dp_pdev *pdev,
struct dp_peer *peer,
u_int16_t peer_id)
{
}
#endif #endif
/* /*
@@ -2482,6 +2514,7 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
uint16_t mpdu_failed; uint16_t mpdu_failed;
struct dp_mon_ops *mon_ops; struct dp_mon_ops *mon_ops;
enum cdp_ru_index ru_index; enum cdp_ru_index ru_index;
struct dp_mon_peer *mon_peer = NULL;
preamble = ppdu->preamble; preamble = ppdu->preamble;
mcs = ppdu->mcs; 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) if (pdev->soc->process_tx_status)
return; return;
mon_peer = peer->monitor_peer;
if (!mon_peer)
return;
if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK) { if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK) {
/* /*
* All failed mpdu will be retried, so incrementing * 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 * ack failure i.e for long retries we get
* mpdu failed equal mpdu tried. * mpdu failed equal mpdu tried.
*/ */
DP_STATS_INC(peer, tx.retries, mpdu_failed); DP_STATS_INC(mon_peer, tx.retries, mpdu_failed);
DP_STATS_INC(peer, tx.tx_failed, ppdu->failed_msdus);
return; return;
} }
if (ppdu->is_ppdu_cookie_valid) 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 && if (ppdu->mu_group_id <= MAX_MU_GROUP_ID &&
ppdu->ppdu_type != HTT_PPDU_STATS_PPDU_TYPE_SU) { 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, QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
"mu_group_id out of bound!!\n"); "mu_group_id out of bound!!\n");
else 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)); (ppdu->user_pos + 1));
} }
if (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA || if (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA ||
ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO_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(mon_peer, tx.ru_tones, ppdu->ru_tones);
DP_STATS_UPD(peer, tx.ru_start, ppdu->ru_start); DP_STATS_UPD(mon_peer, tx.ru_start, ppdu->ru_start);
ru_index = dp_get_ru_index_frm_ru_tones(ppdu->ru_tones); ru_index = dp_get_ru_index_frm_ru_tones(ppdu->ru_tones);
if (ru_index != RU_INDEX_MAX) { 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); 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); 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); 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 * ack failure i.e for long retries we get
* mpdu failed equal mpdu tried. * mpdu failed equal mpdu tried.
*/ */
DP_STATS_INC(peer, tx.retries, mpdu_failed); DP_STATS_INC(mon_peer, tx.retries, mpdu_failed);
DP_STATS_INC(peer, tx.tx_failed, ppdu->failed_msdus);
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); 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); 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); mpdu_tried);
DP_STATS_UPD(peer, tx.tx_rate, ppdu->tx_rate); DP_STATS_UPD(mon_peer, tx.tx_rate, ppdu->tx_rate);
DP_STATS_INC(peer, tx.sgi_count[ppdu->gi], num_msdu); DP_STATS_INC(mon_peer, tx.sgi_count[ppdu->gi], num_msdu);
DP_STATS_INC(peer, tx.bw[ppdu->bw], num_msdu); DP_STATS_INC(mon_peer, tx.bw[ppdu->bw], num_msdu);
DP_STATS_INC(peer, tx.nss[ppdu->nss], num_msdu); DP_STATS_INC(mon_peer, tx.nss[ppdu->nss], num_msdu);
if (ppdu->tid < CDP_DATA_TID_MAX) 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); num_msdu);
DP_STATS_INCC(peer, tx.stbc, num_msdu, ppdu->stbc); DP_STATS_INCC(mon_peer, tx.stbc, num_msdu, ppdu->stbc);
DP_STATS_INCC(peer, tx.ldpc, num_msdu, ppdu->ldpc); DP_STATS_INCC(mon_peer, tx.ldpc, num_msdu, ppdu->ldpc);
if (!(ppdu->is_mcast) && ppdu->ack_rssi_valid) 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, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu, tx.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(mon_peer,
tx.pkt_type[preamble].mcs_count[mcs], num_msdu, tx.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, tx.ampdu_cnt, num_mpdu, ppdu->is_ampdu); DP_STATS_INCC(mon_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(mon_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.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); mon_ops = dp_mon_ops_get(pdev->soc);
if (mon_ops && mon_ops->mon_tx_stats_update) 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); 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; uint8_t tid;
struct dp_peer *peer; struct dp_peer *peer;
struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev; struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
struct dp_mon_peer *mon_peer = NULL;
ppdu_desc = (struct cdp_tx_completion_ppdu *) ppdu_desc = (struct cdp_tx_completion_ppdu *)
qdf_nbuf_data(ppdu_info->nbuf); 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; goto add_ppdu_to_sched_list;
if (ppdu_desc->drop_reason == HTT_FLUSH_EXCESS_RETRIES) { 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)], tx.excess_retries_per_ac[TID_TO_WME_AC(tid)],
ppdu_desc->num_msdu); ppdu_desc->num_msdu);
} }

17
dp/wifi3.0/monitor/dp_mon.h
Näytä tiedosto

@@ -586,7 +586,7 @@ struct dp_mon_ops {
#ifdef QCA_ENHANCED_STATS_SUPPORT #ifdef QCA_ENHANCED_STATS_SUPPORT
void (*mon_filter_setup_enhanced_stats)(struct dp_pdev *pdev); void (*mon_filter_setup_enhanced_stats)(struct dp_pdev *pdev);
void (*mon_filter_reset_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); struct cdp_tx_completion_ppdu_user *ppdu);
#endif #endif
#ifdef QCA_MCOPY_SUPPORT #ifdef QCA_MCOPY_SUPPORT
@@ -648,7 +648,7 @@ struct dp_mon_ops {
#endif #endif
void (*mon_register_feature_ops)(struct dp_soc *soc); void (*mon_register_feature_ops)(struct dp_soc *soc);
#ifdef QCA_ENHANCED_STATS_SUPPORT #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_indication_ppdu *ppdu,
struct cdp_rx_stats_ppdu_user *ppdu_user); struct cdp_rx_stats_ppdu_user *ppdu_user);
void (*mon_rx_populate_ppdu_usr_info)(struct mon_rx_user_status *rx_user_status, 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 #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); QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev, struct dp_peer *peer);
#else #else
static inline QDF_STATUS dp_peer_stats_notify(struct dp_pdev *pdev, 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 #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 #ifndef WLAN_TX_PKT_CAPTURE_ENH
/** /**
* dp_tx_ppdu_stats_process - Deferred PPDU stats handler * dp_tx_ppdu_stats_process - Deferred PPDU stats handler

137
dp/wifi3.0/monitor/dp_rx_mon.c
Näytä tiedosto

@@ -647,12 +647,17 @@ static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
uint16_t ratecode = 0; uint16_t ratecode = 0;
struct cdp_rx_stats_ppdu_user *ppdu_user = NULL; struct cdp_rx_stats_ppdu_user *ppdu_user = NULL;
enum PUNCTURED_MODES punc_mode = NO_PUNCTURE; enum PUNCTURED_MODES punc_mode = NO_PUNCTURE;
struct dp_mon_peer *mon_peer = NULL;
if (!peer || !ppdu) if (!peer || !ppdu)
return; return;
mon_peer = peer->monitor_peer;
ppdu_user = &ppdu->user[user]; ppdu_user = &ppdu->user[user];
if (!mon_peer)
return;
if (ppdu->u.ppdu_type != HAL_RX_TYPE_SU) { if (ppdu->u.ppdu_type != HAL_RX_TYPE_SU) {
if (ppdu_user->nss == 0) if (ppdu_user->nss == 0)
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; nss = ppdu_user->nss - 1;
mcs = ppdu_user->mcs; mcs = ppdu_user->mcs;
mon_peer->stats.rx.nss_info = ppdu_user->nss;
mon_peer->stats.rx.mcs_info = ppdu_user->mcs;
} else { } else {
if (ppdu->u.nss == 0) if (ppdu->u.nss == 0)
nss = 0; nss = 0;
else else
nss = ppdu->u.nss - 1; nss = ppdu->u.nss - 1;
mcs = ppdu->u.mcs; 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, ratekbps = dp_getrateindex(ppdu->u.gi,
@@ -685,12 +695,16 @@ static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
return; 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; ppdu->rix = rix;
DP_STATS_UPD(peer, rx.last_rx_rate, ratekbps); DP_STATS_UPD(mon_peer, rx.last_rx_rate, ratekbps);
peer->stats.rx.avg_rx_rate = mon_peer->stats.rx.avg_rx_rate =
dp_ath_rate_lpf(peer->stats.rx.avg_rx_rate, ratekbps); dp_ath_rate_lpf(mon_peer->stats.rx.avg_rx_rate, ratekbps);
ppdu_rx_rate = dp_ath_rate_out(peer->stats.rx.avg_rx_rate); ppdu_rx_rate = dp_ath_rate_out(mon_peer->stats.rx.avg_rx_rate);
DP_STATS_UPD(peer, rx.rnd_avg_rx_rate, ppdu_rx_rate); DP_STATS_UPD(mon_peer, rx.rnd_avg_rx_rate, ppdu_rx_rate);
ppdu->rx_ratekbps = ratekbps; ppdu->rx_ratekbps = ratekbps;
ppdu->rx_ratecode = ratecode; ppdu->rx_ratecode = ratecode;
ppdu_user->rx_ratekbps = ratekbps; ppdu_user->rx_ratekbps = ratekbps;
@@ -766,10 +780,12 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
uint16_t num_msdu; uint16_t num_msdu;
uint8_t pkt_bw_offset; uint8_t pkt_bw_offset;
struct dp_peer *peer; struct dp_peer *peer;
struct dp_mon_peer *mon_peer;
struct cdp_rx_stats_ppdu_user *ppdu_user; struct cdp_rx_stats_ppdu_user *ppdu_user;
uint32_t i; uint32_t i;
enum cdp_mu_packet_type mu_pkt_type; enum cdp_mu_packet_type mu_pkt_type;
struct dp_mon_ops *mon_ops; struct dp_mon_ops *mon_ops;
struct dp_mon_pdev *mon_pdev = NULL;
if (pdev) if (pdev)
soc = pdev->soc; soc = pdev->soc;
@@ -779,6 +795,8 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
if (!soc || soc->process_rx_status) if (!soc || soc->process_rx_status)
return; return;
mon_pdev = pdev->monitor_pdev;
preamble = ppdu->u.preamble; preamble = ppdu->u.preamble;
ppdu_type = ppdu->u.ppdu_type; 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); DP_MOD_ID_RX_PPDU_STATS);
if (!peer) 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)) if ((preamble == DOT11_A) || (preamble == DOT11_B))
ppdu->u.nss = 1; ppdu->u.nss = 1;
@@ -805,24 +833,24 @@ static void dp_rx_stats_update(struct dp_pdev *pdev,
num_msdu = ppdu_user->num_msdu; num_msdu = ppdu_user->num_msdu;
pkt_bw_offset = dp_get_bw_offset_frm_bw(soc, ppdu->u.bw); 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) if (mon_peer->stats.rx.avg_snr == CDP_INVALID_SNR)
peer->stats.rx.avg_snr = mon_peer->stats.rx.avg_snr =
CDP_SNR_IN(peer->stats.rx.snr); CDP_SNR_IN(mon_peer->stats.rx.snr);
else else
CDP_SNR_UPDATE_AVG(peer->stats.rx.avg_snr, CDP_SNR_UPDATE_AVG(mon_peer->stats.rx.avg_snr,
peer->stats.rx.snr); mon_peer->stats.rx.snr);
if (ppdu_type == HAL_RX_TYPE_SU) { if (ppdu_type == HAL_RX_TYPE_SU) {
if (nss) { if (nss) {
DP_STATS_INC(peer, rx.nss[nss - 1], num_msdu); DP_STATS_INC(mon_peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(peer, rx.ppdu_nss[nss - 1], 1); 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); 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); 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; mu_pkt_type = TXRX_TYPE_MU_OFDMA;
if (nss) { if (nss) {
DP_STATS_INC(peer, rx.nss[nss - 1], num_msdu); DP_STATS_INC(mon_peer, rx.nss[nss - 1], num_msdu);
DP_STATS_INC(peer, DP_STATS_INC(mon_peer,
rx.rx_mu[mu_pkt_type].ppdu_nss[nss - 1], rx.rx_mu[mu_pkt_type].ppdu_nss[nss - 1],
1); 1);
} }
DP_STATS_INC(peer, DP_STATS_INC(mon_peer,
rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_ok, rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_ok,
ppdu_user->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, rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_err,
ppdu_user->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(mon_peer, rx.sgi_count[ppdu->u.gi], num_msdu);
DP_STATS_INC(peer, rx.bw[ppdu->u.bw], num_msdu); DP_STATS_INC(mon_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.reception_type[ppdu->u.ppdu_type],
num_msdu); num_msdu);
DP_STATS_INC(peer, rx.ppdu_cnt[ppdu->u.ppdu_type], 1); DP_STATS_INC(mon_peer, rx.ppdu_cnt[ppdu->u.ppdu_type], 1);
DP_STATS_INCC(peer, rx.ampdu_cnt, num_msdu, DP_STATS_INCC(mon_peer, rx.ampdu_cnt, num_msdu,
ppdu_user->is_ampdu); 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)); !(ppdu_user->is_ampdu));
DP_STATS_UPD(peer, rx.rx_rate, mcs); DP_STATS_UPD(mon_peer, rx.rx_rate, mcs);
DP_STATS_INCC(peer, DP_STATS_INCC(mon_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(mon_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(mon_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(mon_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(mon_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(mon_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(mon_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(mon_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(mon_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(mon_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, DP_STATS_INCC(mon_peer,
rx.su_ax_ppdu_cnt.mcs_count[MAX_MCS - 1], 1, rx.su_ax_ppdu_cnt.mcs_count[MAX_MCS - 1], 1,
((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX) && ((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_SU))); (ppdu_type == HAL_RX_TYPE_SU)));
DP_STATS_INCC(peer, DP_STATS_INCC(mon_peer,
rx.su_ax_ppdu_cnt.mcs_count[mcs], 1, rx.su_ax_ppdu_cnt.mcs_count[mcs], 1,
((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX) && ((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_SU))); (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], rx.rx_mu[TXRX_TYPE_MU_OFDMA].ppdu.mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) && 1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_AX) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA))); (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], rx.rx_mu[TXRX_TYPE_MU_OFDMA].ppdu.mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) && 1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_AX) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_OFDMA))); (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], rx.rx_mu[TXRX_TYPE_MU_MIMO].ppdu.mcs_count[MAX_MCS - 1],
1, ((mcs >= (MAX_MCS - 1)) && 1, ((mcs >= (MAX_MCS - 1)) &&
(preamble == DOT11_AX) && (preamble == DOT11_AX) &&
(ppdu_type == HAL_RX_TYPE_MU_MIMO))); (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], rx.rx_mu[TXRX_TYPE_MU_MIMO].ppdu.mcs_count[mcs],
1, ((mcs < (MAX_MCS - 1)) && 1, ((mcs < (MAX_MCS - 1)) &&
(preamble == DOT11_AX) && (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); ac = TID_TO_WME_AC(ppdu_user->tid);
if (ppdu->tid != HAL_TID_INVALID) 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); mon_ops = dp_mon_ops_get(soc);
if (mon_ops && mon_ops->mon_rx_stats_update) 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_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); dp_peer_qos_stats_notify(pdev, ppdu_user);
if (peer == pdev->invalid_peer)
continue;
if (dp_is_subtype_data(ppdu->frame_ctrl)) if (dp_is_subtype_data(ppdu->frame_ctrl))
dp_rx_rate_stats_update(peer, ppdu, i); dp_rx_rate_stats_update(peer, ppdu, i);
#if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE dp_send_stats_event(pdev, peer, ppdu_user->peer_id);
dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
&peer->stats, ppdu->peer_id,
UPDATE_PEER_STATS, pdev->pdev_id);
#endif
dp_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS); dp_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS);
} }
} }