diff --git a/dp/inc/cdp_txrx_stats_struct.h b/dp/inc/cdp_txrx_stats_struct.h
index f5c475d45b..2998a7fc1c 100644
--- a/dp/inc/cdp_txrx_stats_struct.h
+++ b/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;
diff --git a/dp/wifi3.0/be/dp_be_rx.c b/dp/wifi3.0/be/dp_be_rx.c
index 112ef7ec31..c4f403031f 100644
--- a/dp/wifi3.0/be/dp_be_rx.c
+++ b/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));
diff --git a/dp/wifi3.0/dp_internal.h b/dp/wifi3.0/dp_internal.h
index 1008ea3956..b6926c8837 100644
--- a/dp/wifi3.0/dp_internal.h
+++ b/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)
 
 /**
diff --git a/dp/wifi3.0/dp_main.c b/dp/wifi3.0/dp_main.c
index 51c2a58e6f..df60794109 100644
--- a/dp/wifi3.0/dp_main.c
+++ b/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;
 }
 
 /**
diff --git a/dp/wifi3.0/dp_rx.c b/dp/wifi3.0/dp_rx.c
index fec3be43a6..1fee71d4ad 100644
--- a/dp/wifi3.0/dp_rx.c
+++ b/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++;
 		}
 	}
diff --git a/dp/wifi3.0/dp_rx_err.c b/dp/wifi3.0/dp_rx_err.c
index 9104857a02..b4ff39b6bc 100644
--- a/dp/wifi3.0/dp_rx_err.c
+++ b/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,
diff --git a/dp/wifi3.0/dp_stats.c b/dp/wifi3.0/dp_stats.c
index 9971b1f7c8..e21ebb63e6 100644
--- a/dp/wifi3.0/dp_stats.c
+++ b/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",
diff --git a/dp/wifi3.0/dp_types.h b/dp/wifi3.0/dp_types.h
index 2f9d07c41f..9b36f06dc1 100644
--- a/dp/wifi3.0/dp_types.h
+++ b/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;
 
diff --git a/dp/wifi3.0/li/dp_li_rx.c b/dp/wifi3.0/li/dp_li_rx.c
index 6e67a3ddb5..3255ac1e0a 100644
--- a/dp/wifi3.0/li/dp_li_rx.c
+++ b/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;