qcacmn: Rx stats changes for BE HW vdev stats

Following peer stats are updated in per packet Rx path:
    to_stack
    multicast
    broadcast

In BE architecture, HW provides the support for basic vdev stats and
hence per packet stats updation of above parameters can be done only
when enhanced stats is enabled or HW vdev offload stats is disabled.

Avoiding per packet stats updation reduces CPU load and improves KPI.

Change-Id: Id7c11c025a8464951b615a7f7b006ce61db487fc
CRs-Fixed: 3067843

dp/inc/cdp_txrx_stats_struct.h

@@ -1342,6 +1342,8 @@ struct cdp_tx_stats {
  * @fcserr: rx MIC check failed (CCMP)
  * @pn_err: pn check failed
  * @oor_err: Rx OOR errors
+ * @jump_2k_err: 2k jump errors
+ * @rxdma_wifi_parse_err: rxdma wifi parse errors
  * @wme_ac_type[WME_AC_MAX]: Wireless Multimedia type Count
  * @reception_type[MAX_RECEPTION_TYPES]: Reception type os packets
  * @mcs_count[MAX_MCS]: mcs count
@@ -1387,6 +1389,8 @@ struct cdp_tx_stats {
  * @snr: SNR of received signal
  * @last_snr: Previous snr
  * @multipass_rx_pkt_drop: Dropped multipass rx pkt
+ * @peer_unauth_rx_pkt_drop: Unauth rx packet drops
+ * @policy_check_drop: policy check drops
  * @rx_mpdu_cnt: rx mpdu count per MCS rate
  * @nss_info: NSS 1,2, ...8
  * @mcs_info: MCS index
@@ -1427,6 +1431,8 @@ struct cdp_rx_stats {
 		uint32_t fcserr;
 		uint32_t pn_err;
 		uint32_t oor_err;
+		uint32_t jump_2k_err;
+		uint32_t rxdma_wifi_parse_err;
 	} err;
 
 	uint32_t wme_ac_type[WME_AC_MAX];
@@ -1471,6 +1477,8 @@ struct cdp_rx_stats {
 	uint8_t snr;
 	uint8_t last_snr;
 	uint32_t multipass_rx_pkt_drop;
+	uint32_t peer_unauth_rx_pkt_drop;
+	uint32_t policy_check_drop;
 	uint32_t rx_mpdu_cnt[MAX_MCS];
 	uint32_t nss_info:4,
 		 mcs_info:4,
@@ -1591,14 +1599,27 @@ struct cdp_tx_ingress_stats {
 	struct cdp_tso_stats tso_stats;
 };
 
+/* struct cdp_rx_ingress_stats - rx ingress stats
+ * @reo_rcvd_pkt: packets received at REO block
+ * @ null_q_desc_pkt: null queue desc pkt count
+ * @ routed_eapol_pkt: routed eapol pkt count
+ */
+struct cdp_rx_ingress_stats {
+	struct cdp_pkt_info reo_rcvd_pkt;
+	struct cdp_pkt_info null_q_desc_pkt;
+	struct cdp_pkt_info routed_eapol_pkt;
+};
+
 /* struct cdp_vdev_stats - vdev stats structure
  * @tx_i: ingress tx stats
+ * @rx_i: ingress rx stats
  * @tx: cdp tx stats
  * @rx: cdp rx stats
  * @tso_stats: tso stats
  */
 struct cdp_vdev_stats {
 	struct cdp_tx_ingress_stats tx_i;
+	struct cdp_rx_ingress_stats rx_i;
 	struct cdp_tx_stats tx;
 	struct cdp_rx_stats rx;
 	struct cdp_tso_stats tso_stats;
@@ -2229,6 +2250,7 @@ struct cdp_soc_stats {
  * @tcp_udp_csum_err: tcp/udp checksum errors
  * @buf_freelist: buffers added back in freelist
  * @tx_i: Tx Ingress stats
+ * @rx_i: Rx Ingress stats
  * @tx:CDP Tx Stats
  * @rx: CDP Rx Stats
  * @tx_comp_histogram: Number of Tx completions per interrupt
@@ -2285,6 +2307,7 @@ struct cdp_pdev_stats {
 
 	uint32_t buf_freelist;
 	struct cdp_tx_ingress_stats tx_i;
+	struct cdp_rx_ingress_stats rx_i;
 	struct cdp_tx_stats tx;
 	struct cdp_rx_stats rx;
 	struct cdp_hist_tx_comp tx_comp_histogram;

dp/wifi3.0/be/dp_be_rx.c

@@ -152,6 +152,7 @@ uint32_t dp_rx_process_be(struct dp_intr *int_ctx,
 	uint32_t rx_bufs_reaped[MAX_PDEV_CNT];
 	uint8_t mac_id = 0;
 	struct dp_pdev *rx_pdev;
+	bool enh_flag;
 	struct dp_srng *dp_rxdma_srng;
 	struct rx_desc_pool *rx_desc_pool;
 	struct dp_soc *soc = int_ctx->soc;
@@ -578,6 +579,8 @@ done:
 				 soc->wlan_cfg_ctx)))
 			qdf_nbuf_set_timestamp(nbuf);
 
+		enh_flag = rx_pdev->enhanced_stats_en;
+
 		tid_stats =
 		&rx_pdev->stats.tid_stats.tid_rx_stats[reo_ring_num][tid];
 
@@ -683,6 +686,7 @@ done:
 
 		if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
 			dp_rx_err("%pK: Policy Check Drop pkt", soc);
+			DP_STATS_INC(peer, rx.policy_check_drop, 1);
 			tid_stats->fail_cnt[POLICY_CHECK_DROP]++;
 			/* Drop & free packet */
 			qdf_nbuf_free(nbuf);
@@ -712,9 +716,8 @@ done:
 					qdf_nbuf_is_ipv4_wapi_pkt(nbuf);
 
 			if (!is_eapol) {
-				DP_STATS_INC(soc,
-					     rx.err.peer_unauth_rx_pkt_drop,
-					     1);
+				DP_STATS_INC(peer,
+					     rx.peer_unauth_rx_pkt_drop, 1);
 				qdf_nbuf_free(nbuf);
 				nbuf = next;
 				continue;
@@ -775,8 +778,8 @@ done:
 		DP_RX_LIST_APPEND(deliver_list_head,
 				  deliver_list_tail,
 				  nbuf);
-		DP_STATS_INC_PKT(peer, rx.to_stack, 1,
-				 QDF_NBUF_CB_RX_PKT_LEN(nbuf));
+		DP_PEER_TO_STACK_INCC_PKT(peer, 1, QDF_NBUF_CB_RX_PKT_LEN(nbuf),
+					  enh_flag);
 		if (qdf_unlikely(peer->in_twt))
 			DP_STATS_INC_PKT(peer, rx.to_stack_twt, 1,
 					 QDF_NBUF_CB_RX_PKT_LEN(nbuf));

dp/wifi3.0/dp_internal.h

@@ -768,6 +768,69 @@ void DP_PRINT_STATS(const char *fmt, ...);
 #define DP_STATS_AGGR_PKT(_handle_a, _handle_b, _field)
 #endif
 
+#if defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT) && \
+	defined(QCA_ENHANCED_STATS_SUPPORT)
+#define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en) || _cond) \
+		DP_STATS_INC_PKT(_handle, rx.to_stack, _count, _bytes); \
+}
+
+#define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en) || _cond) \
+		DP_STATS_DEC(_handle, rx.to_stack.num, _count); \
+}
+
+#define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en) || _cond) \
+		DP_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes); \
+}
+
+#define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en) || _cond) \
+		DP_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes); \
+}
+#elif defined(QCA_VDEV_STATS_HW_OFFLOAD_SUPPORT)
+#define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en)) \
+		DP_STATS_INC_PKT(_handle, rx.to_stack, _count, _bytes); \
+}
+
+#define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en)) \
+		DP_STATS_DEC(_handle, rx.to_stack.num, _count); \
+}
+
+#define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en)) \
+		DP_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes); \
+}
+
+#define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond) \
+{ \
+	if (!(_handle->hw_txrx_stats_en)) \
+		DP_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes); \
+}
+#else
+#define DP_PEER_TO_STACK_INCC_PKT(_handle, _count, _bytes, _cond) \
+	DP_STATS_INC_PKT(_handle, rx.to_stack, _count, _bytes);
+
+#define DP_PEER_TO_STACK_DECC(_handle, _count, _cond) \
+	DP_STATS_DEC(_handle, rx.to_stack.num, _count);
+
+#define DP_PEER_MC_INCC_PKT(_handle, _count, _bytes, _cond) \
+	DP_STATS_INC_PKT(_handle, rx.multicast, _count, _bytes);
+
+#define DP_PEER_BC_INCC_PKT(_handle, _count, _bytes, _cond) \
+	DP_STATS_INC_PKT(_handle, rx.bcast, _count, _bytes);
+#endif
+
 #ifdef ENABLE_DP_HIST_STATS
 #define DP_HIST_INIT() \
 	uint32_t num_of_packets[MAX_PDEV_CNT] = {0};
@@ -1160,10 +1223,16 @@ static inline void dp_update_pdev_stats(struct dp_pdev *tgtobj,
 			srcobj->tx.dropped.fw_reason3;
 	tgtobj->stats.tx.dropped.age_out += srcobj->tx.dropped.age_out;
 	tgtobj->stats.rx.err.mic_err += srcobj->rx.err.mic_err;
+	tgtobj->stats.rx.err.decrypt_err += srcobj->rx.err.decrypt_err;
+	tgtobj->stats.rx.err.fcserr += srcobj->rx.err.fcserr;
+	tgtobj->stats.rx.err.pn_err += srcobj->rx.err.pn_err;
+	tgtobj->stats.rx.err.oor_err += srcobj->rx.err.oor_err;
+	tgtobj->stats.rx.err.jump_2k_err += srcobj->rx.err.jump_2k_err;
+	tgtobj->stats.rx.err.rxdma_wifi_parse_err +=
+				srcobj->rx.err.rxdma_wifi_parse_err;
 	if (srcobj->rx.snr != 0)
 		tgtobj->stats.rx.snr = srcobj->rx.snr;
 	tgtobj->stats.rx.rx_rate = srcobj->rx.rx_rate;
-	tgtobj->stats.rx.err.decrypt_err += srcobj->rx.err.decrypt_err;
 	tgtobj->stats.rx.non_ampdu_cnt += srcobj->rx.non_ampdu_cnt;
 	tgtobj->stats.rx.amsdu_cnt += srcobj->rx.ampdu_cnt;
 	tgtobj->stats.rx.non_amsdu_cnt += srcobj->rx.non_amsdu_cnt;
@@ -1209,6 +1278,22 @@ static inline void dp_update_pdev_stats(struct dp_pdev *tgtobj,
 	tgtobj->stats.rx.mec_drop.bytes += srcobj->rx.mec_drop.bytes;
 	tgtobj->stats.rx.multipass_rx_pkt_drop +=
 		srcobj->rx.multipass_rx_pkt_drop;
+	tgtobj->stats.rx.peer_unauth_rx_pkt_drop +=
+		srcobj->rx.peer_unauth_rx_pkt_drop;
+	tgtobj->stats.rx.policy_check_drop +=
+		srcobj->rx.policy_check_drop;
+}
+
+static inline void dp_update_vdev_ingress_stats(struct dp_vdev *tgtobj)
+{
+	tgtobj->stats.tx_i.dropped.dropped_pkt.num =
+		tgtobj->stats.tx_i.dropped.dma_error +
+		tgtobj->stats.tx_i.dropped.ring_full +
+		tgtobj->stats.tx_i.dropped.enqueue_fail +
+		tgtobj->stats.tx_i.dropped.fail_per_pkt_vdev_id_check +
+		tgtobj->stats.tx_i.dropped.desc_na.num +
+		tgtobj->stats.tx_i.dropped.res_full +
+		tgtobj->stats.tx_i.dropped.headroom_insufficient;
 }
 
 static inline void dp_update_pdev_ingress_stats(struct dp_pdev *tgtobj,
@@ -1249,13 +1334,18 @@ static inline void dp_update_pdev_ingress_stats(struct dp_pdev *tgtobj,
 	DP_STATS_AGGR(tgtobj, srcobj, tx_i.mesh.exception_fw);
 	DP_STATS_AGGR(tgtobj, srcobj, tx_i.mesh.completion_fw);
 
+	DP_STATS_AGGR_PKT(tgtobj, srcobj, rx_i.reo_rcvd_pkt);
+	DP_STATS_AGGR_PKT(tgtobj, srcobj, rx_i.null_q_desc_pkt);
+	DP_STATS_AGGR_PKT(tgtobj, srcobj, rx_i.routed_eapol_pkt);
+
 	tgtobj->stats.tx_i.dropped.dropped_pkt.num =
 		tgtobj->stats.tx_i.dropped.dma_error +
 		tgtobj->stats.tx_i.dropped.ring_full +
 		tgtobj->stats.tx_i.dropped.enqueue_fail +
 		tgtobj->stats.tx_i.dropped.fail_per_pkt_vdev_id_check +
 		tgtobj->stats.tx_i.dropped.desc_na.num +
-		tgtobj->stats.tx_i.dropped.res_full;
+		tgtobj->stats.tx_i.dropped.res_full +
+		tgtobj->stats.tx_i.dropped.headroom_insufficient;
 
 }
 
@@ -1383,10 +1473,16 @@ static inline void dp_update_vdev_stats(struct dp_soc *soc,
 	tgtobj->tx.mpdu_success_with_retries +=
 			srcobj->stats.tx.mpdu_success_with_retries;
 	tgtobj->rx.err.mic_err += srcobj->stats.rx.err.mic_err;
+	tgtobj->rx.err.decrypt_err += srcobj->stats.rx.err.decrypt_err;
+	tgtobj->rx.err.fcserr += srcobj->stats.rx.err.fcserr;
+	tgtobj->rx.err.pn_err += srcobj->stats.rx.err.pn_err;
+	tgtobj->rx.err.oor_err += srcobj->stats.rx.err.oor_err;
+	tgtobj->rx.err.jump_2k_err += srcobj->stats.rx.err.jump_2k_err;
+	tgtobj->rx.err.rxdma_wifi_parse_err +=
+				srcobj->stats.rx.err.rxdma_wifi_parse_err;
 	if (srcobj->stats.rx.snr != 0)
 		tgtobj->rx.snr = srcobj->stats.rx.snr;
 	tgtobj->rx.rx_rate = srcobj->stats.rx.rx_rate;
-	tgtobj->rx.err.decrypt_err += srcobj->stats.rx.err.decrypt_err;
 	tgtobj->rx.non_ampdu_cnt += srcobj->stats.rx.non_ampdu_cnt;
 	tgtobj->rx.amsdu_cnt += srcobj->stats.rx.ampdu_cnt;
 	tgtobj->rx.non_amsdu_cnt += srcobj->stats.rx.non_amsdu_cnt;
@@ -1431,6 +1527,10 @@ static inline void dp_update_vdev_stats(struct dp_soc *soc,
 	tgtobj->rx.mec_drop.bytes += srcobj->stats.rx.mec_drop.bytes;
 	tgtobj->rx.multipass_rx_pkt_drop +=
 		srcobj->stats.rx.multipass_rx_pkt_drop;
+	tgtobj->rx.peer_unauth_rx_pkt_drop +=
+		srcobj->stats.rx.peer_unauth_rx_pkt_drop;
+	tgtobj->rx.policy_check_drop +=
+		srcobj->stats.rx.policy_check_drop;
 }
 
 #define DP_UPDATE_STATS(_tgtobj, _srcobj)	\
@@ -1497,10 +1597,15 @@ static inline void dp_update_vdev_stats(struct dp_soc *soc,
 		DP_STATS_AGGR(_tgtobj, _srcobj, tx.dropped.age_out); \
 								\
 		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.mic_err); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.decrypt_err); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.fcserr); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.pn_err); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.oor_err); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.jump_2k_err); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.rxdma_wifi_parse_err); \
 		if (_srcobj->stats.rx.snr != 0) \
 			DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.snr); \
 		DP_STATS_UPD_STRUCT(_tgtobj, _srcobj, rx.rx_rate); \
-		DP_STATS_AGGR(_tgtobj, _srcobj, rx.err.decrypt_err); \
 		DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_ampdu_cnt); \
 		DP_STATS_AGGR(_tgtobj, _srcobj, rx.ampdu_cnt); \
 		DP_STATS_AGGR(_tgtobj, _srcobj, rx.non_amsdu_cnt); \
@@ -1528,6 +1633,8 @@ static inline void dp_update_vdev_stats(struct dp_soc *soc,
 		_tgtobj->stats.tx.last_ack_rssi =	\
 			_srcobj->stats.tx.last_ack_rssi; \
 		DP_STATS_AGGR(_tgtobj, _srcobj, rx.multipass_rx_pkt_drop); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.peer_unauth_rx_pkt_drop); \
+		DP_STATS_AGGR(_tgtobj, _srcobj, rx.policy_check_drop); \
 	}  while (0)
 
 /**

dp/wifi3.0/dp_main.c

@@ -8228,6 +8228,8 @@ void dp_aggregate_vdev_stats(struct dp_vdev *vdev,
 
 	soc = vdev->pdev->soc;
 
+	dp_update_vdev_ingress_stats(vdev);
+
 	qdf_mem_copy(vdev_stats, &vdev->stats, sizeof(vdev->stats));
 
 	dp_vdev_iterate_peer(vdev, dp_update_vdev_stats, vdev_stats,
@@ -8323,12 +8325,31 @@ static QDF_STATUS dp_vdev_getstats(struct cdp_vdev *vdev_handle,
 			    vdev_stats->tx_i.mcast_en.dropped_send_fail +
 			    vdev_stats->tx.nawds_mcast_drop;
 
-	stats->rx_packets = vdev_stats->rx.unicast.num +
-		vdev_stats->rx.multicast.num +
-		vdev_stats->rx.bcast.num;
-	stats->rx_bytes = vdev_stats->rx.unicast.bytes +
-		vdev_stats->rx.multicast.bytes +
-		vdev_stats->rx.bcast.bytes;
+	if (!wlan_cfg_get_vdev_stats_hw_offload_config(soc->wlan_cfg_ctx)) {
+		stats->rx_packets = vdev_stats->rx.to_stack.num;
+		stats->rx_bytes = vdev_stats->rx.to_stack.bytes;
+	} else {
+		stats->rx_packets = vdev_stats->rx_i.reo_rcvd_pkt.num +
+				    vdev_stats->rx_i.null_q_desc_pkt.num +
+				    vdev_stats->rx_i.routed_eapol_pkt.num;
+		stats->rx_bytes = vdev_stats->rx_i.reo_rcvd_pkt.bytes +
+				  vdev_stats->rx_i.null_q_desc_pkt.bytes +
+				  vdev_stats->rx_i.routed_eapol_pkt.bytes;
+	}
+
+	stats->rx_errors = vdev_stats->rx.err.mic_err +
+			   vdev_stats->rx.err.decrypt_err +
+			   vdev_stats->rx.err.fcserr +
+			   vdev_stats->rx.err.pn_err +
+			   vdev_stats->rx.err.oor_err +
+			   vdev_stats->rx.err.jump_2k_err +
+			   vdev_stats->rx.err.rxdma_wifi_parse_err;
+
+	stats->rx_dropped = vdev_stats->rx.mec_drop.num +
+			    vdev_stats->rx.multipass_rx_pkt_drop +
+			    vdev_stats->rx.peer_unauth_rx_pkt_drop +
+			    vdev_stats->rx.policy_check_drop +
+			    vdev_stats->rx.nawds_mcast_drop;
 
 	qdf_mem_free(vdev_stats);
 
@@ -8361,16 +8382,27 @@ static void dp_pdev_getstats(struct cdp_pdev *pdev_handle,
 			    pdev->stats.tx.nawds_mcast_drop +
 			    pdev->stats.tso_stats.dropped_host.num;
 
-	stats->rx_packets = pdev->stats.rx.unicast.num +
-		pdev->stats.rx.multicast.num +
-		pdev->stats.rx.bcast.num;
-	stats->rx_bytes = pdev->stats.rx.unicast.bytes +
-		pdev->stats.rx.multicast.bytes +
-		pdev->stats.rx.bcast.bytes;
+	if (!wlan_cfg_get_vdev_stats_hw_offload_config(pdev->soc->wlan_cfg_ctx)) {
+		stats->rx_packets = pdev->stats.rx.to_stack.num;
+		stats->rx_bytes = pdev->stats.rx.to_stack.bytes;
+	} else {
+		stats->rx_packets = pdev->stats.rx_i.reo_rcvd_pkt.num +
+				    pdev->stats.rx_i.null_q_desc_pkt.num +
+				    pdev->stats.rx_i.routed_eapol_pkt.num;
+		stats->rx_bytes = pdev->stats.rx_i.reo_rcvd_pkt.bytes +
+				  pdev->stats.rx_i.null_q_desc_pkt.bytes +
+				  pdev->stats.rx_i.routed_eapol_pkt.bytes;
+	}
+
 	stats->rx_errors = pdev->stats.err.ip_csum_err +
 		pdev->stats.err.tcp_udp_csum_err +
 		pdev->stats.rx.err.mic_err +
 		pdev->stats.rx.err.decrypt_err +
+		pdev->stats.rx.err.fcserr +
+		pdev->stats.rx.err.pn_err +
+		pdev->stats.rx.err.oor_err +
+		pdev->stats.rx.err.jump_2k_err +
+		pdev->stats.rx.err.rxdma_wifi_parse_err +
 		pdev->stats.err.rxdma_error +
 		pdev->stats.err.reo_error;
 	stats->rx_dropped = pdev->stats.dropped.msdu_not_done +
@@ -8378,7 +8410,12 @@ static void dp_pdev_getstats(struct cdp_pdev *pdev_handle,
 		pdev->stats.dropped.mesh_filter +
 		pdev->stats.dropped.wifi_parse +
 		pdev->stats.dropped.mon_rx_drop +
-		pdev->stats.dropped.mon_radiotap_update_err;
+		pdev->stats.dropped.mon_radiotap_update_err +
+		pdev->stats.rx.mec_drop.num +
+		pdev->stats.rx.multipass_rx_pkt_drop +
+		pdev->stats.rx.peer_unauth_rx_pkt_drop +
+		pdev->stats.rx.policy_check_drop +
+		pdev->stats.rx.nawds_mcast_drop;
 }
 
 /**

dp/wifi3.0/dp_rx.c

@@ -1595,7 +1595,8 @@ dp_rx_validate_rx_callbacks(struct dp_soc *soc,
 		} else {
 			num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev,
 							nbuf_head);
-			DP_STATS_DEC(peer, rx.to_stack.num, num_nbuf);
+			DP_PEER_TO_STACK_DECC(peer, num_nbuf,
+					      vdev->pdev->enhanced_stats_en);
 		}
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -1686,6 +1687,7 @@ void dp_rx_msdu_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
 	bool is_ampdu, is_not_amsdu;
 	uint32_t sgi, mcs, tid, nss, bw, reception_type, pkt_type;
 	struct dp_vdev *vdev = peer->vdev;
+	bool enh_flag;
 	qdf_ether_header_t *eh;
 	uint16_t msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
 
@@ -1702,10 +1704,11 @@ void dp_rx_msdu_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
 	if (qdf_unlikely(qdf_nbuf_is_da_mcbc(nbuf) &&
 			 (vdev->rx_decap_type == htt_cmn_pkt_type_ethernet))) {
 		eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
-		DP_STATS_INC_PKT(peer, rx.multicast, 1, msdu_len);
+		enh_flag = vdev->pdev->enhanced_stats_en;
+		DP_PEER_MC_INCC_PKT(peer, 1, msdu_len, enh_flag);
 		tid_stats->mcast_msdu_cnt++;
 		if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost)) {
-			DP_STATS_INC_PKT(peer, rx.bcast, 1, msdu_len);
+			DP_PEER_BC_INCC_PKT(peer, 1, msdu_len, enh_flag);
 			tid_stats->bcast_msdu_cnt++;
 		}
 	}

dp/wifi3.0/dp_rx_err.c

@@ -1232,6 +1232,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
 	struct hal_rx_msdu_metadata msdu_metadata;
 	uint16_t sa_idx = 0;
 	bool is_eapol;
+	bool enh_flag;
 
 	qdf_nbuf_set_rx_chfrag_start(nbuf,
 				hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
@@ -1332,6 +1333,8 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
 		qdf_nbuf_pull_head(nbuf, (msdu_metadata.l3_hdr_pad +
 				   soc->rx_pkt_tlv_size));
 
+	DP_STATS_INC_PKT(vdev, rx_i.null_q_desc_pkt, 1, qdf_nbuf_len(nbuf));
+
 	dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, NULL, 0, 1);
 
 	if (hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc, rx_tlv_hdr)) {
@@ -1373,6 +1376,7 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
 
 	if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
 		dp_err_rl("mcast Policy Check Drop pkt");
+		DP_STATS_INC(peer, rx.policy_check_drop, 1);
 		goto drop_nbuf;
 	}
 	/* WDS Source Port Learning */
@@ -1425,10 +1429,10 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
 		qdf_nbuf_set_next(nbuf, NULL);
 		dp_rx_deliver_raw(vdev, nbuf, peer);
 	} else {
+		enh_flag = vdev->pdev->enhanced_stats_en;
 		qdf_nbuf_set_next(nbuf, NULL);
-		DP_STATS_INC_PKT(peer, rx.to_stack, 1,
-				 qdf_nbuf_len(nbuf));
-
+		DP_PEER_TO_STACK_INCC_PKT(peer, 1, qdf_nbuf_len(nbuf),
+					  enh_flag);
 		/*
 		 * Update the protocol tag in SKB based on
 		 * CCE metadata
@@ -1445,12 +1449,12 @@ dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
 				 soc->hal_soc, rx_tlv_hdr) &&
 				 (vdev->rx_decap_type ==
 				  htt_cmn_pkt_type_ethernet))) {
-			DP_STATS_INC_PKT(peer, rx.multicast, 1,
-					 qdf_nbuf_len(nbuf));
+			DP_PEER_MC_INCC_PKT(peer, 1, qdf_nbuf_len(nbuf),
+					    enh_flag);
 
 			if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost))
-				DP_STATS_INC_PKT(peer, rx.bcast, 1,
-						 qdf_nbuf_len(nbuf));
+				DP_PEER_BC_INCC_PKT(peer, 1, qdf_nbuf_len(nbuf),
+						    enh_flag);
 		}
 
 		qdf_nbuf_set_exc_frame(nbuf, 1);
@@ -1844,6 +1848,9 @@ dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
 			(qdf_ether_header_t *)qdf_nbuf_data(nbuf);
 		if (qdf_mem_cmp(eh->ether_dhost, &vdev->mac_addr.raw[0],
 				QDF_MAC_ADDR_SIZE) == 0) {
+			DP_STATS_INC_PKT(vdev, rx_i.routed_eapol_pkt, 1,
+					 qdf_nbuf_len(nbuf));
+
 			/*
 			 * Update the protocol tag in SKB based on
 			 * CCE metadata.
@@ -1854,7 +1861,8 @@ dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
 			/* Update the flow tag in SKB based on FSE metadata */
 			dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr,
 					      true);
-			DP_STATS_INC(peer, rx.to_stack.num, 1);
+			DP_PEER_TO_STACK_INCC_PKT(peer, 1, qdf_nbuf_len(nbuf),
+						  vdev->pdev->enhanced_stats_en);
 			qdf_nbuf_set_exc_frame(nbuf, 1);
 			qdf_nbuf_set_next(nbuf, NULL);
 
@@ -2725,6 +2733,11 @@ done:
 				/* TODO */
 				/* Add per error code accounting */
 				case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
+					if (peer)
+						DP_STATS_INC(peer,
+							     rx.err.jump_2k_err,
+							     1);
+
 					pool_id = wbm_err_info.pool_id;
 
 					if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
@@ -2809,6 +2822,11 @@ done:
 				case HAL_RXDMA_ERR_UNENCRYPTED:
 
 				case HAL_RXDMA_ERR_WIFI_PARSE:
+					if (peer)
+						DP_STATS_INC(peer,
+							     rx.err.rxdma_wifi_parse_err,
+							     1);
+
 					pool_id = wbm_err_info.pool_id;
 					dp_rx_process_rxdma_err(soc, nbuf,
 								rx_tlv_hdr,

dp/wifi3.0/dp_stats.c

@@ -5826,6 +5826,10 @@ void dp_print_peer_stats(struct dp_peer *peer)
 		       peer->stats.rx.err.pn_err);
 	DP_PRINT_STATS("Errors: OOR Errors = %d",
 		       peer->stats.rx.err.oor_err);
+	DP_PRINT_STATS("Errors: 2k Jump Errors = %d",
+		       peer->stats.rx.err.jump_2k_err);
+	DP_PRINT_STATS("Errors: RXDMA Wifi Parse Errors = %d",
+		       peer->stats.rx.err.rxdma_wifi_parse_err);
 	DP_PRINT_STATS("Msdu's Received As Part of Ampdu = %d",
 		       peer->stats.rx.non_ampdu_cnt);
 	DP_PRINT_STATS("Msdu's Recived As Ampdu = %d",
@@ -5910,6 +5914,10 @@ void dp_print_peer_stats(struct dp_peer *peer)
 		       peer->stats.rx.rx_data_rate);
 	DP_PRINT_STATS("Multipass Rx Packet Drop = %d",
 		       peer->stats.rx.multipass_rx_pkt_drop);
+	DP_PRINT_STATS("Peer Unauth Rx Packet Drop = %d",
+		       peer->stats.rx.peer_unauth_rx_pkt_drop);
+	DP_PRINT_STATS("Policy Check Rx Packet Drop = %d",
+		       peer->stats.rx.policy_check_drop);
 
 	dp_peer_print_rx_delay_stats(pdev, peer);
 }
@@ -6383,6 +6391,10 @@ dp_print_pdev_rx_stats(struct dp_pdev *pdev)
 		       pdev->stats.rx.mec_drop.num);
 	DP_PRINT_STATS("	Bytes = %llu",
 		       pdev->stats.rx.mec_drop.bytes);
+	DP_PRINT_STATS("	peer_unauth_drop = %u",
+		       pdev->stats.rx.peer_unauth_rx_pkt_drop);
+	DP_PRINT_STATS("	policy_check_drop = %u",
+		       pdev->stats.rx.policy_check_drop);
 	DP_PRINT_STATS("Sent To Stack:");
 	DP_PRINT_STATS("	Packets = %u",
 		       pdev->stats.rx.to_stack.num);
@@ -6609,8 +6621,6 @@ dp_print_soc_rx_stats(struct dp_soc *soc)
 		       soc->stats.rx.err.defrag_peer_uninit);
 	DP_PRINT_STATS("Pkts delivered no peer = %d",
 		       soc->stats.rx.err.pkt_delivered_no_peer);
-	DP_PRINT_STATS("Pkts drop due to no peer auth :%d",
-		       soc->stats.rx.err.peer_unauth_rx_pkt_drop);
 	DP_PRINT_STATS("Invalid Pdev = %d",
 		       soc->stats.rx.err.invalid_pdev);
 	DP_PRINT_STATS("Invalid Peer = %d",

dp/wifi3.0/dp_types.h

@@ -1143,8 +1143,6 @@ struct dp_soc_stats {
 			uint32_t dup_refill_link_desc;
 			/* Incorrect msdu continuation bit in MSDU desc */
 			uint32_t msdu_continuation_err;
-			/* Non Eapol packet drop count due to peer not authorized  */
-			uint32_t peer_unauth_rx_pkt_drop;
 			/* count of start sequence (ssn) updates */
 			uint32_t ssn_update_count;
 			/* count of bar handling fail */
@@ -2590,6 +2588,9 @@ struct dp_pdev {
 	 */
 	bool is_pdev_down;
 
+	/* Enhanced Stats is enabled */
+	bool enhanced_stats_en;
+
 	/* Second ring used to replenish rx buffers */
 	struct dp_srng rx_refill_buf_ring2;
 
@@ -2639,9 +2640,6 @@ struct dp_pdev {
 	/* Global RX decap mode for the device */
 	enum htt_pkt_type rx_decap_mode;
 
-	/* Enhanced Stats is enabled */
-	bool enhanced_stats_en;
-
 	qdf_atomic_t num_tx_outstanding;
 	int32_t tx_descs_max;
 

dp/wifi3.0/li/dp_li_rx.c

@@ -771,6 +771,7 @@ done:
 
 		if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
 			dp_rx_err("%pK: Policy Check Drop pkt", soc);
+			DP_STATS_INC(peer, rx.policy_check_drop, 1);
 			tid_stats->fail_cnt[POLICY_CHECK_DROP]++;
 			/* Drop & free packet */
 			qdf_nbuf_free(nbuf);
@@ -800,9 +801,8 @@ done:
 					qdf_nbuf_is_ipv4_wapi_pkt(nbuf);
 
 			if (!is_eapol) {
-				DP_STATS_INC(soc,
-					     rx.err.peer_unauth_rx_pkt_drop,
-					     1);
+				DP_STATS_INC(peer,
+					     rx.peer_unauth_rx_pkt_drop, 1);
 				qdf_nbuf_free(nbuf);
 				nbuf = next;
 				continue;