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

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

Change-Id: Icfeb49fc6f1fa2c1f2648a9b4576f31a927c7ecd
CRs-Fixed: 3092123

dp/wifi3.0/monitor/2.0/dp_mon_2.0.c

@@ -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)
 {
 }

dp/wifi3.0/monitor/2.0/dp_rx_mon_2.0.c

@@ -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

dp/wifi3.0/monitor/2.0/dp_rx_mon_2.0.h

@@ -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);
 

dp/wifi3.0/monitor/dp_mon.c

@@ -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 || !peer->vdev || !peer->monitor_peer)
+		return QDF_STATUS_E_FAULT;
 
-	if (!peer->vdev)
+	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);
-
-	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.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);
+
+	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,20 +2365,32 @@ 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)
 {
+	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,
-			     &peer->stats, peer_id,
+			     &peer_stats_intf, peer_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
 
 /*
@@ -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);
 	}

dp/wifi3.0/monitor/dp_mon.h

@@ -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

dp/wifi3.0/monitor/dp_rx_mon.c

@@ -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);
 	}
 }