qcacmn: Add check for num users while peer deterministic stats update

Adding check for num users and num ul users to not cross max users limit
And convert target uplink trigger tid to data tids

CRs-Fixed: 3396991
Change-Id: I66180dba0889e116ce8ff4e582fd9c1d8391f27b

dp/inc/cdp_txrx_stats_struct.h

@@ -387,6 +387,26 @@ enum cdp_msduq_index {
 	MSDUQ_INDEX_MAX,
 };
 
+/*
+ * cdp_ul_trigger_tids: UL trigger tids
+ * CDP_UL_TRIG_BK_TID: Background tid
+ * CDP_UL_TRIG_BE_TID: Best effort tid
+ * CDP_UL_TRIG_VI_TID: Video tid
+ * CDP_UL_TRIG_VO_TID: Voice tid
+ */
+enum cdp_ul_trigger_tids {
+	CDP_UL_TRIG_BK_TID = 25,
+	CDP_UL_TRIG_BE_TID,
+	CDP_UL_TRIG_VI_TID,
+	CDP_UL_TRIG_VO_TID,
+};
+
+#define UL_TRIGGER_TID_TO_DATA_TID(_tid) (      \
+		(((_tid) == CDP_UL_TRIG_BE_TID)) ? 0 : \
+		(((_tid) == CDP_UL_TRIG_BK_TID)) ? 1 : \
+		(((_tid) == CDP_UL_TRIG_VI_TID)) ? 5 : \
+		6)
+
 /*
  * cdp_ru_index: Different RU index
  *
@@ -2981,6 +3001,16 @@ struct cdp_pdev_chan_util_stats {
 	uint8_t ap_rx_util;
 };
 
+/**
+ * struct cdp_pdev_ul_trigger_status- Structure to hold UL trigger status
+ * @trigger_success: Trigger success
+ * @trigger_fail: Trigger fail
+ */
+struct cdp_pdev_ul_trigger_status {
+	uint64_t trigger_success;
+	uint64_t trigger_fail;
+};
+
 /**
  * struct cdp_pdev_deter_stats- Structure to hold pdev deterministic stats
  * @dl_ofdma_usr: num_user counter for dl ofdma
@@ -2989,8 +3019,10 @@ struct cdp_pdev_chan_util_stats {
  * @ul_mimo_usr: num_user counter for ul mimo
  * @dl_mode_cnt: DL tx mode counter
  * @ul_mode_cnt: UL tx mode counter
+ * @rx_su_cnt: RX su counter
  * @ch_access_delay
  * @ch_util: channel congestion stats
+ * @ts: trigger status for ul
  */
 struct cdp_pdev_deter_stats {
 	uint64_t dl_ofdma_usr[CDP_MU_MAX_USERS];
@@ -2999,10 +3031,10 @@ struct cdp_pdev_deter_stats {
 	uint64_t ul_mimo_usr[CDP_MU_MAX_USERS];
 	uint64_t dl_mode_cnt[TX_MODE_DL_MAX];
 	uint64_t ul_mode_cnt[TX_MODE_UL_MAX];
+	uint64_t rx_su_cnt;
 	uint32_t ch_access_delay[WME_AC_MAX];
-	uint64_t trigger_success;
-	uint64_t trigger_fail;
 	struct cdp_pdev_chan_util_stats ch_util;
+	struct cdp_pdev_ul_trigger_status ts[TX_MODE_UL_MAX];
 };
 #endif
 

dp/wifi3.0/dp_stats.c

@@ -9332,13 +9332,15 @@ dp_get_pdev_deter_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
 		     pdev->stats.deter_stats.ch_access_delay,
 		     sizeof(stats->ch_access_delay[0]) * WME_AC_MAX);
 
-	stats->trigger_success = pdev->stats.deter_stats.trigger_success;
+	qdf_mem_copy(stats->ts,
-	stats->trigger_fail = pdev->stats.deter_stats.trigger_fail;
+		     pdev->stats.deter_stats.ts,
+		     sizeof(stats->ts[0]) * TX_MODE_UL_MAX);
 
 	stats->ch_util.ap_tx_util = pdev->stats.deter_stats.ch_util.ap_tx_util;
 	stats->ch_util.ap_rx_util = pdev->stats.deter_stats.ch_util.ap_rx_util;
 	stats->ch_util.ap_chan_util =
 			pdev->stats.deter_stats.ch_util.ap_chan_util;
+	stats->rx_su_cnt = pdev->stats.deter_stats.rx_su_cnt;
 
 	return QDF_STATUS_SUCCESS;
 }

dp/wifi3.0/monitor/dp_mon.c

@@ -3008,11 +3008,13 @@ void dp_ppdu_desc_get_txmode(struct cdp_tx_completion_ppdu *ppdu)
 {
 	uint16_t frame_type = ppdu->htt_frame_type;
 
-	if (ppdu->frame_type != CDP_PPDU_FTYPE_DATA)
-		return;
-
 	ppdu->txmode_type = TX_MODE_TYPE_UNKNOWN;
 
+	if (ppdu->frame_type == CDP_PPDU_FTYPE_CTRL &&
+	    (frame_type != HTT_STATS_FTYPE_SGEN_MU_TRIG &&
+	     frame_type != HTT_STATS_FTYPE_SGEN_BE_MU_TRIG))
+		return;
+
 	if (frame_type == HTT_STATS_FTYPE_SGEN_MU_BAR ||
 	    frame_type == HTT_STATS_FTYPE_SGEN_BE_MU_BAR) {
 		ppdu->txmode = TX_MODE_UL_OFDMA_MU_BAR_TRIGGER;
@@ -3079,28 +3081,24 @@ dp_pdev_update_deter_stats(struct dp_pdev *pdev,
 	if (!pdev || !ppdu)
 		return;
 
-	if (ppdu->frame_type != CDP_PPDU_FTYPE_DATA)
-		return;
-
 	if (ppdu->txmode_type == TX_MODE_TYPE_UNKNOWN)
 		return;
 
-	if (ppdu->backoff_ac_valid)
+	if (ppdu->num_ul_users >= HAL_MAX_UL_MU_USERS ||
+	    ppdu->num_users >= HAL_MAX_UL_MU_USERS) {
+		dp_mon_err("num ul user %d or num users %d exceeds max limit",
+			   ppdu->num_ul_users, ppdu->num_users);
+		return;
+	}
+	if (ppdu->backoff_ac_valid) {
+		if (ppdu->backoff_ac >= WME_AC_MAX) {
+			dp_mon_err("backoff_ac %d exceed max limit",
+				   ppdu->backoff_ac);
+			return;
+		}
 		DP_STATS_UPD(pdev,
 			     deter_stats.ch_access_delay[ppdu->backoff_ac],
 			     ppdu->ch_access_delay);
-
-	if (ppdu->num_ul_user_resp_valid &&
-	    (ppdu->txmode_type == TX_MODE_TYPE_UL)) {
-		if (ppdu->num_ul_user_resp) {
-			DP_STATS_INC(pdev,
-				     deter_stats.trigger_success,
-				     1);
-		} else {
-			DP_STATS_INC(pdev,
-				     deter_stats.trigger_fail,
-				     1);
-		}
 	}
 
 	if (ppdu->txmode_type == TX_MODE_TYPE_DL) {
@@ -3135,6 +3133,17 @@ dp_pdev_update_deter_stats(struct dp_pdev *pdev,
 				     1);
 			break;
 		}
+		if (ppdu->num_ul_user_resp_valid) {
+			if (ppdu->num_ul_user_resp) {
+				DP_STATS_INC(pdev,
+					     deter_stats.ts[ppdu->txmode].trigger_success,
+					     1);
+			} else {
+				DP_STATS_INC(pdev,
+					     deter_stats.ts[ppdu->txmode].trigger_fail,
+					     1);
+			}
+		}
 	}
 }
 
@@ -3184,19 +3193,17 @@ dp_ppdu_desc_user_deter_stats_update(struct dp_pdev *pdev,
 				     struct cdp_tx_completion_ppdu_user *user)
 {
 	struct dp_mon_peer *mon_peer = NULL;
+	uint64_t avg_tx_rate = 0;
+	uint32_t ratekbps = 0;
+	uint32_t rix;
 	uint32_t msduq;
+	uint16_t ratecode = 0;
 	uint8_t txmode;
 	uint8_t tid;
 
 	if (!pdev || !ppdu_desc || !user || !peer)
 		return;
 
-	if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_DATA)
-		return;
-
-	if (user->tid >= CDP_DATA_TID_MAX)
-		return;
-
 	mon_peer = peer->monitor_peer;
 	if (qdf_unlikely(!mon_peer))
 		return;
@@ -3204,33 +3211,67 @@ dp_ppdu_desc_user_deter_stats_update(struct dp_pdev *pdev,
 	if (ppdu_desc->txmode_type == TX_MODE_TYPE_UNKNOWN)
 		return;
 
+	if (ppdu_desc->txmode_type == TX_MODE_TYPE_UL &&
+	    (ppdu_desc->txmode != TX_MODE_UL_OFDMA_MU_BAR_TRIGGER)) {
+		if (user->tid < CDP_UL_TRIG_BK_TID ||
+		    user->tid > CDP_UL_TRIG_VO_TID)
+			return;
+
+		user->tid = UL_TRIGGER_TID_TO_DATA_TID(user->tid);
+	}
+
+	if (user->tid >= CDP_DATA_TID_MAX)
+		return;
+
+	ratekbps = dp_getrateindex(user->gi,
+				   user->mcs,
+				   user->nss,
+				   user->preamble,
+				   user->bw,
+				   user->punc_mode,
+				   &rix,
+				   &ratecode);
+
+	if (!ratekbps)
+		return;
+
+	avg_tx_rate = mon_peer->stats.deter_stats.avg_tx_rate;
+	avg_tx_rate = dp_ath_rate_lpf(avg_tx_rate,
+				      ratekbps);
+	DP_STATS_UPD(mon_peer,
+		     deter_stats.avg_tx_rate,
+		     avg_tx_rate);
+
 	txmode = ppdu_desc->txmode;
 	tid = user->tid;
+
 	if (ppdu_desc->txmode_type == TX_MODE_TYPE_DL) {
 		dp_ppdu_desc_get_msduq(user->msduq_bitmap, &msduq);
 		if (msduq == MSDUQ_INDEX_MAX)
 			return;
 
 		DP_STATS_INC(mon_peer,
-			     deter_stats[tid].dl_det[msduq][txmode].mode_cnt,
+			     deter_stats.deter[tid].dl_det[msduq][txmode].mode_cnt,
 			     1);
+
 		DP_STATS_UPD(mon_peer,
-			     deter_stats[tid].dl_det[msduq][txmode].avg_rate,
+			     deter_stats.deter[tid].dl_det[msduq][txmode].avg_rate,
-			     mon_peer->stats.tx.avg_tx_rate);
+			     avg_tx_rate);
 	} else {
 		DP_STATS_INC(mon_peer,
-			     deter_stats[tid].ul_det[txmode].mode_cnt,
+			     deter_stats.deter[tid].ul_det[txmode].mode_cnt,
 			     1);
+
 		DP_STATS_UPD(mon_peer,
-			     deter_stats[tid].ul_det[txmode].avg_rate,
+			     deter_stats.deter[tid].ul_det[txmode].avg_rate,
-			     mon_peer->stats.tx.avg_tx_rate);
+			     avg_tx_rate);
 		if (!user->completion_status) {
 			DP_STATS_INC(mon_peer,
-				     deter_stats[tid].ul_det[txmode].trigger_success,
+				     deter_stats.deter[tid].ul_det[txmode].trigger_success,
 				     1);
 		} else {
 			DP_STATS_INC(mon_peer,
-				     deter_stats[tid].ul_det[txmode].trigger_fail,
+				     deter_stats.deter[tid].ul_det[txmode].trigger_fail,
 				     1);
 		}
 	}
@@ -3438,9 +3479,6 @@ dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
 	dp_tx_rate_stats_update(peer, ppdu);
 	dp_pdev_telemetry_stats_update(pdev, ppdu);
 
-	dp_ppdu_desc_user_deter_stats_update(pdev, peer, ppdu_desc,
-					     ppdu);
-
 	dp_peer_stats_notify(pdev, peer);
 
 	ratekbps = mon_peer->stats.tx.tx_rate;
@@ -4849,6 +4887,9 @@ dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
 
 		dp_tx_ctrl_stats_update(pdev, peer, &ppdu_desc->user[i]);
 
+		dp_ppdu_desc_user_deter_stats_update(pdev, peer, ppdu_desc,
+						     &ppdu_desc->user[i]);
+
 		/*
 		 * different frame like DATA, BAR or CTRL has different
 		 * tlv bitmap expected. Apart from ACK_BA_STATUS TLV, we

dp/wifi3.0/monitor/dp_mon.h

@@ -916,14 +916,12 @@ struct dp_mon_peer_airtime_stats {
 
 /**
  * struct dp_mon_peer_deterministic - Monitor peer deterministic stats
- * @dl_det: Downlink deterministic stats
+ * @deter: Deterministic stats per data tid
- * @ul_det: Uplink deterministic stats
+ * @avg_tx_rate: Avg TX rate
- * @rx_det: RX deterministic stats
  */
 struct dp_mon_peer_deterministic {
-	struct cdp_peer_tx_dl_deter dl_det[MSDUQ_INDEX_MAX][TX_MODE_DL_MAX];
+	struct cdp_peer_deter_stats deter[CDP_DATA_TID_MAX];
-	struct cdp_peer_tx_ul_deter ul_det[TX_MODE_UL_MAX];
+	uint64_t avg_tx_rate;
-	struct cdp_peer_rx_deter rx_det;
 };
 #endif
 
@@ -940,7 +938,7 @@ struct dp_mon_peer_stats {
 	dp_mon_peer_rx_stats rx;
 #ifdef WLAN_TELEMETRY_STATS_SUPPORT
 	struct dp_mon_peer_airtime_stats airtime_stats;
-	struct dp_mon_peer_deterministic deter_stats[CDP_DATA_TID_MAX];
+	struct dp_mon_peer_deterministic deter_stats;
 #endif
 #endif
 };
@@ -4491,13 +4489,13 @@ void dp_monitor_peer_deter_stats(struct dp_peer *peer,
 				 struct cdp_peer_deter_stats *stats)
 {
 	struct dp_mon_peer_stats *mon_peer_stats = NULL;
-	struct dp_mon_peer_deterministic *deter_stats;
+	struct cdp_peer_deter_stats *deter_stats;
 
 	if (qdf_unlikely(!peer->monitor_peer))
 		return;
 
 	mon_peer_stats = &peer->monitor_peer->stats;
-	deter_stats = mon_peer_stats->deter_stats;
+	deter_stats = &mon_peer_stats->deter_stats.deter[0];
 	qdf_mem_copy(stats, deter_stats, sizeof(*stats) * CDP_DATA_TID_MAX);
 }
 #endif

dp/wifi3.0/monitor/dp_rx_mon.c

@@ -880,12 +880,31 @@ void dp_rx_mon_update_user_deter_stats(struct dp_pdev *pdev,
 		return;
 
 	DP_STATS_INC(mon_peer,
-		     deter_stats[tid].rx_det.mode_cnt,
+		     deter_stats.deter[tid].rx_det.mode_cnt,
 		     1);
 	DP_STATS_UPD(mon_peer,
-		     deter_stats[tid].rx_det.avg_rate,
+		     deter_stats.deter[tid].rx_det.avg_rate,
 		     mon_peer->stats.rx.avg_rx_rate);
 }
+
+/**
+ * dp_rx_mon_update_pdev_deter_stats() - Update pdev deterministic stats
+ * @pdev: Datapath pdev handle
+ * @ppdu: PPDU Descriptor
+ *
+ * Return: None
+ */
+static inline
+void dp_rx_mon_update_pdev_deter_stats(struct dp_pdev *pdev,
+				       struct cdp_rx_indication_ppdu *ppdu)
+{
+	if (!dp_is_subtype_data(ppdu->frame_ctrl))
+		return;
+
+	DP_STATS_INC(pdev,
+		     deter_stats.rx_su_cnt,
+		     1);
+}
 #else
 static inline void
 dp_ppdu_desc_user_rx_time_update(struct dp_pdev *pdev,
@@ -900,6 +919,11 @@ void dp_rx_mon_update_user_deter_stats(struct dp_pdev *pdev,
 				       struct cdp_rx_indication_ppdu *ppdu,
 				       struct cdp_rx_stats_ppdu_user *user)
 { }
+
+static inline
+void dp_rx_mon_update_pdev_deter_stats(struct dp_pdev *pdev,
+				       struct cdp_rx_indication_ppdu *ppdu)
+{ }
 #endif
 
 static void dp_rx_stats_update(struct dp_pdev *pdev,
@@ -1200,6 +1224,8 @@ dp_rx_handle_ppdu_stats(struct dp_soc *soc, struct dp_pdev *pdev,
 		if (!qdf_unlikely(qdf_nbuf_put_tail(ppdu_nbuf,
 				       sizeof(struct cdp_rx_indication_ppdu))))
 			return;
+		if (cdp_rx_ppdu->u.ppdu_type == HAL_RX_TYPE_SU)
+			dp_rx_mon_update_pdev_deter_stats(pdev, cdp_rx_ppdu);
 
 		dp_rx_stats_update(pdev, cdp_rx_ppdu);