qcacmn: Monitor code segregation

- Features common to both Li and BE and
  their APIs are retained files at dp/wifi3.0/monitor.
- New monitor ops are introduced if there
  is a requirement for divergence of API.
- Diverged API definitions for 1.0 are captured
  in this change.

All of code in below files are moved to 1.0
- dp_rx_mon_dest.c -> 1.0/dp_rx_mon_dest_1.0.c
- dp_rx_mon_status -> 1.0/dp_rx_mon_status_1.0.c

Only Li and HMT specific are moved for below file
- dp_mon_filter.c -> 1.0/dp_mon_filter_1.0.c
- dp_mon.c -> 1.0/dp_mon_1.0.c

Change-Id: I44d163b27565b86068d80e1d97ec11d0b4a081d4
CRs-Fixed: 2991248

dp/inc/cdp_txrx_ops.h

@@ -866,6 +866,8 @@ struct cdp_mon_ops {
 	/* Configure full monitor mode */
 	QDF_STATUS
 		(*config_full_mon_mode)(struct cdp_soc_t *soc, uint8_t val);
+	QDF_STATUS (*soc_config_full_mon_mode)(struct cdp_pdev *cdp_pdev,
+					       uint8_t val);
 };
 
 struct cdp_host_stats_ops {

dp/wifi3.0/dp_rx_buffer_pool.c

@@ -19,6 +19,7 @@
 #include "dp_rx_buffer_pool.h"
 #include "dp_ipa.h"
 #ifdef WLAN_FEATURE_RX_PREALLOC_BUFFER_POOL
+#include "dp_mon.h"
 #include "dp_rx_mon.h"
 #endif
 

dp/wifi3.0/monitor/1.0/dp_mon_1.0.c

@@ -13,3 +13,3362 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
+#include <dp_types.h>
+#include "dp_rx.h"
+#include "dp_peer.h"
+#include <dp_htt.h>
+#include <dp_mon_filter.h>
+#include <dp_mon.h>
+#include <dp_rx_mon.h>
+#include <dp_rx_mon_1.0.h>
+#include <dp_mon_1.0.h>
+#include <dp_mon_filter_1.0.h>
+
+#include "htt_ppdu_stats.h"
+#if defined(DP_CON_MON)
+#ifndef REMOVE_PKT_LOG
+#include <pktlog_ac_api.h>
+#include <pktlog_ac.h>
+#endif
+#endif
+#ifdef FEATURE_PERPKT_INFO
+#include "dp_ratetable.h"
+#endif
+
+#ifdef WLAN_TX_PKT_CAPTURE_ENH
+#include "dp_tx_capture.h"
+#endif
+
+#define HTT_MGMT_CTRL_TLV_HDR_RESERVERD_LEN 16
+#define HTT_TLV_HDR_LEN HTT_T2H_EXT_STATS_CONF_TLV_HDR_SIZE
+#define HTT_SHIFT_UPPER_TIMESTAMP 32
+#define HTT_MASK_UPPER_TIMESTAMP 0xFFFFFFFF00000000
+
+#ifndef WLAN_TX_PKT_CAPTURE_ENH
+static inline void
+dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
+					   void *data,
+					   uint32_t ppdu_id,
+					   uint32_t size)
+{
+}
+#endif
+
+extern QDF_STATUS dp_srng_alloc(struct dp_soc *soc, struct dp_srng *srng,
+				int ring_type, uint32_t num_entries,
+				bool cached);
+extern void dp_srng_free(struct dp_soc *soc, struct dp_srng *srng);
+extern QDF_STATUS dp_srng_init(struct dp_soc *soc, struct dp_srng *srng,
+			       int ring_type, int ring_num, int mac_id);
+extern void dp_srng_deinit(struct dp_soc *soc, struct dp_srng *srng,
+			   int ring_type, int ring_num);
+
+extern enum timer_yield_status
+dp_should_timer_irq_yield(struct dp_soc *soc, uint32_t work_done,
+			  uint64_t start_time);
+
+#ifdef QCA_SUPPORT_FULL_MON
+static QDF_STATUS
+dp_config_full_mon_mode(struct cdp_soc_t *soc_handle,
+			uint8_t val)
+{
+	struct dp_soc *soc = (struct dp_soc *)soc_handle;
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+
+	mon_soc->full_mon_mode = val;
+	dp_cdp_err("Configure full monitor mode val: %d ", val);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+dp_soc_config_full_mon_mode(struct cdp_pdev *cdp_pdev, uint8_t val)
+{
+	struct dp_pdev *pdev = (struct dp_pdev *)cdp_pdev;
+	struct dp_soc *soc = pdev->soc;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+
+	if (!mon_soc->full_mon_mode)
+		return QDF_STATUS_SUCCESS;
+
+	if ((htt_h2t_full_mon_cfg(soc->htt_handle,
+				  pdev->pdev_id,
+				  val)) != QDF_STATUS_SUCCESS) {
+		status = QDF_STATUS_E_FAILURE;
+	}
+
+	return status;
+}
+#else
+static inline QDF_STATUS
+dp_config_full_mon_mode(struct cdp_soc_t *soc_handle,
+			uint8_t val)
+{
+	return 0;
+}
+
+static inline QDF_STATUS
+dp_soc_config_full_mon_mode(struct cdp_pdev *cdp_pdev,
+			    uint8_t val)
+{
+	return 0;
+}
+#endif
+
+#if !defined(DISABLE_MON_CONFIG)
+void dp_flush_monitor_rings(struct dp_soc *soc)
+{
+	struct dp_pdev *pdev = soc->pdev_list[0];
+	hal_soc_handle_t hal_soc = soc->hal_soc;
+	uint32_t lmac_id;
+	uint32_t hp, tp;
+	uint8_t dp_intr_id;
+	int budget;
+	void *mon_dst_srng;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	/* Reset monitor filters before reaping the ring*/
+	qdf_spin_lock_bh(&mon_pdev->mon_lock);
+	dp_mon_filter_reset_mon_mode(pdev);
+	if (dp_mon_filter_update(pdev) != QDF_STATUS_SUCCESS)
+		dp_info("failed to reset monitor filters");
+	qdf_spin_unlock_bh(&mon_pdev->mon_lock);
+
+	if (mon_pdev->mon_chan_band == REG_BAND_UNKNOWN)
+		return;
+
+	lmac_id = pdev->ch_band_lmac_id_mapping[mon_pdev->mon_chan_band];
+	if (qdf_unlikely(lmac_id == DP_MON_INVALID_LMAC_ID))
+		return;
+
+	dp_intr_id = soc->mon_intr_id_lmac_map[lmac_id];
+	mon_dst_srng = dp_rxdma_get_mon_dst_ring(pdev, lmac_id);
+
+	/* reap full ring */
+	budget = wlan_cfg_get_dma_mon_stat_ring_size(pdev->wlan_cfg_ctx);
+
+	hal_get_sw_hptp(hal_soc, mon_dst_srng, &tp, &hp);
+	dp_info("Before reap: Monitor DST ring HP %u TP %u", hp, tp);
+
+	dp_mon_process(soc, &soc->intr_ctx[dp_intr_id], lmac_id, budget);
+
+	hal_get_sw_hptp(hal_soc, mon_dst_srng, &tp, &hp);
+	dp_info("After reap: Monitor DST ring HP %u TP %u", hp, tp);
+}
+
+static
+void dp_mon_rings_deinit_1_0(struct dp_pdev *pdev)
+{
+	int mac_id = 0;
+	struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx;
+	struct dp_soc *soc = pdev->soc;
+
+	pdev_cfg_ctx = pdev->wlan_cfg_ctx;
+
+	for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
+		int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id,
+							 pdev->pdev_id);
+
+		dp_srng_deinit(soc, &soc->rxdma_mon_status_ring[lmac_id],
+			       RXDMA_MONITOR_STATUS, 0);
+
+		dp_mon_dest_rings_deinit(pdev, lmac_id);
+	}
+}
+
+static
+void dp_mon_rings_free_1_0(struct dp_pdev *pdev)
+{
+	int mac_id = 0;
+	struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx;
+	struct dp_soc *soc = pdev->soc;
+
+	pdev_cfg_ctx = pdev->wlan_cfg_ctx;
+
+	for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
+		int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id,
+							 pdev->pdev_id);
+
+		dp_srng_free(soc, &soc->rxdma_mon_status_ring[lmac_id]);
+
+		dp_mon_dest_rings_free(pdev, lmac_id);
+	}
+}
+
+static
+QDF_STATUS dp_mon_rings_init_1_0(struct dp_soc *soc, struct dp_pdev *pdev)
+{
+	int mac_id = 0;
+	struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx;
+
+	pdev_cfg_ctx = pdev->wlan_cfg_ctx;
+
+	for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
+		int lmac_id = dp_get_lmac_id_for_pdev_id(soc, mac_id,
+							 pdev->pdev_id);
+
+		if (dp_srng_init(soc, &soc->rxdma_mon_status_ring[lmac_id],
+				 RXDMA_MONITOR_STATUS, 0, lmac_id)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_status_ring",
+				   soc);
+			goto fail1;
+		}
+
+		if (dp_mon_dest_rings_init(pdev, lmac_id))
+			goto fail1;
+	}
+	return QDF_STATUS_SUCCESS;
+
+fail1:
+	dp_mon_rings_deinit_1_0(pdev);
+	return QDF_STATUS_E_NOMEM;
+}
+
+static
+QDF_STATUS dp_mon_rings_alloc_1_0(struct dp_soc *soc, struct dp_pdev *pdev)
+{
+	int mac_id = 0;
+	int entries;
+	struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx;
+
+	pdev_cfg_ctx = pdev->wlan_cfg_ctx;
+
+	for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
+		int lmac_id =
+		dp_get_lmac_id_for_pdev_id(soc, mac_id, pdev->pdev_id);
+		entries = wlan_cfg_get_dma_mon_stat_ring_size(pdev_cfg_ctx);
+		if (dp_srng_alloc(soc, &soc->rxdma_mon_status_ring[lmac_id],
+				  RXDMA_MONITOR_STATUS, entries, 0)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_status_ring",
+				   soc);
+			goto fail1;
+		}
+
+		if (dp_mon_dest_rings_alloc(pdev, lmac_id))
+			goto fail1;
+	}
+	return QDF_STATUS_SUCCESS;
+
+fail1:
+	dp_mon_rings_free_1_0(pdev);
+	return QDF_STATUS_E_NOMEM;
+}
+#else
+static
+void dp_mon_rings_deinit_1_0(struct dp_pdev *pdev)
+{
+}
+
+static
+void dp_mon_rings_free_1_0(struct dp_pdev *pdev)
+{
+}
+
+static
+QDF_STATUS dp_mon_rings_init_1_0(struct dp_soc *soc, struct dp_pdev *pdev)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static
+QDF_STATUS dp_mon_rings_alloc_1_0(struct dp_soc *soc, struct dp_pdev *pdev)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+#endif
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+void dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev)
+{
+	uint32_t mac_id;
+	uint32_t mac_for_pdev;
+	struct dp_srng *mon_buf_ring;
+	uint32_t num_entries;
+	struct dp_soc *soc = pdev->soc;
+
+	/* If delay monitor replenish is disabled, allocate link descriptor
+	 * monitor ring buffers of ring size.
+	 */
+	if (!wlan_cfg_is_delay_mon_replenish(soc->wlan_cfg_ctx)) {
+		dp_vdev_set_monitor_mode_rings(pdev, false);
+	} else {
+		for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
+			mac_for_pdev =
+				dp_get_lmac_id_for_pdev_id(pdev->soc,
+							   mac_id,
+							   pdev->pdev_id);
+
+			dp_rx_pdev_mon_buf_buffers_alloc(pdev, mac_for_pdev,
+							 FALSE);
+			mon_buf_ring =
+				&pdev->soc->rxdma_mon_buf_ring[mac_for_pdev];
+			/*
+			 * Configure low interrupt threshld when monitor mode is
+			 * configured.
+			 */
+			if (mon_buf_ring->hal_srng) {
+				num_entries = mon_buf_ring->num_entries;
+				hal_set_low_threshold(mon_buf_ring->hal_srng,
+						      num_entries >> 3);
+				htt_srng_setup(pdev->soc->htt_handle,
+					       pdev->pdev_id,
+					       mon_buf_ring->hal_srng,
+					       RXDMA_MONITOR_BUF);
+			}
+		}
+	}
+}
+#endif
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+QDF_STATUS dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
+					  uint8_t delayed_replenish)
+{
+	struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx;
+	uint32_t mac_id;
+	uint32_t mac_for_pdev;
+	struct dp_soc *soc = pdev->soc;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct dp_srng *mon_buf_ring;
+	uint32_t num_entries;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	pdev_cfg_ctx = pdev->wlan_cfg_ctx;
+
+	/* If monitor rings are aleady initilized, return from here */
+	if (mon_pdev->pdev_mon_init)
+		return QDF_STATUS_SUCCESS;
+
+	for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
+		mac_for_pdev = dp_get_lmac_id_for_pdev_id(pdev->soc, mac_id,
+							  pdev->pdev_id);
+
+		/* Allocate sw rx descriptor pool for mon RxDMA buffer ring */
+		status = dp_rx_pdev_mon_buf_desc_pool_alloc(pdev, mac_for_pdev);
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
+			dp_err("%s: dp_rx_pdev_mon_buf_desc_pool_alloc() failed\n",
+			       __func__);
+			goto fail0;
+		}
+
+		dp_rx_pdev_mon_buf_desc_pool_init(pdev, mac_for_pdev);
+
+		/* If monitor buffers are already allocated,
+		 * do not allocate.
+		 */
+		status = dp_rx_pdev_mon_buf_buffers_alloc(pdev, mac_for_pdev,
+							  delayed_replenish);
+
+		mon_buf_ring = &pdev->soc->rxdma_mon_buf_ring[mac_for_pdev];
+		/*
+		 * Configure low interrupt threshld when monitor mode is
+		 * configured.
+		 */
+		if (mon_buf_ring->hal_srng) {
+			num_entries = mon_buf_ring->num_entries;
+			hal_set_low_threshold(mon_buf_ring->hal_srng,
+					      num_entries >> 3);
+			htt_srng_setup(pdev->soc->htt_handle,
+				       pdev->pdev_id,
+				       mon_buf_ring->hal_srng,
+				       RXDMA_MONITOR_BUF);
+		}
+
+		/* Allocate link descriptors for the mon link descriptor ring */
+		status = dp_hw_link_desc_pool_banks_alloc(soc, mac_for_pdev);
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
+			dp_err("%s: dp_hw_link_desc_pool_banks_alloc() failed",
+			       __func__);
+			goto fail0;
+		}
+		dp_link_desc_ring_replenish(soc, mac_for_pdev);
+
+		htt_srng_setup(soc->htt_handle, pdev->pdev_id,
+			       soc->rxdma_mon_desc_ring[mac_for_pdev].hal_srng,
+			       RXDMA_MONITOR_DESC);
+		htt_srng_setup(soc->htt_handle, pdev->pdev_id,
+			       soc->rxdma_mon_dst_ring[mac_for_pdev].hal_srng,
+			       RXDMA_MONITOR_DST);
+	}
+	mon_pdev->pdev_mon_init = 1;
+
+	return QDF_STATUS_SUCCESS;
+
+fail0:
+	return QDF_STATUS_E_FAILURE;
+}
+#endif
+
+/* dp_mon_vdev_timer()- timer poll for interrupts
+ *
+ * @arg: SoC Handle
+ *
+ * Return:
+ *
+ */
+static void dp_mon_vdev_timer(void *arg)
+{
+	struct dp_soc *soc = (struct dp_soc *)arg;
+	struct dp_pdev *pdev = soc->pdev_list[0];
+	enum timer_yield_status yield = DP_TIMER_NO_YIELD;
+	uint32_t work_done  = 0, total_work_done = 0;
+	int budget = 0xffff;
+	uint32_t remaining_quota = budget;
+	uint64_t start_time;
+	uint32_t lmac_id = DP_MON_INVALID_LMAC_ID;
+	uint32_t lmac_iter;
+	int max_mac_rings = wlan_cfg_get_num_mac_rings(pdev->wlan_cfg_ctx);
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (!qdf_atomic_read(&soc->cmn_init_done))
+		return;
+
+	if (mon_pdev->mon_chan_band != REG_BAND_UNKNOWN)
+		lmac_id = pdev->ch_band_lmac_id_mapping[mon_pdev->mon_chan_band];
+
+	start_time = qdf_get_log_timestamp();
+	dp_is_hw_dbs_enable(soc, &max_mac_rings);
+
+	while (yield == DP_TIMER_NO_YIELD) {
+		for (lmac_iter = 0; lmac_iter < max_mac_rings; lmac_iter++) {
+			if (lmac_iter == lmac_id)
+				work_done = dp_monitor_process(
+						    soc, NULL,
+						    lmac_iter, remaining_quota);
+			else
+				work_done =
+					dp_monitor_drop_packets_for_mac(pdev,
+								     lmac_iter,
+								     remaining_quota);
+			if (work_done) {
+				budget -=  work_done;
+				if (budget <= 0) {
+					yield = DP_TIMER_WORK_EXHAUST;
+					goto budget_done;
+				}
+				remaining_quota = budget;
+				total_work_done += work_done;
+			}
+		}
+
+		yield = dp_should_timer_irq_yield(soc, total_work_done,
+						  start_time);
+		total_work_done = 0;
+	}
+
+budget_done:
+	if (yield == DP_TIMER_WORK_EXHAUST ||
+	    yield == DP_TIMER_TIME_EXHAUST)
+		qdf_timer_mod(&mon_soc->mon_vdev_timer, 1);
+	else
+		qdf_timer_mod(&mon_soc->mon_vdev_timer, DP_INTR_POLL_TIMER_MS);
+}
+
+/* MCL specific functions */
+#if defined(DP_CON_MON)
+/*
+ * dp_mon_reap_timer_handler()- timer to reap monitor rings
+ * reqd as we are not getting ppdu end interrupts
+ * @arg: SoC Handle
+ *
+ * Return:
+ *
+ */
+static void dp_mon_reap_timer_handler(void *arg)
+{
+	struct dp_soc *soc = (struct dp_soc *)arg;
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+
+	dp_service_mon_rings(soc, QCA_NAPI_BUDGET);
+
+	qdf_timer_mod(&mon_soc->mon_reap_timer, DP_INTR_POLL_TIMER_MS);
+}
+#endif
+
+#ifdef QCA_HOST2FW_RXBUF_RING
+static void dp_mon_reap_timer_init(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+
+        qdf_timer_init(soc->osdev, &mon_soc->mon_reap_timer,
+                       dp_mon_reap_timer_handler, (void *)soc,
+                       QDF_TIMER_TYPE_WAKE_APPS);
+        mon_soc->reap_timer_init = 1;
+}
+#else
+static void dp_mon_reap_timer_init(struct dp_soc *soc)
+{
+}
+#endif
+
+static void dp_mon_reap_timer_deinit(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+        if (mon_soc->reap_timer_init) {
+                qdf_timer_free(&mon_soc->mon_reap_timer);
+                mon_soc->reap_timer_init = 0;
+        }
+}
+
+static void dp_mon_reap_timer_start(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+        if (mon_soc->reap_timer_init) {
+                qdf_timer_mod(&mon_soc->mon_reap_timer, DP_INTR_POLL_TIMER_MS);
+        }
+
+}
+
+static bool dp_mon_reap_timer_stop(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+        if (mon_soc->reap_timer_init) {
+                qdf_timer_sync_cancel(&mon_soc->mon_reap_timer);
+                return true;
+        }
+
+        return false;
+}
+
+static void dp_mon_vdev_timer_init(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+
+        qdf_timer_init(soc->osdev, &mon_soc->mon_vdev_timer,
+                       dp_mon_vdev_timer, (void *)soc,
+                       QDF_TIMER_TYPE_WAKE_APPS);
+        mon_soc->mon_vdev_timer_state |= MON_VDEV_TIMER_INIT;
+}
+
+static void dp_mon_vdev_timer_deinit(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+        if (mon_soc->mon_vdev_timer_state & MON_VDEV_TIMER_INIT) {
+                qdf_timer_free(&mon_soc->mon_vdev_timer);
+                mon_soc->mon_vdev_timer_state = 0;
+        }
+}
+
+static void dp_mon_vdev_timer_start(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+        if (mon_soc->mon_vdev_timer_state & MON_VDEV_TIMER_INIT) {
+                qdf_timer_mod(&mon_soc->mon_vdev_timer, DP_INTR_POLL_TIMER_MS);
+                mon_soc->mon_vdev_timer_state |= MON_VDEV_TIMER_RUNNING;
+        }
+}
+
+static bool dp_mon_vdev_timer_stop(struct dp_soc *soc)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+        if (mon_soc->mon_vdev_timer_state & MON_VDEV_TIMER_RUNNING) {
+                qdf_timer_sync_cancel(&mon_soc->mon_vdev_timer);
+                mon_soc->mon_vdev_timer_state &= ~MON_VDEV_TIMER_RUNNING;
+		return true;
+        }
+
+	return false;
+}
+
+static void dp_mon_neighbour_peer_add_ast(struct dp_pdev *pdev,
+					  struct dp_peer *ta_peer,
+					  uint8_t *mac_addr,
+					  qdf_nbuf_t nbuf,
+					  uint32_t flags)
+{
+	struct dp_neighbour_peer *neighbour_peer = NULL;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	struct dp_soc *soc = pdev->soc;
+	uint32_t ret = 0;
+
+	if (mon_pdev->neighbour_peers_added) {
+		qdf_mem_copy(mac_addr,
+			     (qdf_nbuf_data(nbuf) +
+			      QDF_MAC_ADDR_SIZE),
+			      QDF_MAC_ADDR_SIZE);
+
+		qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
+		TAILQ_FOREACH(neighbour_peer,
+			      &mon_pdev->neighbour_peers_list,
+			      neighbour_peer_list_elem) {
+			if (!qdf_mem_cmp(&neighbour_peer->neighbour_peers_macaddr,
+					 mac_addr,
+					 QDF_MAC_ADDR_SIZE)) {
+				ret = dp_peer_add_ast(soc,
+						      ta_peer,
+						      mac_addr,
+						      CDP_TXRX_AST_TYPE_WDS,
+						      flags);
+				QDF_TRACE(QDF_MODULE_ID_DP,
+					  QDF_TRACE_LEVEL_INFO,
+					  "sa valid and nac roamed to wds");
+				break;
+			}
+		}
+		qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
+	}
+}
+
+#if !defined(DISABLE_MON_CONFIG)
+
+/**
+ * dp_mon_htt_srng_setup_1_0() - Prepare HTT messages for Monitor rings
+ * @soc: soc handle
+ * @pdev: physical device handle
+ * @mac_id: ring number
+ * @mac_for_pdev: mac_id
+ *
+ * Return: non-zero for failure, zero for success
+ */
+#ifdef QCA_HOST2FW_RXBUF_RING
+static
+QDF_STATUS dp_mon_htt_srng_setup_1_0(struct dp_soc *soc,
+				     struct dp_pdev *pdev,
+				     int mac_id,
+				     int mac_for_pdev)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	status = dp_mon_htt_dest_srng_setup(soc, pdev, mac_id, mac_for_pdev);
+	if (status != QDF_STATUS_SUCCESS)
+		return status;
+
+	status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
+				soc->rxdma_mon_status_ring[mac_id]
+				.hal_srng,
+				RXDMA_MONITOR_STATUS);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		dp_mon_err("Failed to send htt srng setup message for Rxdma mon status ring");
+		return status;
+	}
+
+	return status;
+}
+#else
+/* This is only for WIN */
+static
+QDF_STATUS dp_mon_htt_srng_setup_1_0(struct dp_soc *soc,
+				     struct dp_pdev *pdev,
+				     int mac_id,
+				     int mac_for_pdev)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct dp_mon_soc *mon_soc;
+
+	mon_soc = soc->monitor_soc;
+	if(!mon_soc) {
+		dp_mon_err("%pK: monitor SOC not initialized", soc);
+		return status;
+	}
+
+	if (mon_soc->monitor_mode_v2)
+		return status;
+
+	if (wlan_cfg_is_delay_mon_replenish(soc->wlan_cfg_ctx)) {
+		status = dp_mon_htt_dest_srng_setup(soc, pdev,
+						    mac_id, mac_for_pdev);
+		if (status != QDF_STATUS_SUCCESS)
+			return status;
+	}
+
+	status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
+				soc->rxdma_mon_status_ring[mac_id]
+				.hal_srng,
+				RXDMA_MONITOR_STATUS);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		dp_mon_err("Failed to send htt srng setup msg for Rxdma mon status ring");
+		return status;
+	}
+
+	return status;
+}
+#endif
+#else
+static
+QDF_STATUS dp_mon_htt_srng_setup_1_0(struct dp_soc *soc,
+				     struct dp_pdev *pdev,
+				     int mac_id,
+				     int mac_for_pdev)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
+/* MCL specific functions */
+#if defined(DP_CON_MON)
+
+/*
+ * dp_service_mon_rings()- service monitor rings
+ * @soc: soc dp handle
+ * @quota: number of ring entry that can be serviced
+ *
+ * Return: None
+ *
+ */
+void dp_service_mon_rings(struct  dp_soc *soc, uint32_t quota)
+{
+	int ring = 0, work_done;
+	struct dp_pdev *pdev = NULL;
+
+	for (ring = 0 ; ring < MAX_NUM_LMAC_HW; ring++) {
+		pdev = dp_get_pdev_for_lmac_id(soc, ring);
+		if (!pdev)
+			continue;
+		work_done = dp_mon_process(soc, NULL, ring, quota);
+
+		dp_rx_mon_dest_debug("Reaped %d descs from Monitor rings",
+				     work_done);
+	}
+}
+#endif
+
+/*
+ * dp_peer_tx_init() – Initialize receive TID state
+ * @pdev: Datapath pdev
+ * @peer: Datapath peer
+ *
+ */
+static void
+dp_peer_tx_init(struct dp_pdev *pdev, struct dp_peer *peer)
+{
+	dp_peer_tid_queue_init(peer);
+	dp_peer_update_80211_hdr(peer->vdev, peer);
+}
+
+/*
+ * dp_peer_tx_cleanup() – Deinitialize receive TID state
+ * @vdev: Datapath vdev
+ * @peer: Datapath peer
+ *
+ */
+static void
+dp_peer_tx_cleanup(struct dp_vdev *vdev, struct dp_peer *peer)
+{
+	dp_peer_tid_queue_cleanup(peer);
+}
+
+#ifdef QCA_SUPPORT_BPR
+static QDF_STATUS
+dp_set_bpr_enable_1_0(struct dp_pdev *pdev, int val)
+{
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	switch (val) {
+	case CDP_BPR_DISABLE:
+		mon_pdev->bpr_enable = CDP_BPR_DISABLE;
+		if (!mon_pdev->pktlog_ppdu_stats &&
+		    !mon_pdev->enhanced_stats_en &&
+		    !mon_pdev->tx_sniffer_enable && !mon_pdev->mcopy_mode) {
+			dp_h2t_cfg_stats_msg_send(pdev, 0, pdev->pdev_id);
+		} else if (mon_pdev->enhanced_stats_en &&
+			   !mon_pdev->tx_sniffer_enable &&
+			   !mon_pdev->mcopy_mode &&
+			   !mon_pdev->pktlog_ppdu_stats) {
+			dp_h2t_cfg_stats_msg_send(pdev,
+						  DP_PPDU_STATS_CFG_ENH_STATS,
+						  pdev->pdev_id);
+		}
+		break;
+	case CDP_BPR_ENABLE:
+		mon_pdev->bpr_enable = CDP_BPR_ENABLE;
+		if (!mon_pdev->enhanced_stats_en &&
+		    !mon_pdev->tx_sniffer_enable &&
+		    !mon_pdev->mcopy_mode && !mon_pdev->pktlog_ppdu_stats) {
+			dp_h2t_cfg_stats_msg_send(pdev,
+						  DP_PPDU_STATS_CFG_BPR,
+						  pdev->pdev_id);
+		} else if (mon_pdev->enhanced_stats_en &&
+			   !mon_pdev->tx_sniffer_enable &&
+			   !mon_pdev->mcopy_mode &&
+			   !mon_pdev->pktlog_ppdu_stats) {
+			dp_h2t_cfg_stats_msg_send(pdev,
+						  DP_PPDU_STATS_CFG_BPR_ENH,
+						  pdev->pdev_id);
+		} else if (mon_pdev->pktlog_ppdu_stats) {
+			dp_h2t_cfg_stats_msg_send(pdev,
+						  DP_PPDU_STATS_CFG_BPR_PKTLOG,
+						  pdev->pdev_id);
+		}
+		break;
+	default:
+		break;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+/*
+ * dp_process_ppdu_stats_tx_mgmtctrl_payload_tlv: Process
+ * htt_ppdu_stats_tx_mgmtctrl_payload_tlv
+ * @pdev: DP PDEV handle
+ * @tag_buf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
+ * @length: tlv_length
+ *
+ * return:QDF_STATUS_SUCCESS if nbuf as to be freed in caller
+ */
+QDF_STATUS
+dp_process_ppdu_stats_tx_mgmtctrl_payload_tlv(struct dp_pdev *pdev,
+					      qdf_nbuf_t tag_buf,
+					      uint32_t ppdu_id)
+{
+	uint32_t *nbuf_ptr;
+	uint8_t trim_size;
+	size_t head_size;
+	struct cdp_tx_mgmt_comp_info *ptr_mgmt_comp_info;
+	uint32_t *msg_word;
+	uint32_t tsf_hdr;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if ((!mon_pdev->tx_sniffer_enable) && (!mon_pdev->mcopy_mode) &&
+	    (!mon_pdev->bpr_enable) && (!mon_pdev->tx_capture_enabled))
+		return QDF_STATUS_SUCCESS;
+
+	/*
+	 * get timestamp from htt_t2h_ppdu_stats_ind_hdr_t
+	 */
+	msg_word = (uint32_t *)qdf_nbuf_data(tag_buf);
+	msg_word = msg_word + 2;
+	tsf_hdr = *msg_word;
+
+	trim_size = ((mon_pdev->mgmtctrl_frm_info.mgmt_buf +
+		      HTT_MGMT_CTRL_TLV_HDR_RESERVERD_LEN) -
+		      qdf_nbuf_data(tag_buf));
+
+	if (!qdf_nbuf_pull_head(tag_buf, trim_size))
+		return QDF_STATUS_SUCCESS;
+
+	qdf_nbuf_trim_tail(tag_buf, qdf_nbuf_len(tag_buf) -
+			    mon_pdev->mgmtctrl_frm_info.mgmt_buf_len);
+
+	if (mon_pdev->tx_capture_enabled) {
+		head_size = sizeof(struct cdp_tx_mgmt_comp_info);
+		if (qdf_unlikely(qdf_nbuf_headroom(tag_buf) < head_size)) {
+			qdf_err("Fail to get headroom h_sz %zu h_avail %d\n",
+				head_size, qdf_nbuf_headroom(tag_buf));
+			qdf_assert_always(0);
+			return QDF_STATUS_E_NOMEM;
+		}
+		ptr_mgmt_comp_info = (struct cdp_tx_mgmt_comp_info *)
+					qdf_nbuf_push_head(tag_buf, head_size);
+		qdf_assert_always(ptr_mgmt_comp_info);
+		ptr_mgmt_comp_info->ppdu_id = ppdu_id;
+		ptr_mgmt_comp_info->is_sgen_pkt = true;
+		ptr_mgmt_comp_info->tx_tsf = tsf_hdr;
+	} else {
+		head_size = sizeof(ppdu_id);
+		nbuf_ptr = (uint32_t *)qdf_nbuf_push_head(tag_buf, head_size);
+		*nbuf_ptr = ppdu_id;
+	}
+	if (mon_pdev->bpr_enable) {
+		dp_wdi_event_handler(WDI_EVENT_TX_BEACON, pdev->soc,
+				     tag_buf, HTT_INVALID_PEER,
+				     WDI_NO_VAL, pdev->pdev_id);
+	}
+
+	dp_deliver_mgmt_frm(pdev, tag_buf);
+
+	return QDF_STATUS_E_ALREADY;
+}
+
+/*
+ * dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap() - Get ppdu stats tlv
+ * bitmap for sniffer mode
+ * @bitmap: received bitmap
+ *
+ * Return: expected bitmap value, returns zero if doesn't match with
+ * either 64-bit Tx window or 256-bit window tlv bitmap
+ */
+int
+dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(uint32_t bitmap)
+{
+	if (bitmap == (HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64))
+		return HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64;
+	else if (bitmap == (HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256))
+		return HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256;
+
+	return 0;
+}
+
+/*
+ * dp_peer_find_by_id_valid - check if peer exists for given id
+ * @soc: core DP soc context
+ * @peer_id: peer id from peer object can be retrieved
+ *
+ * Return: true if peer exists of false otherwise
+ */
+
+static
+bool dp_peer_find_by_id_valid(struct dp_soc *soc, uint16_t peer_id)
+{
+	struct dp_peer *peer = dp_peer_get_ref_by_id(soc, peer_id,
+						     DP_MOD_ID_HTT);
+
+	if (peer) {
+		/*
+		 * Decrement the peer ref which is taken as part of
+		 * dp_peer_get_ref_by_id if PEER_LOCK_REF_PROTECT is enabled
+		 */
+		dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
+
+		return true;
+	}
+
+	return false;
+}
+
+/*
+ * dp_peer_copy_delay_stats() - copy ppdu stats to peer delayed stats.
+ * @peer: Datapath peer handle
+ * @ppdu: User PPDU Descriptor
+ * @cur_ppdu_id: PPDU_ID
+ *
+ * Return: None
+ *
+ * on Tx data frame, we may get delayed ba set
+ * in htt_ppdu_stats_user_common_tlv. which mean we get Block Ack(BA) after we
+ * request Block Ack Request(BAR). Successful msdu is received only after Block
+ * Ack. To populate peer stats we need successful msdu(data frame).
+ * So we hold the Tx data stats on delayed_ba for stats update.
+ */
+static void
+dp_peer_copy_delay_stats(struct dp_peer *peer,
+			 struct cdp_tx_completion_ppdu_user *ppdu,
+			 uint32_t cur_ppdu_id)
+{
+	struct dp_pdev *pdev;
+	struct dp_vdev *vdev;
+	struct dp_mon_peer *mon_peer = peer->monitor_peer;
+
+	if (mon_peer->last_delayed_ba) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "BA not yet recv for prev delayed ppdu[%d] - cur ppdu[%d]",
+			  mon_peer->last_delayed_ba_ppduid, cur_ppdu_id);
+		vdev = peer->vdev;
+		if (vdev) {
+			pdev = vdev->pdev;
+			pdev->stats.cdp_delayed_ba_not_recev++;
+		}
+	}
+
+	mon_peer->delayed_ba_ppdu_stats.ltf_size = ppdu->ltf_size;
+	mon_peer->delayed_ba_ppdu_stats.stbc = ppdu->stbc;
+	mon_peer->delayed_ba_ppdu_stats.he_re = ppdu->he_re;
+	mon_peer->delayed_ba_ppdu_stats.txbf = ppdu->txbf;
+	mon_peer->delayed_ba_ppdu_stats.bw = ppdu->bw;
+	mon_peer->delayed_ba_ppdu_stats.nss = ppdu->nss;
+	mon_peer->delayed_ba_ppdu_stats.gi = ppdu->gi;
+	mon_peer->delayed_ba_ppdu_stats.dcm = ppdu->dcm;
+	mon_peer->delayed_ba_ppdu_stats.ldpc = ppdu->ldpc;
+	mon_peer->delayed_ba_ppdu_stats.dcm = ppdu->dcm;
+	mon_peer->delayed_ba_ppdu_stats.mpdu_tried_ucast =
+					ppdu->mpdu_tried_ucast;
+	mon_peer->delayed_ba_ppdu_stats.mpdu_tried_mcast =
+					ppdu->mpdu_tried_mcast;
+	mon_peer->delayed_ba_ppdu_stats.frame_ctrl = ppdu->frame_ctrl;
+	mon_peer->delayed_ba_ppdu_stats.qos_ctrl = ppdu->qos_ctrl;
+	mon_peer->delayed_ba_ppdu_stats.dcm = ppdu->dcm;
+
+	mon_peer->delayed_ba_ppdu_stats.ru_start = ppdu->ru_start;
+	mon_peer->delayed_ba_ppdu_stats.ru_tones = ppdu->ru_tones;
+	mon_peer->delayed_ba_ppdu_stats.is_mcast = ppdu->is_mcast;
+
+	mon_peer->delayed_ba_ppdu_stats.user_pos = ppdu->user_pos;
+	mon_peer->delayed_ba_ppdu_stats.mu_group_id = ppdu->mu_group_id;
+
+	mon_peer->last_delayed_ba = true;
+
+	ppdu->debug_copied = true;
+}
+
+/*
+ * dp_peer_copy_stats_to_bar() - copy delayed stats to ppdu stats.
+ * @peer: Datapath peer handle
+ * @ppdu: PPDU Descriptor
+ *
+ * Return: None
+ *
+ * For Tx BAR, PPDU stats TLV include Block Ack info. PPDU info
+ * from Tx BAR frame not required to populate peer stats.
+ * But we need successful MPDU and MSDU to update previous
+ * transmitted Tx data frame. Overwrite ppdu stats with the previous
+ * stored ppdu stats.
+ */
+static void
+dp_peer_copy_stats_to_bar(struct dp_peer *peer,
+			  struct cdp_tx_completion_ppdu_user *ppdu)
+{
+	struct dp_mon_peer *mon_peer = peer->monitor_peer;
+
+	ppdu->ltf_size = mon_peer->delayed_ba_ppdu_stats.ltf_size;
+	ppdu->stbc = mon_peer->delayed_ba_ppdu_stats.stbc;
+	ppdu->he_re = mon_peer->delayed_ba_ppdu_stats.he_re;
+	ppdu->txbf = mon_peer->delayed_ba_ppdu_stats.txbf;
+	ppdu->bw = mon_peer->delayed_ba_ppdu_stats.bw;
+	ppdu->nss = mon_peer->delayed_ba_ppdu_stats.nss;
+	ppdu->gi = mon_peer->delayed_ba_ppdu_stats.gi;
+	ppdu->dcm = mon_peer->delayed_ba_ppdu_stats.dcm;
+	ppdu->ldpc = mon_peer->delayed_ba_ppdu_stats.ldpc;
+	ppdu->dcm = mon_peer->delayed_ba_ppdu_stats.dcm;
+	ppdu->mpdu_tried_ucast =
+			mon_peer->delayed_ba_ppdu_stats.mpdu_tried_ucast;
+	ppdu->mpdu_tried_mcast =
+			mon_peer->delayed_ba_ppdu_stats.mpdu_tried_mcast;
+	ppdu->frame_ctrl = mon_peer->delayed_ba_ppdu_stats.frame_ctrl;
+	ppdu->qos_ctrl = mon_peer->delayed_ba_ppdu_stats.qos_ctrl;
+	ppdu->dcm = mon_peer->delayed_ba_ppdu_stats.dcm;
+
+	ppdu->ru_start = mon_peer->delayed_ba_ppdu_stats.ru_start;
+	ppdu->ru_tones = mon_peer->delayed_ba_ppdu_stats.ru_tones;
+	ppdu->is_mcast = mon_peer->delayed_ba_ppdu_stats.is_mcast;
+
+	ppdu->user_pos = mon_peer->delayed_ba_ppdu_stats.user_pos;
+	ppdu->mu_group_id = mon_peer->delayed_ba_ppdu_stats.mu_group_id;
+
+	mon_peer->last_delayed_ba = false;
+
+	ppdu->debug_copied = true;
+}
+
+/*
+ * dp_tx_rate_stats_update() - Update rate per-peer statistics
+ * @peer: Datapath peer handle
+ * @ppdu: PPDU Descriptor
+ *
+ * Return: None
+ */
+static void
+dp_tx_rate_stats_update(struct dp_peer *peer,
+			struct cdp_tx_completion_ppdu_user *ppdu)
+{
+	uint32_t ratekbps = 0;
+	uint64_t ppdu_tx_rate = 0;
+	uint32_t rix;
+	uint16_t ratecode = 0;
+
+	if (!peer || !ppdu)
+		return;
+
+	if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK)
+		return;
+
+	ratekbps = dp_getrateindex(ppdu->gi,
+				   ppdu->mcs,
+				   ppdu->nss,
+				   ppdu->preamble,
+				   ppdu->bw,
+				   &rix,
+				   &ratecode);
+
+	DP_STATS_UPD(peer, tx.last_tx_rate, ratekbps);
+
+	if (!ratekbps)
+		return;
+
+	/* Calculate goodput in non-training period
+	 * In training period, don't do anything as
+	 * pending pkt is send as goodput.
+	 */
+	if ((!peer->bss_peer) && (!ppdu->sa_is_training)) {
+		ppdu->sa_goodput = ((ratekbps / CDP_NUM_KB_IN_MB) *
+				(CDP_PERCENT_MACRO - ppdu->current_rate_per));
+	}
+	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;
+	if (peer->vdev) {
+		/*
+		 * In STA mode:
+		 *	We get ucast stats as BSS peer stats.
+		 *
+		 * In AP mode:
+		 *	We get mcast stats as BSS peer stats.
+		 *	We get ucast stats as assoc peer stats.
+		 */
+		if (peer->vdev->opmode == wlan_op_mode_ap && peer->bss_peer) {
+			peer->vdev->stats.tx.mcast_last_tx_rate = ratekbps;
+			peer->vdev->stats.tx.mcast_last_tx_rate_mcs = ppdu->mcs;
+		} else {
+			peer->vdev->stats.tx.last_tx_rate = ratekbps;
+			peer->vdev->stats.tx.last_tx_rate_mcs = ppdu->mcs;
+		}
+	}
+}
+
+/*
+ * dp_tx_stats_update() - Update per-peer statistics
+ * @pdev: Datapath pdev handle
+ * @peer: Datapath peer handle
+ * @ppdu: PPDU Descriptor
+ * @ack_rssi: RSSI of last ack received
+ *
+ * Return: None
+ */
+static void
+dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
+		   struct cdp_tx_completion_ppdu_user *ppdu,
+		   uint32_t ack_rssi)
+{
+	uint8_t preamble, mcs;
+	uint16_t num_msdu;
+	uint16_t num_mpdu;
+	uint16_t mpdu_tried;
+	uint16_t mpdu_failed;
+
+	preamble = ppdu->preamble;
+	mcs = ppdu->mcs;
+	num_msdu = ppdu->num_msdu;
+	num_mpdu = ppdu->mpdu_success;
+	mpdu_tried = ppdu->mpdu_tried_ucast + ppdu->mpdu_tried_mcast;
+	mpdu_failed = mpdu_tried - num_mpdu;
+
+	/* If the peer statistics are already processed as part of
+	 * per-MSDU completion handler, do not process these again in per-PPDU
+	 * indications
+	 */
+	if (pdev->soc->process_tx_status)
+		return;
+
+	if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK) {
+		/*
+		 * All failed mpdu will be retried, so incrementing
+		 * retries mpdu based on mpdu failed. Even for
+		 * 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);
+		return;
+	}
+
+	if (ppdu->is_ppdu_cookie_valid)
+		DP_STATS_INC(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) {
+		if (unlikely(!(ppdu->mu_group_id & (MAX_MU_GROUP_ID - 1))))
+			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],
+				     (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);
+		switch (ppdu->ru_tones) {
+		case RU_26:
+			DP_STATS_INC(peer, tx.ru_loc[RU_26_INDEX].num_msdu,
+				     num_msdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_26_INDEX].num_mpdu,
+				     num_mpdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_26_INDEX].mpdu_tried,
+				     mpdu_tried);
+		break;
+		case RU_52:
+			DP_STATS_INC(peer, tx.ru_loc[RU_52_INDEX].num_msdu,
+				     num_msdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_52_INDEX].num_mpdu,
+				     num_mpdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_52_INDEX].mpdu_tried,
+				     mpdu_tried);
+		break;
+		case RU_106:
+			DP_STATS_INC(peer, tx.ru_loc[RU_106_INDEX].num_msdu,
+				     num_msdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_106_INDEX].num_mpdu,
+				     num_mpdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_106_INDEX].mpdu_tried,
+				     mpdu_tried);
+		break;
+		case RU_242:
+			DP_STATS_INC(peer, tx.ru_loc[RU_242_INDEX].num_msdu,
+				     num_msdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_242_INDEX].num_mpdu,
+				     num_mpdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_242_INDEX].mpdu_tried,
+				     mpdu_tried);
+		break;
+		case RU_484:
+			DP_STATS_INC(peer, tx.ru_loc[RU_484_INDEX].num_msdu,
+				     num_msdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_484_INDEX].num_mpdu,
+				     num_mpdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_484_INDEX].mpdu_tried,
+				     mpdu_tried);
+		break;
+		case RU_996:
+			DP_STATS_INC(peer, tx.ru_loc[RU_996_INDEX].num_msdu,
+				     num_msdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_996_INDEX].num_mpdu,
+				     num_mpdu);
+			DP_STATS_INC(peer, tx.ru_loc[RU_996_INDEX].mpdu_tried,
+				     mpdu_tried);
+		break;
+		}
+	}
+
+	/*
+	 * All failed mpdu will be retried, so incrementing
+	 * retries mpdu based on mpdu failed. Even for
+	 * 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(peer, tx.transmit_type[ppdu->ppdu_type].num_msdu,
+		     num_msdu);
+	DP_STATS_INC(peer, tx.transmit_type[ppdu->ppdu_type].num_mpdu,
+		     num_mpdu);
+	DP_STATS_INC(peer, tx.transmit_type[ppdu->ppdu_type].mpdu_tried,
+		     mpdu_tried);
+
+	DP_STATS_INC_PKT(peer, tx.comp_pkt,
+			 num_msdu, (ppdu->success_bytes +
+				    ppdu->retry_bytes + ppdu->failed_bytes));
+	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);
+	if (ppdu->tid < CDP_DATA_TID_MAX)
+		DP_STATS_INC(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);
+	if (!(ppdu->is_mcast) && ppdu->ack_rssi_valid)
+		DP_STATS_UPD(peer, tx.last_ack_rssi, ack_rssi);
+
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[MAX_MCS-1], num_msdu,
+		      ((mcs >= MAX_MCS_11A) && (preamble == DOT11_A)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+		      ((mcs < MAX_MCS_11A) && (preamble == DOT11_A)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[MAX_MCS-1], num_msdu,
+		      ((mcs >= MAX_MCS_11B) && (preamble == DOT11_B)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+		      ((mcs < (MAX_MCS_11B)) && (preamble == DOT11_B)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[MAX_MCS-1], num_msdu,
+		      ((mcs >= MAX_MCS_11A) && (preamble == DOT11_N)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+		      ((mcs < MAX_MCS_11A) && (preamble == DOT11_N)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[MAX_MCS-1], num_msdu,
+		      ((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+		      ((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC)));
+	DP_STATS_INCC(peer,
+		      tx.pkt_type[preamble].mcs_count[MAX_MCS-1], num_msdu,
+		      ((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX)));
+	DP_STATS_INCC(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_msdu, ppdu->is_ampdu);
+	DP_STATS_INCC(peer, tx.non_ampdu_cnt, num_msdu, !(ppdu->is_ampdu));
+	DP_STATS_INCC(peer, tx.pream_punct_cnt, 1, ppdu->pream_punct);
+
+	dp_peer_stats_notify(pdev, peer);
+
+#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_get_ppdu_info_user_index: Find and allocate a per-user descriptor for a PPDU,
+ * if a new peer id arrives in a PPDU
+ * pdev: DP pdev handle
+ * @peer_id : peer unique identifier
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:user index to be populated
+ */
+static uint8_t dp_get_ppdu_info_user_index(struct dp_pdev *pdev,
+					   uint16_t peer_id,
+					   struct ppdu_info *ppdu_info)
+{
+	uint8_t user_index = 0;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	while ((user_index + 1) <= ppdu_info->last_user) {
+		ppdu_user_desc = &ppdu_desc->user[user_index];
+		if (ppdu_user_desc->peer_id != peer_id) {
+			user_index++;
+			continue;
+		} else {
+			/* Max users possible is 8 so user array index should
+			 * not exceed 7
+			 */
+			qdf_assert_always(user_index <= (ppdu_desc->max_users - 1));
+			return user_index;
+		}
+	}
+
+	ppdu_info->last_user++;
+	/* Max users possible is 8 so last user should not exceed 8 */
+	qdf_assert_always(ppdu_info->last_user <= ppdu_desc->max_users);
+	return ppdu_info->last_user - 1;
+}
+
+/*
+ * dp_process_ppdu_stats_common_tlv: Process htt_ppdu_stats_common_tlv
+ * pdev: DP pdev handle
+ * @tag_buf: buffer containing the tlv htt_ppdu_stats_common_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void
+dp_process_ppdu_stats_common_tlv(struct dp_pdev *pdev,
+				 uint32_t *tag_buf,
+				 struct ppdu_info *ppdu_info)
+{
+	uint16_t frame_type;
+	uint16_t frame_ctrl;
+	uint16_t freq;
+	struct dp_soc *soc = NULL;
+	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
+	uint64_t ppdu_start_timestamp;
+	uint32_t *start_tag_buf;
+
+	start_tag_buf = tag_buf;
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	ppdu_desc->ppdu_id = ppdu_info->ppdu_id;
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(RING_ID_SCH_CMD_ID);
+	ppdu_info->sched_cmdid =
+		HTT_PPDU_STATS_COMMON_TLV_SCH_CMDID_GET(*tag_buf);
+	ppdu_desc->num_users =
+		HTT_PPDU_STATS_COMMON_TLV_NUM_USERS_GET(*tag_buf);
+
+	qdf_assert_always(ppdu_desc->num_users <= ppdu_desc->max_users);
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(QTYPE_FRM_TYPE);
+	frame_type = HTT_PPDU_STATS_COMMON_TLV_FRM_TYPE_GET(*tag_buf);
+	ppdu_desc->htt_frame_type = frame_type;
+
+	frame_ctrl = ppdu_desc->frame_ctrl;
+
+	ppdu_desc->bar_ppdu_id = ppdu_info->ppdu_id;
+
+	switch (frame_type) {
+	case HTT_STATS_FTYPE_TIDQ_DATA_SU:
+	case HTT_STATS_FTYPE_TIDQ_DATA_MU:
+	case HTT_STATS_FTYPE_SGEN_QOS_NULL:
+		/*
+		 * for management packet, frame type come as DATA_SU
+		 * need to check frame_ctrl before setting frame_type
+		 */
+		if (HTT_GET_FRAME_CTRL_TYPE(frame_ctrl) <= FRAME_CTRL_TYPE_CTRL)
+			ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
+		else
+			ppdu_desc->frame_type = CDP_PPDU_FTYPE_DATA;
+	break;
+	case HTT_STATS_FTYPE_SGEN_MU_BAR:
+	case HTT_STATS_FTYPE_SGEN_BAR:
+		ppdu_desc->frame_type = CDP_PPDU_FTYPE_BAR;
+	break;
+	default:
+		ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
+	break;
+	}
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(FES_DUR_US);
+	ppdu_desc->tx_duration = *tag_buf;
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(START_TSTMP_L32_US);
+	ppdu_desc->ppdu_start_timestamp = *tag_buf;
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(CHAN_MHZ_PHY_MODE);
+	freq = HTT_PPDU_STATS_COMMON_TLV_CHAN_MHZ_GET(*tag_buf);
+	if (freq != ppdu_desc->channel) {
+		soc = pdev->soc;
+		ppdu_desc->channel = freq;
+		pdev->operating_channel.freq = freq;
+		if (soc && soc->cdp_soc.ol_ops->freq_to_channel)
+			pdev->operating_channel.num =
+			    soc->cdp_soc.ol_ops->freq_to_channel(soc->ctrl_psoc,
+								 pdev->pdev_id,
+								 freq);
+
+		if (soc && soc->cdp_soc.ol_ops->freq_to_band)
+			pdev->operating_channel.band =
+			       soc->cdp_soc.ol_ops->freq_to_band(soc->ctrl_psoc,
+								 pdev->pdev_id,
+								 freq);
+	}
+
+	ppdu_desc->phy_mode = HTT_PPDU_STATS_COMMON_TLV_PHY_MODE_GET(*tag_buf);
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(RESV_NUM_UL_BEAM);
+	ppdu_desc->phy_ppdu_tx_time_us =
+		HTT_PPDU_STATS_COMMON_TLV_PHY_PPDU_TX_TIME_US_GET(*tag_buf);
+	ppdu_desc->beam_change =
+		HTT_PPDU_STATS_COMMON_TLV_BEAM_CHANGE_GET(*tag_buf);
+	ppdu_desc->doppler =
+		HTT_PPDU_STATS_COMMON_TLV_DOPPLER_INDICATION_GET(*tag_buf);
+	ppdu_desc->spatial_reuse =
+		HTT_PPDU_STATS_COMMON_TLV_SPATIAL_REUSE_GET(*tag_buf);
+
+	dp_tx_capture_htt_frame_counter(pdev, frame_type);
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(START_TSTMP_U32_US);
+	ppdu_start_timestamp = *tag_buf;
+	ppdu_desc->ppdu_start_timestamp |= ((ppdu_start_timestamp <<
+					     HTT_SHIFT_UPPER_TIMESTAMP) &
+					    HTT_MASK_UPPER_TIMESTAMP);
+
+	ppdu_desc->ppdu_end_timestamp = ppdu_desc->ppdu_start_timestamp +
+					ppdu_desc->tx_duration;
+	/* Ack time stamp is same as end time stamp*/
+	ppdu_desc->ack_timestamp = ppdu_desc->ppdu_end_timestamp;
+
+	ppdu_desc->ppdu_end_timestamp = ppdu_desc->ppdu_start_timestamp +
+					ppdu_desc->tx_duration;
+
+	ppdu_desc->bar_ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
+	ppdu_desc->bar_ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
+	ppdu_desc->bar_tx_duration = ppdu_desc->tx_duration;
+
+	/* Ack time stamp is same as end time stamp*/
+	ppdu_desc->ack_timestamp = ppdu_desc->ppdu_end_timestamp;
+
+	tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(BSSCOLOR_OBSS_PSR);
+	ppdu_desc->bss_color =
+		HTT_PPDU_STATS_COMMON_TLV_BSS_COLOR_ID_GET(*tag_buf);
+}
+
+/*
+ * dp_process_ppdu_stats_user_common_tlv: Process ppdu_stats_user_common
+ * @tag_buf: buffer containing the tlv htt_ppdu_stats_user_common_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_user_common_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	uint16_t peer_id;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	struct dp_peer *peer;
+	struct dp_vdev *vdev;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+	peer_id = HTT_PPDU_STATS_USER_RATE_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index =
+		dp_get_ppdu_info_user_index(pdev,
+					    peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+
+	ppdu_desc->vdev_id =
+		HTT_PPDU_STATS_USER_COMMON_TLV_VAP_ID_GET(*tag_buf);
+
+	ppdu_user_desc->peer_id = peer_id;
+
+	tag_buf++;
+
+	if (HTT_PPDU_STATS_USER_COMMON_TLV_DELAYED_BA_GET(*tag_buf)) {
+		ppdu_user_desc->delayed_ba = 1;
+		ppdu_desc->delayed_ba = 1;
+	}
+
+	if (HTT_PPDU_STATS_USER_COMMON_TLV_MCAST_GET(*tag_buf)) {
+		ppdu_user_desc->is_mcast = true;
+		ppdu_user_desc->mpdu_tried_mcast =
+		HTT_PPDU_STATS_USER_COMMON_TLV_MPDUS_TRIED_GET(*tag_buf);
+		ppdu_user_desc->num_mpdu = ppdu_user_desc->mpdu_tried_mcast;
+	} else {
+		ppdu_user_desc->mpdu_tried_ucast =
+		HTT_PPDU_STATS_USER_COMMON_TLV_MPDUS_TRIED_GET(*tag_buf);
+	}
+
+	ppdu_user_desc->is_seq_num_valid =
+	HTT_PPDU_STATS_USER_COMMON_TLV_IS_SQNUM_VALID_IN_BUFFER_GET(*tag_buf);
+	tag_buf++;
+
+	ppdu_user_desc->qos_ctrl =
+		HTT_PPDU_STATS_USER_COMMON_TLV_QOS_CTRL_GET(*tag_buf);
+	ppdu_user_desc->frame_ctrl =
+		HTT_PPDU_STATS_USER_COMMON_TLV_FRAME_CTRL_GET(*tag_buf);
+	ppdu_desc->frame_ctrl = ppdu_user_desc->frame_ctrl;
+
+	if (ppdu_user_desc->delayed_ba)
+		ppdu_user_desc->mpdu_success = 0;
+
+	tag_buf += 3;
+
+	if (HTT_PPDU_STATS_IS_OPAQUE_VALID_GET(*tag_buf)) {
+		ppdu_user_desc->ppdu_cookie =
+			HTT_PPDU_STATS_HOST_OPAQUE_COOKIE_GET(*tag_buf);
+		ppdu_user_desc->is_ppdu_cookie_valid = 1;
+	}
+
+	/* returning earlier causes other feilds unpopulated */
+	if (peer_id == DP_SCAN_PEER_ID) {
+		vdev = dp_vdev_get_ref_by_id(pdev->soc, ppdu_desc->vdev_id,
+					     DP_MOD_ID_TX_PPDU_STATS);
+		if (!vdev)
+			return;
+		qdf_mem_copy(ppdu_user_desc->mac_addr, vdev->mac_addr.raw,
+			     QDF_MAC_ADDR_SIZE);
+		dp_vdev_unref_delete(pdev->soc, vdev, DP_MOD_ID_TX_PPDU_STATS);
+	} else {
+		peer = dp_peer_get_ref_by_id(pdev->soc, peer_id,
+					     DP_MOD_ID_TX_PPDU_STATS);
+		if (!peer) {
+			/*
+			 * fw sends peer_id which is about to removed but
+			 * it was already removed in host.
+			 * eg: for disassoc, fw send ppdu stats
+			 * with peer id equal to previously associated
+			 * peer's peer_id but it was removed
+			 */
+			vdev = dp_vdev_get_ref_by_id(pdev->soc,
+						     ppdu_desc->vdev_id,
+						     DP_MOD_ID_TX_PPDU_STATS);
+			if (!vdev)
+				return;
+			qdf_mem_copy(ppdu_user_desc->mac_addr,
+				     vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE);
+			dp_vdev_unref_delete(pdev->soc, vdev,
+					     DP_MOD_ID_TX_PPDU_STATS);
+			return;
+		}
+		qdf_mem_copy(ppdu_user_desc->mac_addr,
+			     peer->mac_addr.raw, QDF_MAC_ADDR_SIZE);
+		dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
+	}
+}
+
+/**
+ * dp_process_ppdu_stats_user_rate_tlv() - Process htt_ppdu_stats_user_rate_tlv
+ * @pdev: DP pdev handle
+ * @tag_buf: T2H message buffer carrying the user rate TLV
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void
+dp_process_ppdu_stats_user_rate_tlv(struct dp_pdev *pdev,
+				    uint32_t *tag_buf,
+				    struct ppdu_info *ppdu_info)
+{
+	uint16_t peer_id;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	struct dp_vdev *vdev;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+	peer_id = HTT_PPDU_STATS_USER_RATE_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index =
+		dp_get_ppdu_info_user_index(pdev,
+					    peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	if (peer_id == DP_SCAN_PEER_ID) {
+		vdev = dp_vdev_get_ref_by_id(pdev->soc, ppdu_desc->vdev_id,
+					     DP_MOD_ID_TX_PPDU_STATS);
+		if (!vdev)
+			return;
+		dp_vdev_unref_delete(pdev->soc, vdev,
+				     DP_MOD_ID_TX_PPDU_STATS);
+	}
+	ppdu_user_desc->peer_id = peer_id;
+
+	ppdu_user_desc->tid =
+		HTT_PPDU_STATS_USER_RATE_TLV_TID_NUM_GET(*tag_buf);
+
+	tag_buf += 1;
+
+	ppdu_user_desc->user_pos =
+		HTT_PPDU_STATS_USER_RATE_TLV_USER_POS_GET(*tag_buf);
+	ppdu_user_desc->mu_group_id =
+		HTT_PPDU_STATS_USER_RATE_TLV_MU_GROUPID_GET(*tag_buf);
+
+	tag_buf += 1;
+
+	ppdu_user_desc->ru_start =
+		HTT_PPDU_STATS_USER_RATE_TLV_RU_START_GET(*tag_buf);
+	ppdu_user_desc->ru_tones =
+		(HTT_PPDU_STATS_USER_RATE_TLV_RU_END_GET(*tag_buf) -
+		HTT_PPDU_STATS_USER_RATE_TLV_RU_START_GET(*tag_buf)) + 1;
+	ppdu_desc->usr_ru_tones_sum += ppdu_user_desc->ru_tones;
+
+	tag_buf += 2;
+
+	ppdu_user_desc->ppdu_type =
+		HTT_PPDU_STATS_USER_RATE_TLV_PPDU_TYPE_GET(*tag_buf);
+
+	tag_buf++;
+	ppdu_user_desc->tx_rate = *tag_buf;
+
+	ppdu_user_desc->ltf_size =
+		HTT_PPDU_STATS_USER_RATE_TLV_LTF_SIZE_GET(*tag_buf);
+	ppdu_user_desc->stbc =
+		HTT_PPDU_STATS_USER_RATE_TLV_STBC_GET(*tag_buf);
+	ppdu_user_desc->he_re =
+		HTT_PPDU_STATS_USER_RATE_TLV_HE_RE_GET(*tag_buf);
+	ppdu_user_desc->txbf =
+		HTT_PPDU_STATS_USER_RATE_TLV_TXBF_GET(*tag_buf);
+	ppdu_user_desc->bw =
+		HTT_PPDU_STATS_USER_RATE_TLV_BW_GET(*tag_buf) - 2;
+	ppdu_user_desc->nss = HTT_PPDU_STATS_USER_RATE_TLV_NSS_GET(*tag_buf);
+	ppdu_desc->usr_nss_sum += ppdu_user_desc->nss;
+	ppdu_user_desc->mcs = HTT_PPDU_STATS_USER_RATE_TLV_MCS_GET(*tag_buf);
+	ppdu_user_desc->preamble =
+		HTT_PPDU_STATS_USER_RATE_TLV_PREAMBLE_GET(*tag_buf);
+	ppdu_user_desc->gi = HTT_PPDU_STATS_USER_RATE_TLV_GI_GET(*tag_buf);
+	ppdu_user_desc->dcm = HTT_PPDU_STATS_USER_RATE_TLV_DCM_GET(*tag_buf);
+	ppdu_user_desc->ldpc = HTT_PPDU_STATS_USER_RATE_TLV_LDPC_GET(*tag_buf);
+}
+
+/*
+ * dp_process_ppdu_stats_enq_mpdu_bitmap_64_tlv: Process
+ * htt_ppdu_stats_enq_mpdu_bitmap_64_tlv
+ * pdev: DP PDEV handle
+ * @tag_buf: buffer containing the tlv htt_ppdu_stats_enq_mpdu_bitmap_64_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_enq_mpdu_bitmap_64_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	htt_ppdu_stats_enq_mpdu_bitmap_64_tlv *dp_stats_buf =
+		(htt_ppdu_stats_enq_mpdu_bitmap_64_tlv *)tag_buf;
+
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	uint16_t peer_id;
+	uint32_t size = CDP_BA_64_BIT_MAP_SIZE_DWORDS;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+
+	peer_id =
+	HTT_PPDU_STATS_ENQ_MPDU_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	ppdu_user_desc->peer_id = peer_id;
+
+	ppdu_user_desc->start_seq = dp_stats_buf->start_seq;
+	qdf_mem_copy(&ppdu_user_desc->enq_bitmap, &dp_stats_buf->enq_bitmap,
+		     sizeof(uint32_t) * CDP_BA_64_BIT_MAP_SIZE_DWORDS);
+
+	dp_process_ppdu_stats_update_failed_bitmap(pdev,
+						   (void *)ppdu_user_desc,
+						   ppdu_info->ppdu_id,
+						   size);
+}
+
+/*
+ * dp_process_ppdu_stats_enq_mpdu_bitmap_256_tlv: Process
+ * htt_ppdu_stats_enq_mpdu_bitmap_256_tlv
+ * soc: DP SOC handle
+ * @tag_buf: buffer containing the tlv htt_ppdu_stats_enq_mpdu_bitmap_256_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_enq_mpdu_bitmap_256_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	htt_ppdu_stats_enq_mpdu_bitmap_256_tlv *dp_stats_buf =
+		(htt_ppdu_stats_enq_mpdu_bitmap_256_tlv *)tag_buf;
+
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	uint16_t peer_id;
+	uint32_t size = CDP_BA_256_BIT_MAP_SIZE_DWORDS;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+
+	peer_id =
+	HTT_PPDU_STATS_ENQ_MPDU_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	ppdu_user_desc->peer_id = peer_id;
+
+	ppdu_user_desc->start_seq = dp_stats_buf->start_seq;
+	qdf_mem_copy(&ppdu_user_desc->enq_bitmap, &dp_stats_buf->enq_bitmap,
+		     sizeof(uint32_t) * CDP_BA_256_BIT_MAP_SIZE_DWORDS);
+
+	dp_process_ppdu_stats_update_failed_bitmap(pdev,
+						   (void *)ppdu_user_desc,
+						   ppdu_info->ppdu_id,
+						   size);
+}
+
+/*
+ * dp_process_ppdu_stats_user_cmpltn_common_tlv: Process
+ * htt_ppdu_stats_user_cmpltn_common_tlv
+ * soc: DP SOC handle
+ * @tag_buf: buffer containing the tlv htt_ppdu_stats_user_cmpltn_common_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_user_cmpltn_common_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	uint16_t peer_id;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	uint8_t bw_iter;
+	htt_ppdu_stats_user_cmpltn_common_tlv *dp_stats_buf =
+		(htt_ppdu_stats_user_cmpltn_common_tlv *)tag_buf;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+	peer_id =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	ppdu_user_desc->peer_id = peer_id;
+
+	ppdu_user_desc->completion_status =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_COMPLETION_STATUS_GET(
+				*tag_buf);
+
+	ppdu_user_desc->tid =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_TID_NUM_GET(*tag_buf);
+
+	tag_buf++;
+	if (qdf_likely(ppdu_user_desc->completion_status ==
+			HTT_PPDU_STATS_USER_STATUS_OK)) {
+		ppdu_desc->ack_rssi = dp_stats_buf->ack_rssi;
+		ppdu_user_desc->usr_ack_rssi = dp_stats_buf->ack_rssi;
+		ppdu_user_desc->ack_rssi_valid = 1;
+	} else {
+		ppdu_user_desc->ack_rssi_valid = 0;
+	}
+
+	tag_buf++;
+
+	ppdu_user_desc->mpdu_success =
+	HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MPDU_SUCCESS_GET(*tag_buf);
+
+	ppdu_user_desc->mpdu_failed =
+	HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MPDU_TRIED_GET(*tag_buf) -
+						ppdu_user_desc->mpdu_success;
+
+	tag_buf++;
+
+	ppdu_user_desc->long_retries =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_LONG_RETRY_GET(*tag_buf);
+
+	ppdu_user_desc->short_retries =
+	HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_SHORT_RETRY_GET(*tag_buf);
+	ppdu_user_desc->retry_msdus =
+		ppdu_user_desc->long_retries + ppdu_user_desc->short_retries;
+
+	ppdu_user_desc->is_ampdu =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_IS_AMPDU_GET(*tag_buf);
+	ppdu_info->is_ampdu = ppdu_user_desc->is_ampdu;
+
+	ppdu_desc->resp_type =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_RESP_TYPE_GET(*tag_buf);
+	ppdu_desc->mprot_type =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MPROT_TYPE_GET(*tag_buf);
+	ppdu_desc->rts_success =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_RTS_SUCCESS_GET(*tag_buf);
+	ppdu_desc->rts_failure =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_RTS_FAILURE_GET(*tag_buf);
+	ppdu_user_desc->pream_punct =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_PREAM_PUNC_TX_GET(*tag_buf);
+
+	ppdu_info->compltn_common_tlv++;
+
+	/*
+	 * MU BAR may send request to n users but we may received ack only from
+	 * m users. To have count of number of users respond back, we have a
+	 * separate counter bar_num_users per PPDU that get increment for every
+	 * htt_ppdu_stats_user_cmpltn_common_tlv
+	 */
+	ppdu_desc->bar_num_users++;
+
+	tag_buf++;
+	for (bw_iter = 0; bw_iter < CDP_RSSI_CHAIN_LEN; bw_iter++) {
+		ppdu_user_desc->rssi_chain[bw_iter] =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_CHAIN_RSSI_GET(*tag_buf);
+		tag_buf++;
+	}
+
+	ppdu_user_desc->sa_tx_antenna =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_TX_ANTENNA_MASK_GET(*tag_buf);
+
+	tag_buf++;
+	ppdu_user_desc->sa_is_training =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_IS_TRAINING_GET(*tag_buf);
+	if (ppdu_user_desc->sa_is_training) {
+		ppdu_user_desc->sa_goodput =
+			HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_PENDING_TRAINING_PKTS_GET(*tag_buf);
+	}
+
+	tag_buf++;
+	for (bw_iter = 0; bw_iter < CDP_NUM_SA_BW; bw_iter++) {
+		ppdu_user_desc->sa_max_rates[bw_iter] =
+			HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MAX_RATES_GET(tag_buf[bw_iter]);
+	}
+
+	tag_buf += CDP_NUM_SA_BW;
+	ppdu_user_desc->current_rate_per =
+		HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_CURRENT_RATE_PER_GET(*tag_buf);
+}
+
+/*
+ * dp_process_ppdu_stats_user_compltn_ba_bitmap_64_tlv: Process
+ * htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv
+ * pdev: DP PDEV handle
+ * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_user_compltn_ba_bitmap_64_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv *dp_stats_buf =
+		(htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv *)tag_buf;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	uint8_t curr_user_index = 0;
+	uint16_t peer_id;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+
+	peer_id =
+	HTT_PPDU_STATS_USER_CMPLTN_BA_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	ppdu_user_desc->peer_id = peer_id;
+
+	ppdu_user_desc->ba_seq_no = dp_stats_buf->ba_seq_no;
+	qdf_mem_copy(&ppdu_user_desc->ba_bitmap, &dp_stats_buf->ba_bitmap,
+		     sizeof(uint32_t) * CDP_BA_64_BIT_MAP_SIZE_DWORDS);
+	ppdu_user_desc->ba_size = CDP_BA_64_BIT_MAP_SIZE_DWORDS * 32;
+}
+
+/*
+ * dp_process_ppdu_stats_user_compltn_ba_bitmap_256_tlv: Process
+ * htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv
+ * pdev: DP PDEV handle
+ * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_user_compltn_ba_bitmap_256_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv *dp_stats_buf =
+		(htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv *)tag_buf;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	uint8_t curr_user_index = 0;
+	uint16_t peer_id;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+
+	peer_id =
+	HTT_PPDU_STATS_USER_CMPLTN_BA_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	ppdu_user_desc->peer_id = peer_id;
+
+	ppdu_user_desc->ba_seq_no = dp_stats_buf->ba_seq_no;
+	qdf_mem_copy(&ppdu_user_desc->ba_bitmap, &dp_stats_buf->ba_bitmap,
+		     sizeof(uint32_t) * CDP_BA_256_BIT_MAP_SIZE_DWORDS);
+	ppdu_user_desc->ba_size = CDP_BA_256_BIT_MAP_SIZE_DWORDS * 32;
+}
+
+/*
+ * dp_process_ppdu_stats_user_compltn_ack_ba_status_tlv: Process
+ * htt_ppdu_stats_user_compltn_ack_ba_status_tlv
+ * pdev: DP PDE handle
+ * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ack_ba_status_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_user_compltn_ack_ba_status_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	uint16_t peer_id;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf += 2;
+	peer_id =
+	HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_SW_PEER_ID_GET(*tag_buf);
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+	if (!ppdu_user_desc->ack_ba_tlv) {
+		ppdu_user_desc->ack_ba_tlv = 1;
+	} else {
+		pdev->stats.ack_ba_comes_twice++;
+		return;
+	}
+
+	ppdu_user_desc->peer_id = peer_id;
+
+	tag_buf++;
+	/* not to update ppdu_desc->tid from this TLV */
+	ppdu_user_desc->num_mpdu =
+		HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_NUM_MPDU_GET(*tag_buf);
+
+	ppdu_user_desc->num_msdu =
+		HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_NUM_MSDU_GET(*tag_buf);
+
+	ppdu_user_desc->success_msdus = ppdu_user_desc->num_msdu;
+
+	tag_buf++;
+	ppdu_user_desc->start_seq =
+		HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_START_SEQ_GET(
+			*tag_buf);
+
+	tag_buf++;
+	ppdu_user_desc->success_bytes = *tag_buf;
+
+	/* increase ack ba tlv counter on successful mpdu */
+	if (ppdu_user_desc->num_mpdu)
+		ppdu_info->ack_ba_tlv++;
+
+	if (ppdu_user_desc->ba_size == 0) {
+		ppdu_user_desc->ba_seq_no = ppdu_user_desc->start_seq;
+		ppdu_user_desc->ba_bitmap[0] = 1;
+		ppdu_user_desc->ba_size = 1;
+	}
+}
+
+/*
+ * dp_process_ppdu_stats_user_common_array_tlv: Process
+ * htt_ppdu_stats_user_common_array_tlv
+ * pdev: DP PDEV handle
+ * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ack_ba_status_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void dp_process_ppdu_stats_user_common_array_tlv(
+		struct dp_pdev *pdev, uint32_t *tag_buf,
+		struct ppdu_info *ppdu_info)
+{
+	uint32_t peer_id;
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
+	uint8_t curr_user_index = 0;
+	struct htt_tx_ppdu_stats_info *dp_stats_buf;
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+
+	ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+
+	tag_buf++;
+	dp_stats_buf = (struct htt_tx_ppdu_stats_info *)tag_buf;
+	tag_buf += 3;
+	peer_id =
+		HTT_PPDU_STATS_ARRAY_ITEM_TLV_PEERID_GET(*tag_buf);
+
+	if (!dp_peer_find_by_id_valid(pdev->soc, peer_id)) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "Invalid peer");
+		return;
+	}
+
+	curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
+
+	ppdu_user_desc = &ppdu_desc->user[curr_user_index];
+	ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
+
+	ppdu_user_desc->retry_bytes = dp_stats_buf->tx_retry_bytes;
+	ppdu_user_desc->failed_bytes = dp_stats_buf->tx_failed_bytes;
+
+	tag_buf++;
+
+	ppdu_user_desc->success_msdus =
+		HTT_PPDU_STATS_ARRAY_ITEM_TLV_TX_SUCC_MSDUS_GET(*tag_buf);
+	ppdu_user_desc->retry_bytes =
+		HTT_PPDU_STATS_ARRAY_ITEM_TLV_TX_RETRY_MSDUS_GET(*tag_buf);
+	tag_buf++;
+	ppdu_user_desc->failed_msdus =
+		HTT_PPDU_STATS_ARRAY_ITEM_TLV_TX_FAILED_MSDUS_GET(*tag_buf);
+}
+
+/*
+ * dp_process_ppdu_stats_flush_tlv: Process
+ * htt_ppdu_stats_flush_tlv
+ * @pdev: DP PDEV handle
+ * @tag_buf: buffer containing the htt_ppdu_stats_flush_tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void
+dp_process_ppdu_stats_user_compltn_flush_tlv(struct dp_pdev *pdev,
+					     uint32_t *tag_buf,
+					     struct ppdu_info *ppdu_info)
+{
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	uint32_t peer_id;
+	uint8_t tid;
+	struct dp_peer *peer;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	ppdu_desc = (struct cdp_tx_completion_ppdu *)
+				qdf_nbuf_data(ppdu_info->nbuf);
+	ppdu_desc->is_flush = 1;
+
+	tag_buf++;
+	ppdu_desc->drop_reason = *tag_buf;
+
+	tag_buf++;
+	ppdu_desc->num_msdu = HTT_PPDU_STATS_FLUSH_TLV_NUM_MSDU_GET(*tag_buf);
+	ppdu_desc->num_mpdu = HTT_PPDU_STATS_FLUSH_TLV_NUM_MPDU_GET(*tag_buf);
+	ppdu_desc->flow_type = HTT_PPDU_STATS_FLUSH_TLV_FLOW_TYPE_GET(*tag_buf);
+
+	tag_buf++;
+	peer_id = HTT_PPDU_STATS_FLUSH_TLV_SW_PEER_ID_GET(*tag_buf);
+	tid = HTT_PPDU_STATS_FLUSH_TLV_TID_NUM_GET(*tag_buf);
+
+	ppdu_desc->num_users = 1;
+	ppdu_desc->user[0].peer_id = peer_id;
+	ppdu_desc->user[0].tid = tid;
+
+	ppdu_desc->queue_type =
+			HTT_PPDU_STATS_FLUSH_TLV_QUEUE_TYPE_GET(*tag_buf);
+
+	peer = dp_peer_get_ref_by_id(pdev->soc, peer_id,
+				     DP_MOD_ID_TX_PPDU_STATS);
+	if (!peer)
+		goto add_ppdu_to_sched_list;
+
+	if (ppdu_desc->drop_reason == HTT_FLUSH_EXCESS_RETRIES) {
+		DP_STATS_INC(peer,
+			     tx.excess_retries_per_ac[TID_TO_WME_AC(tid)],
+			     ppdu_desc->num_msdu);
+	}
+
+	dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
+
+add_ppdu_to_sched_list:
+	ppdu_info->done = 1;
+	TAILQ_REMOVE(&mon_pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
+	mon_pdev->list_depth--;
+	TAILQ_INSERT_TAIL(&mon_pdev->sched_comp_ppdu_list, ppdu_info,
+			  ppdu_info_list_elem);
+	mon_pdev->sched_comp_list_depth++;
+}
+
+/**
+ * dp_process_ppdu_stats_sch_cmd_status_tlv: Process schedule command status tlv
+ * Here we are not going to process the buffer.
+ * @pdev: DP PDEV handle
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return:void
+ */
+static void
+dp_process_ppdu_stats_sch_cmd_status_tlv(struct dp_pdev *pdev,
+					 struct ppdu_info *ppdu_info)
+{
+	struct cdp_tx_completion_ppdu *ppdu_desc;
+	struct dp_peer *peer;
+	uint8_t num_users;
+	uint8_t i;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	ppdu_desc = (struct cdp_tx_completion_ppdu *)
+				qdf_nbuf_data(ppdu_info->nbuf);
+
+	num_users = ppdu_desc->bar_num_users;
+
+	for (i = 0; i < num_users; i++) {
+		if (ppdu_desc->user[i].user_pos == 0) {
+			if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) {
+				/* update phy mode for bar frame */
+				ppdu_desc->phy_mode =
+					ppdu_desc->user[i].preamble;
+				ppdu_desc->user[0].mcs = ppdu_desc->user[i].mcs;
+				break;
+			}
+			if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_CTRL) {
+				ppdu_desc->frame_ctrl =
+					ppdu_desc->user[i].frame_ctrl;
+				break;
+			}
+		}
+	}
+
+	if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA &&
+	    ppdu_desc->delayed_ba) {
+		qdf_assert_always(ppdu_desc->num_users <= ppdu_desc->max_users);
+
+		for (i = 0; i < ppdu_desc->num_users; i++) {
+			struct cdp_delayed_tx_completion_ppdu_user *delay_ppdu;
+			uint64_t start_tsf;
+			uint64_t end_tsf;
+			uint32_t ppdu_id;
+			struct dp_mon_peer *mon_peer;
+
+			ppdu_id = ppdu_desc->ppdu_id;
+			peer = dp_peer_get_ref_by_id
+				(pdev->soc, ppdu_desc->user[i].peer_id,
+				 DP_MOD_ID_TX_PPDU_STATS);
+			/**
+			 * This check is to make sure peer is not deleted
+			 * after processing the TLVs.
+			 */
+			if (!peer)
+				continue;
+
+			mon_peer = peer->monitor_peer;
+			delay_ppdu = &mon_peer->delayed_ba_ppdu_stats;
+			start_tsf = ppdu_desc->ppdu_start_timestamp;
+			end_tsf = ppdu_desc->ppdu_end_timestamp;
+			/**
+			 * save delayed ba user info
+			 */
+			if (ppdu_desc->user[i].delayed_ba) {
+				dp_peer_copy_delay_stats(peer,
+							 &ppdu_desc->user[i],
+							 ppdu_id);
+				mon_peer->last_delayed_ba_ppduid = ppdu_id;
+				delay_ppdu->ppdu_start_timestamp = start_tsf;
+				delay_ppdu->ppdu_end_timestamp = end_tsf;
+			}
+			ppdu_desc->user[i].peer_last_delayed_ba =
+				mon_peer->last_delayed_ba;
+
+			dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
+
+			if (ppdu_desc->user[i].delayed_ba &&
+			    !ppdu_desc->user[i].debug_copied) {
+				QDF_TRACE(QDF_MODULE_ID_TXRX,
+					  QDF_TRACE_LEVEL_INFO_MED,
+					  "%s: %d ppdu_id[%d] bar_ppdu_id[%d] num_users[%d] usr[%d] htt_frame_type[%d]\n",
+					  __func__, __LINE__,
+					  ppdu_desc->ppdu_id,
+					  ppdu_desc->bar_ppdu_id,
+					  ppdu_desc->num_users,
+					  i,
+					  ppdu_desc->htt_frame_type);
+			}
+		}
+	}
+
+	/*
+	 * when frame type is BAR and STATS_COMMON_TLV is set
+	 * copy the store peer delayed info to BAR status
+	 */
+	if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) {
+		for (i = 0; i < ppdu_desc->bar_num_users; i++) {
+			struct cdp_delayed_tx_completion_ppdu_user *delay_ppdu;
+			uint64_t start_tsf;
+			uint64_t end_tsf;
+			struct dp_mon_peer *mon_peer;
+
+			peer = dp_peer_get_ref_by_id
+				(pdev->soc,
+				 ppdu_desc->user[i].peer_id,
+				 DP_MOD_ID_TX_PPDU_STATS);
+			/**
+			 * This check is to make sure peer is not deleted
+			 * after processing the TLVs.
+			 */
+			if (!peer)
+				continue;
+
+			mon_peer = peer->monitor_peer;
+			if (ppdu_desc->user[i].completion_status !=
+			    HTT_PPDU_STATS_USER_STATUS_OK) {
+				dp_peer_unref_delete(peer,
+						     DP_MOD_ID_TX_PPDU_STATS);
+				continue;
+			}
+
+			delay_ppdu = &mon_peer->delayed_ba_ppdu_stats;
+			start_tsf = delay_ppdu->ppdu_start_timestamp;
+			end_tsf = delay_ppdu->ppdu_end_timestamp;
+
+			if (mon_peer->last_delayed_ba) {
+				dp_peer_copy_stats_to_bar(peer,
+							  &ppdu_desc->user[i]);
+				ppdu_desc->ppdu_id =
+					mon_peer->last_delayed_ba_ppduid;
+				ppdu_desc->ppdu_start_timestamp = start_tsf;
+				ppdu_desc->ppdu_end_timestamp = end_tsf;
+			}
+			ppdu_desc->user[i].peer_last_delayed_ba =
+						mon_peer->last_delayed_ba;
+			dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
+		}
+	}
+
+	TAILQ_REMOVE(&mon_pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
+	mon_pdev->list_depth--;
+	TAILQ_INSERT_TAIL(&mon_pdev->sched_comp_ppdu_list, ppdu_info,
+			  ppdu_info_list_elem);
+	mon_pdev->sched_comp_list_depth++;
+}
+
+/**
+ * dp_validate_fix_ppdu_tlv(): Function to validate the length of PPDU
+ *
+ * If the TLV length sent as part of PPDU TLV is less that expected size i.e
+ * size of corresponding data structure, pad the remaining bytes with zeros
+ * and continue processing the TLVs
+ *
+ * @pdev: DP pdev handle
+ * @tag_buf: TLV buffer
+ * @tlv_expected_size: Expected size of Tag
+ * @tlv_len: TLV length received from FW
+ *
+ * Return: Pointer to updated TLV
+ */
+static inline uint32_t *dp_validate_fix_ppdu_tlv(struct dp_pdev *pdev,
+						 uint32_t *tag_buf,
+						 uint16_t tlv_expected_size,
+						 uint16_t tlv_len)
+{
+	uint32_t *tlv_desc = tag_buf;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	qdf_assert_always(tlv_len != 0);
+
+	if (tlv_len < tlv_expected_size) {
+		qdf_mem_zero(mon_pdev->ppdu_tlv_buf, tlv_expected_size);
+		qdf_mem_copy(mon_pdev->ppdu_tlv_buf, tag_buf, tlv_len);
+		tlv_desc = mon_pdev->ppdu_tlv_buf;
+	}
+
+	return tlv_desc;
+}
+
+/**
+ * dp_process_ppdu_tag(): Function to process the PPDU TLVs
+ * @pdev: DP pdev handle
+ * @tag_buf: TLV buffer
+ * @tlv_len: length of tlv
+ * @ppdu_info: per ppdu tlv structure
+ *
+ * return: void
+ */
+static void dp_process_ppdu_tag(struct dp_pdev *pdev,
+				uint32_t *tag_buf,
+				uint32_t tlv_len,
+				struct ppdu_info *ppdu_info)
+{
+	uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
+	uint16_t tlv_expected_size;
+	uint32_t *tlv_desc;
+
+	switch (tlv_type) {
+	case HTT_PPDU_STATS_COMMON_TLV:
+		tlv_expected_size = sizeof(htt_ppdu_stats_common_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_common_tlv(pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMMON_TLV:
+		tlv_expected_size = sizeof(htt_ppdu_stats_user_common_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_common_tlv(pdev, tlv_desc,
+						      ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_RATE_TLV:
+		tlv_expected_size = sizeof(htt_ppdu_stats_user_rate_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_rate_tlv(pdev, tlv_desc,
+						    ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_enq_mpdu_bitmap_64_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_enq_mpdu_bitmap_64_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_enq_mpdu_bitmap_256_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_enq_mpdu_bitmap_256_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_user_cmpltn_common_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_cmpltn_common_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_compltn_ba_bitmap_64_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_compltn_ba_bitmap_256_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_user_compltn_ack_ba_status_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_compltn_ack_ba_status_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV:
+		tlv_expected_size =
+			sizeof(htt_ppdu_stats_usr_common_array_tlv_v);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_common_array_tlv(
+				pdev, tlv_desc, ppdu_info);
+		break;
+	case HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV:
+		tlv_expected_size = sizeof(htt_ppdu_stats_flush_tlv);
+		tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
+						    tlv_expected_size, tlv_len);
+		dp_process_ppdu_stats_user_compltn_flush_tlv(pdev, tlv_desc,
+							     ppdu_info);
+		break;
+	case HTT_PPDU_STATS_SCH_CMD_STATUS_TLV:
+		dp_process_ppdu_stats_sch_cmd_status_tlv(pdev, ppdu_info);
+		break;
+	default:
+		break;
+	}
+}
+
+#ifdef WLAN_ATF_ENABLE
+static void
+dp_ppdu_desc_user_phy_tx_time_update(struct dp_pdev *pdev,
+				     struct cdp_tx_completion_ppdu *ppdu_desc,
+				     struct cdp_tx_completion_ppdu_user *user)
+{
+	uint32_t nss_ru_width_sum = 0;
+	struct dp_mon_pdev *mon_pdev = NULL;
+
+	if (!pdev || !ppdu_desc || !user)
+		return;
+
+	mon_pdev = pdev->monitor_pdev;
+
+	if (!mon_pdev || !mon_pdev->dp_atf_stats_enable)
+		return;
+
+	if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_DATA)
+		return;
+
+	nss_ru_width_sum = ppdu_desc->usr_nss_sum * ppdu_desc->usr_ru_tones_sum;
+	if (!nss_ru_width_sum)
+		nss_ru_width_sum = 1;
+
+	/**
+	 * For SU-MIMO PPDU phy Tx time is same for the single user.
+	 * For MU-MIMO phy Tx time is calculated per user as below
+	 *     user phy tx time =
+	 *           Entire PPDU duration * MU Ratio * OFDMA Ratio
+	 *     MU Ratio = usr_nss / Sum_of_nss_of_all_users
+	 *     OFDMA_ratio = usr_ru_width / Sum_of_ru_width_of_all_users
+	 *     usr_ru_widt = ru_end – ru_start + 1
+	 */
+	if (ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_TIDQ_DATA_SU) {
+		user->phy_tx_time_us = ppdu_desc->phy_ppdu_tx_time_us;
+	} else {
+		user->phy_tx_time_us = (ppdu_desc->phy_ppdu_tx_time_us *
+				user->nss * user->ru_tones) / nss_ru_width_sum;
+	}
+}
+#else
+static void
+dp_ppdu_desc_user_phy_tx_time_update(struct dp_pdev *pdev,
+				     struct cdp_tx_completion_ppdu *ppdu_desc,
+				     struct cdp_tx_completion_ppdu_user *user)
+{
+}
+#endif
+
+/**
+ * dp_ppdu_desc_user_stats_update(): Function to update TX user stats
+ * @pdev: DP pdev handle
+ * @ppdu_info: per PPDU TLV descriptor
+ *
+ * return: void
+ */
+void
+dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
+			       struct ppdu_info *ppdu_info)
+{
+	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
+	struct dp_peer *peer = NULL;
+	uint32_t tlv_bitmap_expected;
+	uint32_t tlv_bitmap_default;
+	uint16_t i;
+	uint32_t num_users;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	ppdu_desc = (struct cdp_tx_completion_ppdu *)
+		qdf_nbuf_data(ppdu_info->nbuf);
+
+	if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_BAR)
+		ppdu_desc->ppdu_id = ppdu_info->ppdu_id;
+
+	tlv_bitmap_expected = HTT_PPDU_DEFAULT_TLV_BITMAP;
+	if (mon_pdev->tx_sniffer_enable || mon_pdev->mcopy_mode ||
+	    mon_pdev->tx_capture_enabled) {
+		if (ppdu_info->is_ampdu)
+			tlv_bitmap_expected =
+				dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(
+					ppdu_info->tlv_bitmap);
+	}
+
+	tlv_bitmap_default = tlv_bitmap_expected;
+
+	if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) {
+		num_users = ppdu_desc->bar_num_users;
+		ppdu_desc->num_users = ppdu_desc->bar_num_users;
+	} else {
+		num_users = ppdu_desc->num_users;
+	}
+	qdf_assert_always(ppdu_desc->num_users <= ppdu_desc->max_users);
+
+	for (i = 0; i < num_users; i++) {
+		ppdu_desc->num_mpdu += ppdu_desc->user[i].num_mpdu;
+		ppdu_desc->num_msdu += ppdu_desc->user[i].num_msdu;
+
+		peer = dp_peer_get_ref_by_id(pdev->soc,
+					     ppdu_desc->user[i].peer_id,
+					     DP_MOD_ID_TX_PPDU_STATS);
+		/**
+		 * This check is to make sure peer is not deleted
+		 * after processing the TLVs.
+		 */
+		if (!peer)
+			continue;
+
+		ppdu_desc->user[i].is_bss_peer = peer->bss_peer;
+		/*
+		 * different frame like DATA, BAR or CTRL has different
+		 * tlv bitmap expected. Apart from ACK_BA_STATUS TLV, we
+		 * receive other tlv in-order/sequential from fw.
+		 * Since ACK_BA_STATUS TLV come from Hardware it is
+		 * asynchronous So we need to depend on some tlv to confirm
+		 * all tlv is received for a ppdu.
+		 * So we depend on both SCHED_CMD_STATUS_TLV and
+		 * ACK_BA_STATUS_TLV. for failure packet we won't get
+		 * ACK_BA_STATUS_TLV.
+		 */
+		if (!(ppdu_info->tlv_bitmap &
+		      (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV)) ||
+		    (!(ppdu_info->tlv_bitmap &
+		       (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV)) &&
+		     (ppdu_desc->user[i].completion_status ==
+		      HTT_PPDU_STATS_USER_STATUS_OK))) {
+			dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
+			continue;
+		}
+
+		/**
+		 * Update tx stats for data frames having Qos as well as
+		 * non-Qos data tid
+		 */
+
+		if ((ppdu_desc->user[i].tid < CDP_DATA_TID_MAX ||
+		     (ppdu_desc->user[i].tid == CDP_DATA_NON_QOS_TID) ||
+		     (ppdu_desc->htt_frame_type ==
+		      HTT_STATS_FTYPE_SGEN_QOS_NULL) ||
+		     ((ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) &&
+		      (ppdu_desc->num_mpdu > 1))) &&
+		      (ppdu_desc->frame_type != CDP_PPDU_FTYPE_CTRL)) {
+			dp_tx_stats_update(pdev, peer,
+					   &ppdu_desc->user[i],
+					   ppdu_desc->ack_rssi);
+			dp_tx_rate_stats_update(peer, &ppdu_desc->user[i]);
+		}
+
+		dp_ppdu_desc_user_phy_tx_time_update(pdev, ppdu_desc,
+						     &ppdu_desc->user[i]);
+
+		dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
+		tlv_bitmap_expected = tlv_bitmap_default;
+	}
+}
+
+#ifndef WLAN_TX_PKT_CAPTURE_ENH
+
+/**
+ * dp_ppdu_desc_deliver(): Function to deliver Tx PPDU status descriptor
+ * to upper layer
+ * @pdev: DP pdev handle
+ * @ppdu_info: per PPDU TLV descriptor
+ *
+ * return: void
+ */
+static
+void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
+			  struct ppdu_info *ppdu_info)
+{
+	struct ppdu_info *s_ppdu_info = NULL;
+	struct ppdu_info *ppdu_info_next = NULL;
+	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
+	qdf_nbuf_t nbuf;
+	uint32_t time_delta = 0;
+	bool starved = 0;
+	bool matched = 0;
+	bool recv_ack_ba_done = 0;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (ppdu_info->tlv_bitmap &
+	    (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) &&
+	    ppdu_info->done)
+		recv_ack_ba_done = 1;
+
+	mon_pdev->last_sched_cmdid = ppdu_info->sched_cmdid;
+
+	s_ppdu_info = TAILQ_FIRST(&mon_pdev->sched_comp_ppdu_list);
+
+	TAILQ_FOREACH_SAFE(s_ppdu_info, &mon_pdev->sched_comp_ppdu_list,
+			   ppdu_info_list_elem, ppdu_info_next) {
+		if (s_ppdu_info->tsf_l32 > ppdu_info->tsf_l32)
+			time_delta = (MAX_TSF_32 - s_ppdu_info->tsf_l32) +
+					ppdu_info->tsf_l32;
+		else
+			time_delta = ppdu_info->tsf_l32 - s_ppdu_info->tsf_l32;
+
+		if (!s_ppdu_info->done && !recv_ack_ba_done) {
+			if (time_delta < MAX_SCHED_STARVE) {
+				dp_mon_info("pdev[%d] ppdu_id[%d] sched_cmdid[%d] TLV_B[0x%x] TSF[%u] D[%d]",
+					    pdev->pdev_id,
+					    s_ppdu_info->ppdu_id,
+					    s_ppdu_info->sched_cmdid,
+					    s_ppdu_info->tlv_bitmap,
+					    s_ppdu_info->tsf_l32,
+					    s_ppdu_info->done);
+				break;
+			}
+			starved = 1;
+		}
+
+		mon_pdev->delivered_sched_cmdid = s_ppdu_info->sched_cmdid;
+		TAILQ_REMOVE(&mon_pdev->sched_comp_ppdu_list, s_ppdu_info,
+			     ppdu_info_list_elem);
+		mon_pdev->sched_comp_list_depth--;
+
+		nbuf = s_ppdu_info->nbuf;
+		qdf_assert_always(nbuf);
+		ppdu_desc = (struct cdp_tx_completion_ppdu *)
+				qdf_nbuf_data(nbuf);
+		ppdu_desc->tlv_bitmap = s_ppdu_info->tlv_bitmap;
+
+		if (starved) {
+			dp_mon_err("ppdu starved fc[0x%x] h_ftype[%d] tlv_bitmap[0x%x] cs[%d]\n",
+				   ppdu_desc->frame_ctrl,
+				   ppdu_desc->htt_frame_type,
+				   ppdu_desc->tlv_bitmap,
+				   ppdu_desc->user[0].completion_status);
+			starved = 0;
+		}
+
+		if (ppdu_info->ppdu_id == s_ppdu_info->ppdu_id &&
+		    ppdu_info->sched_cmdid == s_ppdu_info->sched_cmdid)
+			matched = 1;
+
+		dp_ppdu_desc_user_stats_update(pdev, s_ppdu_info);
+
+		qdf_mem_free(s_ppdu_info);
+
+		/**
+		 * Deliver PPDU stats only for valid (acked) data
+		 * frames if sniffer mode is not enabled.
+		 * If sniffer mode is enabled, PPDU stats
+		 * for all frames including mgmt/control
+		 * frames should be delivered to upper layer
+		 */
+		if (mon_pdev->tx_sniffer_enable || mon_pdev->mcopy_mode) {
+			dp_wdi_event_handler(WDI_EVENT_TX_PPDU_DESC,
+					     pdev->soc,
+					     nbuf, HTT_INVALID_PEER,
+					     WDI_NO_VAL,
+					     pdev->pdev_id);
+		} else {
+			if (ppdu_desc->num_mpdu != 0 &&
+			    ppdu_desc->num_users != 0 &&
+			    ppdu_desc->frame_ctrl &
+			    HTT_FRAMECTRL_DATATYPE) {
+				dp_wdi_event_handler(WDI_EVENT_TX_PPDU_DESC,
+						     pdev->soc,
+						     nbuf, HTT_INVALID_PEER,
+						     WDI_NO_VAL,
+						     pdev->pdev_id);
+			} else {
+				qdf_nbuf_free(nbuf);
+			}
+		}
+
+		if (matched)
+			break;
+	}
+}
+
+#endif
+
+/**
+ * dp_get_ppdu_desc(): Function to allocate new PPDU status
+ * desc for new ppdu id
+ * @pdev: DP pdev handle
+ * @ppdu_id: PPDU unique identifier
+ * @tlv_type: TLV type received
+ * @tsf_l32: timestamp received along with ppdu stats indication header
+ * @max_users: Maximum user for that particular ppdu
+ *
+ * return: ppdu_info per ppdu tlv structure
+ */
+static
+struct ppdu_info *dp_get_ppdu_desc(struct dp_pdev *pdev, uint32_t ppdu_id,
+				   uint8_t tlv_type, uint32_t tsf_l32,
+				   uint8_t max_users)
+{
+	struct ppdu_info *ppdu_info = NULL;
+	struct ppdu_info *s_ppdu_info = NULL;
+	struct ppdu_info *ppdu_info_next = NULL;
+	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
+	uint32_t size = 0;
+	struct cdp_tx_completion_ppdu *tmp_ppdu_desc = NULL;
+	struct cdp_tx_completion_ppdu_user *tmp_user;
+	uint32_t time_delta;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	/*
+	 * Find ppdu_id node exists or not
+	 */
+	TAILQ_FOREACH_SAFE(ppdu_info, &mon_pdev->ppdu_info_list,
+			   ppdu_info_list_elem, ppdu_info_next) {
+		if (ppdu_info && (ppdu_info->ppdu_id == ppdu_id)) {
+			if (ppdu_info->tsf_l32 > tsf_l32)
+				time_delta  = (MAX_TSF_32 -
+					       ppdu_info->tsf_l32) + tsf_l32;
+			else
+				time_delta  = tsf_l32 - ppdu_info->tsf_l32;
+
+			if (time_delta > WRAP_DROP_TSF_DELTA) {
+				TAILQ_REMOVE(&mon_pdev->ppdu_info_list,
+					     ppdu_info, ppdu_info_list_elem);
+				mon_pdev->list_depth--;
+				pdev->stats.ppdu_wrap_drop++;
+				tmp_ppdu_desc =
+					(struct cdp_tx_completion_ppdu *)
+					qdf_nbuf_data(ppdu_info->nbuf);
+				tmp_user = &tmp_ppdu_desc->user[0];
+				dp_htt_tx_stats_info("S_PID [%d] S_TSF[%u] TLV_BITMAP[0x%x] [CMPLTN - %d ACK_BA - %d] CS[%d] - R_PID[%d] R_TSF[%u] R_TLV_TAG[0x%x]\n",
+						     ppdu_info->ppdu_id,
+						     ppdu_info->tsf_l32,
+						     ppdu_info->tlv_bitmap,
+						     tmp_user->completion_status,
+						     ppdu_info->compltn_common_tlv,
+						     ppdu_info->ack_ba_tlv,
+						     ppdu_id, tsf_l32,
+						     tlv_type);
+				qdf_nbuf_free(ppdu_info->nbuf);
+				ppdu_info->nbuf = NULL;
+				qdf_mem_free(ppdu_info);
+			} else {
+				break;
+			}
+		}
+	}
+
+	/*
+	 * check if it is ack ba tlv and if it is not there in ppdu info
+	 * list then check it in sched completion ppdu list
+	 */
+	if (!ppdu_info &&
+	    tlv_type == HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) {
+		TAILQ_FOREACH(s_ppdu_info,
+			      &mon_pdev->sched_comp_ppdu_list,
+			      ppdu_info_list_elem) {
+			if (s_ppdu_info && (s_ppdu_info->ppdu_id == ppdu_id)) {
+				if (s_ppdu_info->tsf_l32 > tsf_l32)
+					time_delta  = (MAX_TSF_32 -
+						       s_ppdu_info->tsf_l32) +
+							tsf_l32;
+				else
+					time_delta  = tsf_l32 -
+						s_ppdu_info->tsf_l32;
+				if (time_delta < WRAP_DROP_TSF_DELTA) {
+					ppdu_info = s_ppdu_info;
+					break;
+				}
+			} else {
+				/*
+				 * ACK BA STATUS TLV comes sequential order
+				 * if we received ack ba status tlv for second
+				 * ppdu and first ppdu is still waiting for
+				 * ACK BA STATUS TLV. Based on fw comment
+				 * we won't receive it tlv later. So we can
+				 * set ppdu info done.
+				 */
+				if (s_ppdu_info)
+					s_ppdu_info->done = 1;
+			}
+		}
+	}
+
+	if (ppdu_info) {
+		if (ppdu_info->tlv_bitmap & (1 << tlv_type)) {
+			/**
+			 * if we get tlv_type that is already been processed
+			 * for ppdu, that means we got a new ppdu with same
+			 * ppdu id. Hence Flush the older ppdu
+			 * for MUMIMO and OFDMA, In a PPDU we have
+			 * multiple user with same tlv types. tlv bitmap is
+			 * used to check whether SU or MU_MIMO/OFDMA
+			 */
+			if (!(ppdu_info->tlv_bitmap &
+			    (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV)))
+				return ppdu_info;
+
+			ppdu_desc = (struct cdp_tx_completion_ppdu *)
+				qdf_nbuf_data(ppdu_info->nbuf);
+
+			/**
+			 * apart from ACK BA STATUS TLV rest all comes in order
+			 * so if tlv type not ACK BA STATUS TLV we can deliver
+			 * ppdu_info
+			 */
+			if ((tlv_type ==
+			     HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) &&
+			    (ppdu_desc->htt_frame_type ==
+			     HTT_STATS_FTYPE_SGEN_MU_BAR))
+				return ppdu_info;
+
+			dp_ppdu_desc_deliver(pdev, ppdu_info);
+		} else {
+			return ppdu_info;
+		}
+	}
+
+	/**
+	 * Flush the head ppdu descriptor if ppdu desc list reaches max
+	 * threshold
+	 */
+	if (mon_pdev->list_depth > HTT_PPDU_DESC_MAX_DEPTH) {
+		ppdu_info = TAILQ_FIRST(&mon_pdev->ppdu_info_list);
+		TAILQ_REMOVE(&mon_pdev->ppdu_info_list,
+			     ppdu_info, ppdu_info_list_elem);
+		mon_pdev->list_depth--;
+		pdev->stats.ppdu_drop++;
+		qdf_nbuf_free(ppdu_info->nbuf);
+		ppdu_info->nbuf = NULL;
+		qdf_mem_free(ppdu_info);
+	}
+
+	size = sizeof(struct cdp_tx_completion_ppdu) +
+		(max_users * sizeof(struct cdp_tx_completion_ppdu_user));
+
+	/*
+	 * Allocate new ppdu_info node
+	 */
+	ppdu_info = qdf_mem_malloc(sizeof(struct ppdu_info));
+	if (!ppdu_info)
+		return NULL;
+
+	ppdu_info->nbuf = qdf_nbuf_alloc(pdev->soc->osdev, size,
+					 0, 4, TRUE);
+	if (!ppdu_info->nbuf) {
+		qdf_mem_free(ppdu_info);
+		return NULL;
+	}
+
+	ppdu_info->ppdu_desc =
+		(struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
+	qdf_mem_zero(qdf_nbuf_data(ppdu_info->nbuf), size);
+
+	if (!qdf_nbuf_put_tail(ppdu_info->nbuf, size)) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "No tailroom for HTT PPDU");
+		qdf_nbuf_free(ppdu_info->nbuf);
+		ppdu_info->nbuf = NULL;
+		ppdu_info->last_user = 0;
+		qdf_mem_free(ppdu_info);
+		return NULL;
+	}
+
+	ppdu_info->ppdu_desc->max_users = max_users;
+	ppdu_info->tsf_l32 = tsf_l32;
+	/**
+	 * No lock is needed because all PPDU TLVs are processed in
+	 * same context and this list is updated in same context
+	 */
+	TAILQ_INSERT_TAIL(&mon_pdev->ppdu_info_list, ppdu_info,
+			  ppdu_info_list_elem);
+	mon_pdev->list_depth++;
+	return ppdu_info;
+}
+
+/**
+ * dp_htt_process_tlv(): Function to process each PPDU TLVs
+ * @pdev: DP pdev handle
+ * @htt_t2h_msg: HTT target to host message
+ *
+ * return: ppdu_info per ppdu tlv structure
+ */
+
+static struct ppdu_info *dp_htt_process_tlv(struct dp_pdev *pdev,
+					    qdf_nbuf_t htt_t2h_msg)
+{
+	uint32_t length;
+	uint32_t ppdu_id;
+	uint8_t tlv_type;
+	uint32_t tlv_length, tlv_bitmap_expected;
+	uint8_t *tlv_buf;
+	struct ppdu_info *ppdu_info = NULL;
+	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
+	uint8_t max_users = CDP_MU_MAX_USERS;
+	uint32_t tsf_l32;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	uint32_t *msg_word = (uint32_t *)qdf_nbuf_data(htt_t2h_msg);
+
+	length = HTT_T2H_PPDU_STATS_PAYLOAD_SIZE_GET(*msg_word);
+
+	msg_word = msg_word + 1;
+	ppdu_id = HTT_T2H_PPDU_STATS_PPDU_ID_GET(*msg_word);
+
+	msg_word = msg_word + 1;
+	tsf_l32 = (uint32_t)(*msg_word);
+
+	msg_word = msg_word + 2;
+	while (length > 0) {
+		tlv_buf = (uint8_t *)msg_word;
+		tlv_type = HTT_STATS_TLV_TAG_GET(*msg_word);
+		tlv_length = HTT_STATS_TLV_LENGTH_GET(*msg_word);
+		if (qdf_likely(tlv_type < CDP_PPDU_STATS_MAX_TAG))
+			pdev->stats.ppdu_stats_counter[tlv_type]++;
+
+		if (tlv_length == 0)
+			break;
+
+		tlv_length += HTT_TLV_HDR_LEN;
+
+		/**
+		 * Not allocating separate ppdu descriptor for MGMT Payload
+		 * TLV as this is sent as separate WDI indication and it
+		 * doesn't contain any ppdu information
+		 */
+		if (tlv_type == HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) {
+			mon_pdev->mgmtctrl_frm_info.mgmt_buf = tlv_buf;
+			mon_pdev->mgmtctrl_frm_info.ppdu_id = ppdu_id;
+			mon_pdev->mgmtctrl_frm_info.mgmt_buf_len =
+				HTT_PPDU_STATS_TX_MGMTCTRL_TLV_FRAME_LENGTH_GET
+						(*(msg_word + 1));
+			msg_word =
+				(uint32_t *)((uint8_t *)tlv_buf + tlv_length);
+			length -= (tlv_length);
+			continue;
+		}
+
+		/*
+		 * retrieve max_users if it's USERS_INFO,
+		 * else, it's 1 for COMPLTN_FLUSH,
+		 * else, use CDP_MU_MAX_USERS
+		 */
+		if (tlv_type == HTT_PPDU_STATS_USERS_INFO_TLV) {
+			max_users =
+				HTT_PPDU_STATS_USERS_INFO_TLV_MAX_USERS_GET(*(msg_word + 1));
+		} else if (tlv_type == HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) {
+			max_users = 1;
+		}
+
+		ppdu_info = dp_get_ppdu_desc(pdev, ppdu_id, tlv_type,
+					     tsf_l32, max_users);
+		if (!ppdu_info)
+			return NULL;
+
+		ppdu_info->ppdu_id = ppdu_id;
+		ppdu_info->tlv_bitmap |= (1 << tlv_type);
+
+		dp_process_ppdu_tag(pdev, msg_word, tlv_length, ppdu_info);
+
+		/**
+		 * Increment pdev level tlv count to monitor
+		 * missing TLVs
+		 */
+		mon_pdev->tlv_count++;
+		ppdu_info->last_tlv_cnt = mon_pdev->tlv_count;
+		msg_word = (uint32_t *)((uint8_t *)tlv_buf + tlv_length);
+		length -= (tlv_length);
+	}
+
+	if (!ppdu_info)
+		return NULL;
+
+	mon_pdev->last_ppdu_id = ppdu_id;
+
+	tlv_bitmap_expected = HTT_PPDU_DEFAULT_TLV_BITMAP;
+
+	if (mon_pdev->tx_sniffer_enable || mon_pdev->mcopy_mode ||
+	    mon_pdev->tx_capture_enabled) {
+		if (ppdu_info->is_ampdu)
+			tlv_bitmap_expected =
+				dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(
+					ppdu_info->tlv_bitmap);
+	}
+
+	ppdu_desc = ppdu_info->ppdu_desc;
+
+	if (!ppdu_desc)
+		return NULL;
+
+	if (ppdu_desc->user[ppdu_desc->last_usr_index].completion_status !=
+	    HTT_PPDU_STATS_USER_STATUS_OK) {
+		tlv_bitmap_expected = tlv_bitmap_expected & 0xFF;
+	}
+
+	/*
+	 * for frame type DATA and BAR, we update stats based on MSDU,
+	 * successful msdu and mpdu are populate from ACK BA STATUS TLV
+	 * which comes out of order. successful mpdu also populated from
+	 * COMPLTN COMMON TLV which comes in order. for every ppdu_info
+	 * we store successful mpdu from both tlv and compare before delivering
+	 * to make sure we received ACK BA STATUS TLV. For some self generated
+	 * frame we won't get ack ba status tlv so no need to wait for
+	 * ack ba status tlv.
+	 */
+	if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_CTRL &&
+	    ppdu_desc->htt_frame_type != HTT_STATS_FTYPE_SGEN_QOS_NULL) {
+		/*
+		 * most of the time bar frame will have duplicate ack ba
+		 * status tlv
+		 */
+		if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR &&
+		    (ppdu_info->compltn_common_tlv != ppdu_info->ack_ba_tlv))
+			return NULL;
+		/*
+		 * For data frame, compltn common tlv should match ack ba status
+		 * tlv and completion status. Reason we are checking first user
+		 * for ofdma, completion seen at next MU BAR frm, for mimo
+		 * only for first user completion will be immediate.
+		 */
+		if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA &&
+		    (ppdu_desc->user[0].completion_status == 0 &&
+		     (ppdu_info->compltn_common_tlv != ppdu_info->ack_ba_tlv)))
+			return NULL;
+	}
+
+	/**
+	 * Once all the TLVs for a given PPDU has been processed,
+	 * return PPDU status to be delivered to higher layer.
+	 * tlv_bitmap_expected can't be available for different frame type.
+	 * But SCHED CMD STATS TLV is the last TLV from the FW for a ppdu.
+	 * apart from ACK BA TLV, FW sends other TLV in sequential order.
+	 * flush tlv comes separate.
+	 */
+	if ((ppdu_info->tlv_bitmap != 0 &&
+	     (ppdu_info->tlv_bitmap &
+	      (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV))) ||
+	    (ppdu_info->tlv_bitmap &
+	     (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV))) {
+		ppdu_info->done = 1;
+		return ppdu_info;
+	}
+
+	return NULL;
+}
+#endif /* QCA_ENHANCED_STATS_SUPPORT */
+
+/**
+ * dp_txrx_ppdu_stats_handler() - Function to process HTT PPDU stats from FW
+ * @soc: DP SOC handle
+ * @pdev_id: pdev id
+ * @htt_t2h_msg: HTT message nbuf
+ *
+ * return:void
+ */
+#if defined(WDI_EVENT_ENABLE)
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+static bool dp_txrx_ppdu_stats_handler(struct dp_soc *soc,
+				       uint8_t pdev_id, qdf_nbuf_t htt_t2h_msg)
+{
+	struct dp_pdev *pdev = soc->pdev_list[pdev_id];
+	struct ppdu_info *ppdu_info = NULL;
+	bool free_buf = true;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (pdev_id >= MAX_PDEV_CNT)
+		return true;
+
+	pdev = soc->pdev_list[pdev_id];
+	if (!pdev)
+		return true;
+
+	if (!mon_pdev->enhanced_stats_en && !mon_pdev->tx_sniffer_enable &&
+	    !mon_pdev->mcopy_mode && !mon_pdev->bpr_enable)
+		return free_buf;
+
+	qdf_spin_lock_bh(&mon_pdev->ppdu_stats_lock);
+	ppdu_info = dp_htt_process_tlv(pdev, htt_t2h_msg);
+
+	if (mon_pdev->mgmtctrl_frm_info.mgmt_buf) {
+		if (dp_process_ppdu_stats_tx_mgmtctrl_payload_tlv
+		    (pdev, htt_t2h_msg, mon_pdev->mgmtctrl_frm_info.ppdu_id) !=
+		    QDF_STATUS_SUCCESS)
+			free_buf = false;
+	}
+
+	if (ppdu_info)
+		dp_ppdu_desc_deliver(pdev, ppdu_info);
+
+	mon_pdev->mgmtctrl_frm_info.mgmt_buf = NULL;
+	mon_pdev->mgmtctrl_frm_info.mgmt_buf_len = 0;
+	mon_pdev->mgmtctrl_frm_info.ppdu_id = 0;
+
+	qdf_spin_unlock_bh(&mon_pdev->ppdu_stats_lock);
+
+	return free_buf;
+}
+#else
+static bool dp_txrx_ppdu_stats_handler(struct dp_soc *soc,
+				       uint8_t pdev_id, qdf_nbuf_t htt_t2h_msg)
+{
+	return true;
+}
+#endif/* QCA_ENHANCED_STATS_SUPPORT */
+#endif
+
+#if defined(WDI_EVENT_ENABLE) &&\
+	(defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG))
+/*
+ * dp_ppdu_stats_ind_handler() - PPDU stats msg handler
+ * @htt_soc:	 HTT SOC handle
+ * @msg_word:    Pointer to payload
+ * @htt_t2h_msg: HTT msg nbuf
+ *
+ * Return: True if buffer should be freed by caller.
+ */
+static inline bool
+dp_ppdu_stats_ind_handler(struct htt_soc *soc,
+			  uint32_t *msg_word,
+			  qdf_nbuf_t htt_t2h_msg)
+{
+	u_int8_t pdev_id;
+	u_int8_t target_pdev_id;
+	bool free_buf;
+
+	target_pdev_id = HTT_T2H_PPDU_STATS_PDEV_ID_GET(*msg_word);
+	pdev_id = dp_get_host_pdev_id_for_target_pdev_id(soc->dp_soc,
+							 target_pdev_id);
+	dp_wdi_event_handler(WDI_EVENT_LITE_T2H, soc->dp_soc,
+			     htt_t2h_msg, HTT_INVALID_PEER, WDI_NO_VAL,
+			     pdev_id);
+
+	free_buf = dp_txrx_ppdu_stats_handler(soc->dp_soc, pdev_id,
+					      htt_t2h_msg);
+
+	return free_buf;
+}
+#endif
+
+#ifndef QCA_SUPPORT_FULL_MON
+/**
+ * dp_rx_mon_process () - Core brain processing for monitor mode
+ *
+ * This API processes monitor destination ring followed by monitor status ring
+ * Called from bottom half (tasklet/NET_RX_SOFTIRQ)
+ *
+ * @soc: datapath soc context
+ * @int_ctx: interrupt context
+ * @mac_id: mac_id on which interrupt is received
+ * @quota: Number of status ring entry that can be serviced in one shot.
+ *
+ * @Return: Number of reaped status ring entries
+ */
+static inline uint32_t
+dp_rx_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
+		  uint32_t mac_id, uint32_t quota)
+{
+	return quota;
+}
+#endif
+
+#ifndef DISABLE_MON_CONFIG
+static uint32_t
+dp_rx_mon_process_1_0(struct dp_soc *soc, struct dp_intr *int_ctx,
+	              uint32_t mac_id, uint32_t quota)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+
+	if (qdf_unlikely(mon_soc->full_mon_mode))
+		return dp_rx_mon_process(soc, int_ctx, mac_id, quota);
+
+	return dp_rx_mon_status_process(soc, int_ctx, mac_id, quota);
+}
+#else
+static uint32_t
+dp_rx_mon_process_1_0(struct dp_soc *soc, struct dp_intr *int_ctx,
+	              uint32_t mac_id, uint32_t quota)
+{
+	return 0;
+}
+#endif
+
+struct dp_mon_ops monitor_ops_1_0 = {
+	.mon_soc_cfg_init = dp_mon_soc_cfg_init,
+	.mon_pdev_attach = dp_mon_pdev_attach,
+	.mon_pdev_detach = dp_mon_pdev_detach,
+	.mon_pdev_init = dp_mon_pdev_init,
+	.mon_pdev_deinit = dp_mon_pdev_deinit,
+	.mon_vdev_attach = dp_mon_vdev_attach,
+	.mon_vdev_detach = dp_mon_vdev_detach,
+	.mon_peer_attach = dp_mon_peer_attach,
+	.mon_peer_detach = dp_mon_peer_detach,
+	.mon_config_debug_sniffer = dp_config_debug_sniffer,
+	.mon_flush_rings = dp_flush_monitor_rings,
+#if !defined(DISABLE_MON_CONFIG)
+	.mon_htt_srng_setup = dp_mon_htt_srng_setup_1_0,
+#endif
+#if defined(DP_CON_MON)
+	.mon_service_rings = dp_service_mon_rings,
+#endif
+#ifndef DISABLE_MON_CONFIG
+	.mon_rx_process = dp_rx_mon_process_1_0,
+#endif
+#if !defined(DISABLE_MON_CONFIG) && defined(MON_ENABLE_DROP_FOR_MAC)
+	.mon_drop_packets_for_mac = dp_mon_drop_packets_for_mac,
+#endif
+	.mon_peer_tx_init = dp_peer_tx_init,
+	.mon_peer_tx_cleanup = dp_peer_tx_cleanup,
+#ifdef WLAN_TX_PKT_CAPTURE_ENH
+	.mon_peer_tid_peer_id_update = dp_peer_tid_peer_id_update,
+	.mon_tx_ppdu_stats_attach = dp_tx_ppdu_stats_attach,
+	.mon_tx_ppdu_stats_detach = dp_tx_ppdu_stats_detach,
+	.mon_tx_capture_debugfs_init = dp_tx_capture_debugfs_init,
+	.mon_tx_add_to_comp_queue = dp_tx_add_to_comp_queue,
+	.mon_peer_tx_capture_filter_check = dp_peer_tx_capture_filter_check,
+#endif
+#if defined(WDI_EVENT_ENABLE) &&\
+	(defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG))
+	.mon_ppdu_stats_ind_handler = dp_ppdu_stats_ind_handler,
+#endif
+	.mon_htt_ppdu_stats_attach = dp_htt_ppdu_stats_attach,
+	.mon_htt_ppdu_stats_detach = dp_htt_ppdu_stats_detach,
+	.mon_print_pdev_rx_mon_stats = dp_print_pdev_rx_mon_stats,
+#ifdef WLAN_TX_PKT_CAPTURE_ENH
+	.mon_print_pdev_tx_capture_stats = dp_print_pdev_tx_capture_stats,
+	.mon_config_enh_tx_capture = dp_config_enh_tx_capture,
+#endif
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+	.mon_config_enh_rx_capture = dp_config_enh_rx_capture,
+#endif
+#ifdef QCA_SUPPORT_BPR
+	.mon_set_bpr_enable = dp_set_bpr_enable_1_0,
+#endif
+
+#ifdef ATH_SUPPORT_NAC
+	.mon_set_filter_neigh_peers = dp_set_filter_neigh_peers,
+#endif
+#ifdef WLAN_ATF_ENABLE
+	.mon_set_atf_stats_enable = dp_set_atf_stats_enable,
+#endif
+	.mon_set_bsscolor = dp_mon_set_bsscolor,
+	.mon_pdev_get_filter_ucast_data = dp_pdev_get_filter_ucast_data,
+	.mon_pdev_get_filter_mcast_data = dp_pdev_get_filter_mcast_data,
+	.mon_pdev_get_filter_non_data = dp_pdev_get_filter_non_data,
+#ifdef WDI_EVENT_ENABLE
+	.mon_set_pktlog_wifi3 = dp_set_pktlog_wifi3,
+#endif
+#if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
+	.mon_pktlogmod_exit = dp_pktlogmod_exit,
+#endif
+	.mon_vdev_set_monitor_mode_buf_rings =
+			dp_vdev_set_monitor_mode_buf_rings,
+	.mon_vdev_set_monitor_mode_rings =
+			dp_vdev_set_monitor_mode_rings,
+	.mon_neighbour_peers_detach = dp_neighbour_peers_detach,
+#ifdef FEATURE_NAC_RSSI
+	.mon_filter_neighbour_peer = dp_filter_neighbour_peer,
+#endif
+	.mon_vdev_timer_init = dp_mon_vdev_timer_init,
+	.mon_vdev_timer_start = dp_mon_vdev_timer_start,
+	.mon_vdev_timer_stop = dp_mon_vdev_timer_stop,
+	.mon_vdev_timer_deinit = dp_mon_vdev_timer_deinit,
+	.mon_reap_timer_init = dp_mon_reap_timer_init,
+	.mon_reap_timer_start = dp_mon_reap_timer_start,
+	.mon_reap_timer_stop = dp_mon_reap_timer_stop,
+	.mon_reap_timer_deinit = dp_mon_reap_timer_deinit,
+#ifdef QCA_MCOPY_SUPPORT
+	.mon_mcopy_check_deliver = dp_mcopy_check_deliver,
+#endif
+	.mon_neighbour_peer_add_ast = dp_mon_neighbour_peer_add_ast,
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+	.mon_filter_setup_enhanced_stats =
+		dp_mon_filter_setup_enhanced_stats_1_0,
+	.mon_filter_reset_enhanced_stats =
+		dp_mon_filter_reset_enhanced_stats_1_0,
+#endif
+#ifdef QCA_MCOPY_SUPPORT
+	.mon_filter_setup_mcopy_mode = dp_mon_filter_setup_mcopy_mode_1_0,
+	.mon_filter_reset_mcopy_mode = dp_mon_filter_reset_mcopy_mode_1_0,
+#endif
+#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
+	.mon_filter_setup_smart_monitor = dp_mon_filter_setup_smart_monitor_1_0,
+#endif
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+	.mon_filter_setup_rx_enh_capture =
+		dp_mon_filter_setup_rx_enh_capture_1_0,
+#endif
+	.mon_filter_setup_mon_mode = dp_mon_filter_setup_mon_mode_1_0,
+	.mon_filter_reset_mon_mode = dp_mon_filter_reset_mon_mode_1_0,
+#ifdef WDI_EVENT_ENABLE
+	.mon_filter_setup_rx_pkt_log_full =
+		dp_mon_filter_setup_rx_pkt_log_full_1_0,
+	.mon_filter_reset_rx_pkt_log_full =
+		dp_mon_filter_reset_rx_pkt_log_full_1_0,
+	.mon_filter_setup_rx_pkt_log_lite =
+		dp_mon_filter_setup_rx_pkt_log_lite_1_0,
+	.mon_filter_reset_rx_pkt_log_lite =
+		dp_mon_filter_reset_rx_pkt_log_lite_1_0,
+	.mon_filter_setup_rx_pkt_log_cbf =
+		dp_mon_filter_setup_rx_pkt_log_cbf_1_0,
+	.mon_filter_reset_rx_pkt_log_cbf =
+		dp_mon_filter_reset_rx_pktlog_cbf_1_0,
+#endif
+	.mon_filter_update = dp_mon_filter_update_1_0,
+	.rx_pdev_mon_desc_pool_init = dp_rx_pdev_mon_desc_pool_init,
+	.rx_pdev_mon_desc_pool_deinit = dp_rx_pdev_mon_desc_pool_deinit,
+	.rx_pdev_mon_desc_pool_alloc = dp_rx_pdev_mon_desc_pool_alloc,
+	.rx_pdev_mon_desc_pool_free = dp_rx_pdev_mon_desc_pool_free,
+	.rx_pdev_mon_buffers_alloc = dp_rx_pdev_mon_buffers_alloc,
+	.rx_pdev_mon_buffers_free = dp_rx_pdev_mon_buffers_free,
+	.mon_buffers_alloc = NULL,
+	.mon_buffers_free = NULL,
+	.mon_rings_alloc = dp_mon_rings_alloc_1_0,
+	.mon_rings_free = dp_mon_rings_free_1_0,
+	.mon_rings_init = dp_mon_rings_init_1_0,
+	.mon_rings_deinit = dp_mon_rings_deinit_1_0,
+};
+
+struct cdp_mon_ops dp_ops_mon_1_0 = {
+	.txrx_reset_monitor_mode = dp_reset_monitor_mode,
+	/* Added support for HK advance filter */
+	.txrx_set_advance_monitor_filter = dp_pdev_set_advance_monitor_filter,
+	.txrx_deliver_tx_mgmt = dp_deliver_tx_mgmt,
+	.config_full_mon_mode = dp_config_full_mon_mode,
+	.soc_config_full_mon_mode = dp_soc_config_full_mon_mode,
+};
+
+struct dp_mon_ops *dp_mon_ops_get_1_0(void)
+{
+	return &monitor_ops_1_0;
+}
+
+struct cdp_mon_ops *dp_mon_cdp_ops_get_1_0(void)
+{
+	return &dp_ops_mon_1_0;
+}

dp/wifi3.0/monitor/1.0/dp_mon_1.0.h

@@ -17,4 +17,39 @@
 #ifndef _DP_MON_1_0_H_
 #define _DP_MON_1_0_H_
 
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+#include <dp_rx_mon_feature.h>
+#endif
+
+#include <dp_rx_mon.h>
+
+void dp_flush_monitor_rings(struct dp_soc *soc);
+
+/* MCL specific functions */
+#if defined(DP_CON_MON)
+
+/*
+ * dp_service_mon_rings()- service monitor rings
+ * @soc: soc dp handle
+ * @quota: number of ring entry that can be serviced
+ *
+ * Return: None
+ *
+ */
+void dp_service_mon_rings(struct  dp_soc *soc, uint32_t quota);
+#endif
+
+/**
+ * dp_mon_drop_packets_for_mac() - Drop the mon status ring and
+ *  dest ring packets for a given mac. Packets in status ring and
+ *  dest ring are dropped independently.
+ * @pdev: DP pdev
+ * @mac_id: mac id
+ * @quota: max number of status ring entries that can be processed
+ *
+ * Return: work done
+ */
+uint32_t dp_mon_drop_packets_for_mac(struct dp_pdev *pdev, uint32_t mac_id,
+				     uint32_t quota);
+
 #endif /* _DP_MON_1_0_H_ */

dp/wifi3.0/monitor/1.0/dp_mon_filter_1.0.c

@@ -13,3 +13,1085 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
+
+#include <hal_api.h>
+#include <wlan_cfg.h>
+#include "dp_types.h"
+#include "dp_internal.h"
+#include "dp_htt.h"
+#include "dp_mon.h"
+#include "dp_mon_filter.h"
+
+#include <dp_mon_1.0.h>
+#include <dp_rx_mon_1.0.h>
+#include <dp_mon_filter_1.0.h>
+
+/**
+ * dp_mon_filter_mode_type_to_str
+ *	Monitor Filter mode to string
+ */
+int8_t *dp_mon_filter_mode_type_to_str[DP_MON_FILTER_MAX_MODE] = {
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+	"DP MON FILTER ENHACHED STATS MODE",
+#endif /* QCA_ENHANCED_STATS_SUPPORT */
+#ifdef QCA_MCOPY_SUPPORT
+	"DP MON FILTER MCOPY MODE",
+#endif /* QCA_MCOPY_SUPPORT */
+#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
+	"DP MON FILTER SMART MONITOR MODE",
+#endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
+	"DP_MON FILTER MONITOR MODE",
+#ifdef	WLAN_RX_PKT_CAPTURE_ENH
+	"DP MON FILTER RX CAPTURE MODE",
+#endif /* WLAN_RX_PKT_CAPTURE_ENH */
+#ifdef WDI_EVENT_ENABLE
+	"DP MON FILTER PKT LOG FULL MODE",
+	"DP MON FILTER PKT LOG LITE_MODE",
+#endif /* WDI_EVENT_ENABLE */
+};
+
+void dp_mon_filter_show_filter(struct dp_mon_pdev *mon_pdev,
+			       enum dp_mon_filter_mode mode,
+			       struct dp_mon_filter *filter)
+{
+	struct htt_rx_ring_tlv_filter *tlv_filter = &filter->tlv_filter;
+
+	DP_MON_FILTER_PRINT("[%s]: Valid: %d",
+			    dp_mon_filter_mode_type_to_str[mode],
+			    filter->valid);
+	DP_MON_FILTER_PRINT("mpdu_start: %d", tlv_filter->mpdu_start);
+	DP_MON_FILTER_PRINT("msdu_start: %d", tlv_filter->msdu_start);
+	DP_MON_FILTER_PRINT("packet: %d", tlv_filter->packet);
+	DP_MON_FILTER_PRINT("msdu_end: %d", tlv_filter->msdu_end);
+	DP_MON_FILTER_PRINT("mpdu_end: %d", tlv_filter->mpdu_end);
+	DP_MON_FILTER_PRINT("packet_header: %d",
+			    tlv_filter->packet_header);
+	DP_MON_FILTER_PRINT("attention: %d", tlv_filter->attention);
+	DP_MON_FILTER_PRINT("ppdu_start: %d", tlv_filter->ppdu_start);
+	DP_MON_FILTER_PRINT("ppdu_end: %d", tlv_filter->ppdu_end);
+	DP_MON_FILTER_PRINT("ppdu_end_user_stats: %d",
+			    tlv_filter->ppdu_end_user_stats);
+	DP_MON_FILTER_PRINT("ppdu_end_user_stats_ext: %d",
+			    tlv_filter->ppdu_end_user_stats_ext);
+	DP_MON_FILTER_PRINT("ppdu_end_status_done: %d",
+			    tlv_filter->ppdu_end_status_done);
+	DP_MON_FILTER_PRINT("header_per_msdu: %d", tlv_filter->header_per_msdu);
+	DP_MON_FILTER_PRINT("enable_fp: %d", tlv_filter->enable_fp);
+	DP_MON_FILTER_PRINT("enable_md: %d", tlv_filter->enable_md);
+	DP_MON_FILTER_PRINT("enable_mo: %d", tlv_filter->enable_mo);
+	DP_MON_FILTER_PRINT("fp_mgmt_filter: 0x%x", tlv_filter->fp_mgmt_filter);
+	DP_MON_FILTER_PRINT("mo_mgmt_filter: 0x%x", tlv_filter->mo_mgmt_filter);
+	DP_MON_FILTER_PRINT("fp_ctrl_filter: 0x%x", tlv_filter->fp_ctrl_filter);
+	DP_MON_FILTER_PRINT("mo_ctrl_filter: 0x%x", tlv_filter->mo_ctrl_filter);
+	DP_MON_FILTER_PRINT("fp_data_filter: 0x%x", tlv_filter->fp_data_filter);
+	DP_MON_FILTER_PRINT("mo_data_filter: 0x%x", tlv_filter->mo_data_filter);
+	DP_MON_FILTER_PRINT("md_data_filter: 0x%x", tlv_filter->md_data_filter);
+	DP_MON_FILTER_PRINT("md_mgmt_filter: 0x%x", tlv_filter->md_mgmt_filter);
+	DP_MON_FILTER_PRINT("md_ctrl_filter: 0x%x", tlv_filter->md_ctrl_filter);
+}
+
+/**
+ * dp_mon_filter_h2t_setup() - Setup the filter for the Target setup
+ * @soc: DP soc handle
+ * @pdev: DP pdev handle
+ * @srng_type: The srng type for which filter wll be set
+ * @tlv_filter: tlv filter
+ */
+static void dp_mon_filter_h2t_setup(struct dp_soc *soc, struct dp_pdev *pdev,
+				    enum dp_mon_filter_srng_type srng_type,
+				    struct dp_mon_filter *filter)
+{
+	int32_t current_mode = 0;
+	struct htt_rx_ring_tlv_filter *tlv_filter = &filter->tlv_filter;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	/*
+	 * Loop through all the modes.
+	 */
+	for (current_mode = 0; current_mode < DP_MON_FILTER_MAX_MODE;
+						current_mode++) {
+		struct dp_mon_filter *mon_filter =
+			&mon_pdev->filter[current_mode][srng_type];
+		uint32_t src_filter = 0, dst_filter = 0;
+
+		/*
+		 * Check if the correct mode is enabled or not.
+		 */
+		if (!mon_filter->valid)
+			continue;
+
+		filter->valid = true;
+
+		/*
+		 * Set the super bit fields
+		 */
+		src_filter =
+			DP_MON_FILTER_GET(&mon_filter->tlv_filter, FILTER_TLV);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_TLV);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_TLV, dst_filter);
+
+		/*
+		 * Set the filter management filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_FP_MGMT);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_FP_MGMT);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_FP_MGMT, dst_filter);
+
+		/*
+		 * Set the monitor other management filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_MO_MGMT);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_MGMT);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_MO_MGMT, dst_filter);
+
+		/*
+		 * Set the filter pass control filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_FP_CTRL);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_FP_CTRL);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_FP_CTRL, dst_filter);
+
+		/*
+		 * Set the monitor other control filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_MO_CTRL);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_CTRL);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_MO_CTRL, dst_filter);
+
+		/*
+		 * Set the filter pass data filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_FP_DATA);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter,
+					       FILTER_FP_DATA);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter,
+				  FILTER_FP_DATA, dst_filter);
+
+		/*
+		 * Set the monitor other data filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_MO_DATA);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_DATA);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_MO_DATA, dst_filter);
+
+		/*
+		 * Set the monitor direct data filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_MD_DATA);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter,
+					       FILTER_MD_DATA);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter,
+				  FILTER_MD_DATA, dst_filter);
+
+		/*
+		 * Set the monitor direct management filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_MD_MGMT);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MD_MGMT);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_MD_MGMT, dst_filter);
+
+		/*
+		 * Set the monitor direct management filter.
+		 */
+		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
+					       FILTER_MD_CTRL);
+		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MD_CTRL);
+		dst_filter |= src_filter;
+		DP_MON_FILTER_SET(tlv_filter, FILTER_MD_CTRL, dst_filter);
+	}
+
+	dp_mon_filter_show_filter(mon_pdev, 0, filter);
+}
+
+#if defined(QCA_MCOPY_SUPPORT) || defined(ATH_SUPPORT_NAC_RSSI) \
+	|| defined(ATH_SUPPORT_NAC) || defined(WLAN_RX_PKT_CAPTURE_ENH)
+/**
+ * dp_mon_filter_check_co_exist() - Check the co-existing of the
+ * enabled modes.
+ * @pdev: DP pdev handle
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev)
+{
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	/*
+	 * Check if the Rx Enhanced capture mode, monitor mode,
+	 * smart_monitor_mode and mcopy mode can co-exist together.
+	 */
+	if ((mon_pdev->rx_enh_capture_mode != CDP_RX_ENH_CAPTURE_DISABLED) &&
+	    ((mon_pdev->neighbour_peers_added && mon_pdev->mvdev) ||
+		 mon_pdev->mcopy_mode)) {
+		dp_mon_filter_err("%pK:Rx Capture mode can't exist with modes:\n"
+				  "Smart Monitor Mode:%d\n"
+				  "M_Copy Mode:%d", pdev->soc,
+				  mon_pdev->neighbour_peers_added,
+				  mon_pdev->mcopy_mode);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/*
+	 * Check if the monitor mode cannot co-exist with any other mode.
+	 */
+	if ((mon_pdev->mvdev && mon_pdev->monitor_configured) &&
+	    (mon_pdev->mcopy_mode || mon_pdev->neighbour_peers_added)) {
+		dp_mon_filter_err("%pK: Monitor mode can't exist with modes\n"
+				  "M_Copy Mode:%d\n"
+				  "Smart Monitor Mode:%d",
+				  pdev->soc, mon_pdev->mcopy_mode,
+				  mon_pdev->neighbour_peers_added);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/*
+	 * Check if the smart monitor mode can co-exist with any other mode
+	 */
+	if (mon_pdev->neighbour_peers_added &&
+	    ((mon_pdev->mcopy_mode) || mon_pdev->monitor_configured)) {
+		dp_mon_filter_err("%pk: Smart Monitor mode can't exist with modes\n"
+				  "M_Copy Mode:%d\n"
+				  "Monitor Mode:%d",
+				  pdev->soc, mon_pdev->mcopy_mode,
+			      mon_pdev->monitor_configured);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/*
+	 * Check if the m_copy, monitor mode and the smart_monitor_mode
+	 * can co-exist togther.
+	 */
+	if (mon_pdev->mcopy_mode &&
+	    (mon_pdev->mvdev || mon_pdev->neighbour_peers_added)) {
+		dp_mon_filter_err("%pK: mcopy mode can't exist with modes\n"
+				  "Monitor Mode:%pK\n"
+				  "Smart Monitor Mode:%d",
+				  pdev->soc, mon_pdev->mvdev,
+				  mon_pdev->neighbour_peers_added);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/*
+	 * Check if the Rx packet log lite or full can co-exist with
+	 * the enable modes.
+	 */
+	if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) &&
+	    !mon_pdev->rx_pktlog_cbf &&
+	    (mon_pdev->mvdev || mon_pdev->monitor_configured)) {
+		dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n"
+				  "Monitor Mode:%d", pdev->soc,
+				  mon_pdev->monitor_configured);
+		return QDF_STATUS_E_FAILURE;
+	}
+	return QDF_STATUS_SUCCESS;
+}
+#else
+static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev)
+{
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	/*
+	 * Check if the Rx packet log lite or full can co-exist with
+	 * the enable modes.
+	 */
+	if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) &&
+	    (mon_pdev->mvdev || mon_pdev->monitor_configured)) {
+		 dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n"
+				   "Monitor Mode:%d", pdev->soc,
+				   mon_pdev->monitor_configured);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+void dp_mon_filter_setup_enhanced_stats_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	/* Enabled the filter */
+	filter.valid = true;
+
+	mon_pdev = pdev->monitor_pdev;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+/**
+ * dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_enhanced_stats_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+#endif /* QCA_ENHANCED_STATS_SUPPORT */
+
+#ifdef QCA_MCOPY_SUPPORT
+#ifdef QCA_MONITOR_PKT_SUPPORT
+static void dp_mon_filter_set_reset_mcopy_dest(struct dp_pdev *pdev,
+					       struct dp_mon_filter *pfilter)
+{
+	struct dp_soc *soc = pdev->soc;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE;
+	enum dp_mon_filter_srng_type srng_type;
+
+	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
+
+	/* Set the filter */
+	if (pfilter->valid) {
+		dp_mon_filter_set_mon_cmn(mon_pdev, pfilter);
+
+		pfilter->tlv_filter.fp_data_filter = 0;
+		pfilter->tlv_filter.mo_data_filter = 0;
+
+		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
+		mon_pdev->filter[mode][srng_type] = *pfilter;
+	} else /* Reset the filter */
+		mon_pdev->filter[mode][srng_type] = *pfilter;
+}
+#else
+static void dp_mon_filter_set_reset_mcopy_dest(struct dp_pdev *pdev,
+					       struct dp_mon_filter *pfilter)
+{
+}
+#endif
+
+void dp_mon_filter_setup_mcopy_mode_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	if (!mon_pdev) {
+		dp_mon_filter_err("monitor pdev Context is null");
+		return;
+	}
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_reset_mcopy_dest(pdev, &filter);
+
+	/* Clear the filter as the same filter will be used to set the
+	 * monitor status ring
+	 */
+	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
+
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+
+	/* Setup the filter */
+	filter.tlv_filter.enable_mo = 1;
+	filter.tlv_filter.packet_header = 1;
+	filter.tlv_filter.mpdu_end = 1;
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_reset_mcopy_mode_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	dp_mon_filter_set_reset_mcopy_dest(pdev, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+#endif
+
+#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
+/**
+ * dp_mon_filter_setup_smart_monitor() - Setup the smart monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_smart_monitor_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	struct dp_mon_soc *mon_soc;
+
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_soc = soc->monitor_soc;
+	mon_pdev = pdev->monitor_pdev;
+
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+
+	if (mon_soc->hw_nac_monitor_support) {
+		filter.tlv_filter.enable_md = 1;
+		filter.tlv_filter.packet_header = 1;
+		filter.tlv_filter.md_data_filter = FILTER_DATA_ALL;
+	}
+
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_reset_smart_monitor_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+#endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
+
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+#ifdef QCA_MONITOR_PKT_SUPPORT
+static
+void dp_mon_filter_set_reset_rx_enh_capture_dest(struct dp_pdev *pdev,
+						 struct dp_mon_filter *pfilter)
+{
+	struct dp_soc *soc = pdev->soc;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE;
+	enum dp_mon_filter_srng_type srng_type;
+
+	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
+
+	/* Set the filter */
+	if (pfilter->valid) {
+		dp_mon_filter_set_mon_cmn(mon_pdev, pfilter);
+
+		pfilter->tlv_filter.fp_mgmt_filter = 0;
+		pfilter->tlv_filter.fp_ctrl_filter = 0;
+		pfilter->tlv_filter.fp_data_filter = 0;
+		pfilter->tlv_filter.mo_mgmt_filter = 0;
+		pfilter->tlv_filter.mo_ctrl_filter = 0;
+		pfilter->tlv_filter.mo_data_filter = 0;
+
+		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
+		pdev->monitor_pdev->filter[mode][srng_type] = *pfilter;
+	} else /* Reset the filter */
+		pdev->monitor_pdev->filter[mode][srng_type] = *pfilter;
+}
+#else
+static
+void dp_mon_filter_set_reset_rx_enh_capture_dest(struct dp_pdev *pdev,
+						 struct dp_mon_filter *pfilter)
+{
+}
+#endif
+
+void dp_mon_filter_setup_rx_enh_capture_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_reset_rx_enh_capture_dest(pdev, &filter);
+
+	/* Clear the filter as the same filter will be used to set the
+	 * monitor status ring
+	 */
+	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
+
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+
+	/* Setup the filter */
+	filter.tlv_filter.mpdu_end = 1;
+	filter.tlv_filter.enable_mo = 1;
+	filter.tlv_filter.packet_header = 1;
+
+	if (mon_pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU) {
+		filter.tlv_filter.header_per_msdu = 0;
+		filter.tlv_filter.enable_mo = 0;
+	} else if (mon_pdev->rx_enh_capture_mode ==
+			CDP_RX_ENH_CAPTURE_MPDU_MSDU) {
+		bool is_rx_mon_proto_flow_tag_enabled =
+		wlan_cfg_is_rx_mon_protocol_flow_tag_enabled(soc->wlan_cfg_ctx);
+		filter.tlv_filter.header_per_msdu = 1;
+		filter.tlv_filter.enable_mo = 0;
+		if (mon_pdev->is_rx_enh_capture_trailer_enabled ||
+		    is_rx_mon_proto_flow_tag_enabled)
+			filter.tlv_filter.msdu_end = 1;
+	}
+
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_reset_rx_enh_capture_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	dp_mon_filter_set_reset_rx_enh_capture_dest(pdev, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+#endif /* WLAN_RX_PKT_CAPTURE_ENH */
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+static void dp_mon_filter_set_reset_mon_dest(struct dp_pdev *pdev,
+					     struct dp_mon_filter *pfilter)
+{
+	struct dp_soc *soc = pdev->soc;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE;
+	enum dp_mon_filter_srng_type srng_type;
+
+	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
+
+	/* set the filter */
+	if (pfilter->valid) {
+		dp_mon_filter_set_mon_cmn(mon_pdev, pfilter);
+
+		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
+		mon_pdev->filter[mode][srng_type] = *pfilter;
+	} else /* reset the filter */
+		mon_pdev->filter[mode][srng_type] = *pfilter;
+}
+#else
+static void dp_mon_filter_set_reset_mon_dest(struct dp_pdev *pdev,
+					     struct dp_mon_filter *pfilter)
+{
+}
+#endif
+
+void dp_mon_filter_setup_mon_mode_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	filter.valid = true;
+	dp_mon_filter_set_reset_mon_dest(pdev, &filter);
+
+	/* Clear the filter as the same filter will be used to set the
+	 * monitor status ring
+	 */
+	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
+
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+
+	/* Store the above filter */
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_reset_mon_mode_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	dp_mon_filter_set_reset_mon_dest(pdev, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+#ifdef WDI_EVENT_ENABLE
+void dp_mon_filter_setup_rx_pkt_log_full_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+
+	/* Setup the filter */
+	filter.tlv_filter.packet_header = 1;
+	filter.tlv_filter.msdu_start = 1;
+	filter.tlv_filter.msdu_end = 1;
+	filter.tlv_filter.mpdu_end = 1;
+	filter.tlv_filter.attention = 1;
+
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_reset_rx_pkt_log_full_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_setup_rx_pkt_log_lite_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
+
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+void dp_mon_filter_reset_rx_pkt_log_lite_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+static
+void dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(struct dp_pdev *pdev,
+						 struct dp_mon_filter *pfilter)
+{
+	struct dp_soc *soc = pdev->soc;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
+	enum dp_mon_filter_srng_type srng_type;
+
+	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
+
+	/*set the filter */
+	if (pfilter->valid) {
+		dp_mon_filter_set_cbf_cmn(pdev, pfilter);
+
+		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
+		mon_pdev->filter[mode][srng_type] = *pfilter;
+	} else /* reset the filter */
+		mon_pdev->filter[mode][srng_type] = *pfilter;
+}
+#else
+static
+void dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(struct dp_pdev *pdev,
+						 struct dp_mon_filter *pfilter)
+{
+}
+#endif
+
+void dp_mon_filter_setup_rx_pkt_log_cbf_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	struct dp_mon_pdev *mon_pdev = NULL;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	/* Enabled the filter */
+	filter.valid = true;
+	dp_mon_filter_set_status_cbf(pdev, &filter);
+	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
+	mon_pdev->filter[mode][srng_type] = filter;
+
+	/* Clear the filter as the same filter will be used to set the
+	 * monitor status ring
+	 */
+	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
+
+	filter.valid = true;
+	dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(pdev, &filter);
+}
+
+void dp_mon_filter_reset_rx_pktlog_cbf_1_0(struct dp_pdev *pdev)
+{
+	struct dp_mon_filter filter = {0};
+	struct dp_soc *soc = NULL;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF;
+	struct dp_mon_pdev *mon_pdev = NULL;
+
+	if (!pdev) {
+		QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR,
+			  FL("pdev Context is null"));
+		return;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	soc = pdev->soc;
+	if (!soc) {
+		QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR,
+			  FL("Soc Context is null"));
+		return;
+	}
+
+	dp_mon_filter_set_reset_rx_pkt_log_cbf_dest(pdev, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev->filter[mode][srng_type] = filter;
+}
+#endif /* WDI_EVENT_ENABLE */
+
+#ifdef WLAN_DP_RESET_MON_BUF_RING_FILTER
+/**
+ * dp_mon_should_reset_buf_ring_filter() - Reset the monitor buf ring filter
+ * @pdev: DP PDEV handle
+ *
+ * WIN has targets which does not support monitor mode, but still do the
+ * monitor mode init/deinit, only the rxdma1_enable flag will be set to 0.
+ * MCL need to do the monitor buffer ring filter reset always, but this is
+ * not needed for WIN targets where rxdma1 is not enabled (the indicator
+ * that monitor mode is not enabled.
+ * This function is used as WAR till WIN cleans up the monitor mode
+ * function for targets where monitor mode is not enabled.
+ *
+ * Returns: true
+ */
+static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev)
+{
+	return (pdev->monitor_pdev->mvdev) ? true : false;
+}
+#else
+static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev)
+{
+	return false;
+}
+#endif
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+static QDF_STATUS dp_mon_filter_dest_update(struct dp_pdev *pdev,
+					    struct dp_mon_filter *pfilter,
+					    bool *pmon_mode_set)
+{
+	struct dp_soc *soc = pdev->soc;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	enum dp_mon_filter_srng_type srng_type;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
+
+	dp_mon_filter_h2t_setup(soc, pdev, srng_type, pfilter);
+
+	*pmon_mode_set = pfilter->valid;
+	if (dp_mon_should_reset_buf_ring_filter(pdev) || *pmon_mode_set) {
+		status = dp_mon_ht2_rx_ring_cfg(soc, pdev,
+						srng_type,
+						&pfilter->tlv_filter);
+	} else {
+		/*
+		 * For WIN case the monitor buffer ring is used and it does need
+		 * reset when monitor mode gets enabled/disabled.
+		 */
+		if (soc->wlan_cfg_ctx->rxdma1_enable) {
+			if (mon_pdev->monitor_configured || *pmon_mode_set) {
+				status = dp_mon_ht2_rx_ring_cfg(soc, pdev,
+								srng_type,
+								&pfilter->tlv_filter);
+			}
+		}
+	}
+
+	return status;
+}
+
+static void dp_mon_filter_dest_reset(struct dp_pdev *pdev)
+{
+	struct dp_soc *soc = pdev->soc;
+	enum dp_mon_filter_srng_type srng_type;
+
+	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
+			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
+
+	dp_mon_filter_reset_mon_srng(soc, pdev, srng_type);
+}
+#else
+static QDF_STATUS dp_mon_filter_dest_update(struct dp_pdev *pdev,
+					    struct dp_mon_filter *pfilter,
+					    bool *pmon_mode_set)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static void dp_mon_filter_dest_reset(struct dp_pdev *pdev)
+{
+}
+#endif
+
+QDF_STATUS dp_mon_filter_update_1_0(struct dp_pdev *pdev)
+{
+	struct dp_soc *soc;
+	bool mon_mode_set = false;
+	struct dp_mon_filter filter = {0};
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	mon_pdev = pdev->monitor_pdev;
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	status = dp_mon_filter_check_co_exist(pdev);
+	if (status != QDF_STATUS_SUCCESS)
+		return status;
+
+	/*
+	 * Setup the filters for the monitor destination ring.
+	 */
+	status = dp_mon_filter_dest_update(pdev, &filter,
+					   &mon_mode_set);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		dp_mon_filter_err("%pK: Monitor destination ring filter setting failed",
+				  soc);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/*
+	 * Setup the filters for the status ring.
+	 */
+	qdf_mem_zero(&(filter), sizeof(filter));
+	dp_mon_filter_h2t_setup(soc, pdev,
+				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS,
+				&filter);
+
+	/*
+	 * Reset the monitor filters if the all the modes for the status rings
+	 * are disabled. This is done to prevent the HW backpressure from the
+	 * monitor destination ring in case the status ring filters
+	 * are not enabled.
+	 */
+	if (!filter.valid && mon_mode_set)
+		dp_mon_filter_dest_reset(pdev);
+
+	if (dp_mon_ht2_rx_ring_cfg(soc, pdev,
+				   DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS,
+				   &filter.tlv_filter) != QDF_STATUS_SUCCESS) {
+		dp_mon_filter_err("%pK: Monitor status ring filter setting failed",
+				  soc);
+		dp_mon_filter_dest_reset(pdev);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return status;
+}

dp/wifi3.0/monitor/1.0/dp_mon_filter_1.0.h

@@ -16,4 +16,214 @@
 #ifndef _DP_MON_FILTER_1_0_H_
 #define _DP_MON_FILTER_1_0_H_
 
+/**
+ * Accessor Macros to access the software
+ * defined HTT filter htt_rx_ring_tlv_filter.
+ */
+#define DP_MON_FILTER_TLV_OFFSET                      0x00000000
+#define DP_MON_FILTER_TLV_MASK                        0xffffffff
+#define DP_MON_FILTER_TLV_LSB                         0
+
+#define DP_MON_FILTER_FP_MGMT_OFFSET                  0x00000004
+#define DP_MON_FILTER_FP_MGMT_MASK                    0x0000ffff
+#define DP_MON_FILTER_FP_MGMT_LSB                     0
+
+#define DP_MON_FILTER_MO_MGMT_OFFSET                  0x00000004
+#define DP_MON_FILTER_MO_MGMT_MASK                    0xffff0000
+#define DP_MON_FILTER_MO_MGMT_LSB                     16
+
+#define DP_MON_FILTER_FP_CTRL_OFFSET                  0x00000008
+#define DP_MON_FILTER_FP_CTRL_MASK                    0x0000ffff
+#define DP_MON_FILTER_FP_CTRL_LSB                     0
+
+#define DP_MON_FILTER_MO_CTRL_OFFSET                  0x00000008
+#define DP_MON_FILTER_MO_CTRL_MASK                    0xffff0000
+#define DP_MON_FILTER_MO_CTRL_LSB                     16
+
+#define DP_MON_FILTER_FP_DATA_OFFSET                  0x0000000c
+#define DP_MON_FILTER_FP_DATA_MASK                    0x0000ffff
+#define DP_MON_FILTER_FP_DATA_LSB                     0
+
+#define DP_MON_FILTER_MO_DATA_OFFSET                  0x0000000c
+#define DP_MON_FILTER_MO_DATA_MASK                    0xffff0000
+#define DP_MON_FILTER_MO_DATA_LSB                     16
+
+#define DP_MON_FILTER_MD_DATA_OFFSET                  0x00000010
+#define DP_MON_FILTER_MD_DATA_MASK                    0x0000ffff
+#define DP_MON_FILTER_MD_DATA_LSB                     0
+
+#define DP_MON_FILTER_MD_MGMT_OFFSET                  0x00000010
+#define DP_MON_FILTER_MD_MGMT_MASK                    0xffff0000
+#define DP_MON_FILTER_MD_MGMT_LSB                     16
+
+#define DP_MON_FILTER_MD_CTRL_OFFSET                  0x00000014
+#define DP_MON_FILTER_MD_CTRL_MASK                    0x0000ffff
+#define DP_MON_FILTER_MD_CTRL_LSB                     0
+
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+/**
+ * dp_mon_filter_setup_enhanced_stats() - Setup the enhanced stats filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_enhanced_stats_1_0(struct dp_pdev *pdev);
+
+/***
+ * dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_enhanced_stats_1_0(struct dp_pdev *pdev);
+#else
+static inline void dp_mon_filter_setup_enhanced_stats_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_enhanced_stats_1_0(struct dp_pdev *pdev)
+{
+}
+#endif
+
+#ifdef QCA_MCOPY_SUPPORT
+/**
+ * dp_mon_filter_setup_mcopy_mode() - Setup the m_copy mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_mcopy_mode_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_mcopy_mode() - Reset the m_copy mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_mcopy_mode_1_0(struct dp_pdev *pdev);
+#else
+static inline void dp_mon_filter_setup_mcopy_mode_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_mcopy_mode_1_0(struct dp_pdev *pdev)
+{
+}
+#endif
+
+#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
+/**
+ * dp_mon_filter_setup_smart_monitor() - Setup the smart monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_smart_monitor_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_smart_monitor() - Reset the smart monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_smart_monitor_1_0(struct dp_pdev *pdev);
+#else
+static inline void dp_mon_filter_setup_smart_monitor_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_smart_monitor_1_0(struct dp_pdev *pdev)
+{
+}
+#endif
+
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+/**
+ * dp_mon_filter_setup_rx_enh_capture() - Setup the Rx capture mode filters
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_rx_enh_capture_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_rx_enh_capture() - Reset the Rx capture mode filters
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_rx_enh_capture_1_0(struct dp_pdev *pdev);
+#else
+static inline void dp_mon_filter_setup_rx_enh_capture_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_rx_enh_capture_1_0(struct dp_pdev *pdev)
+{
+}
+#endif
+
+/**
+ * dp_mon_filter_setup_mon_mode() - Setup the Rx monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_mon_mode_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_mon_mode() - Reset the Rx monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_mon_mode_1_0(struct dp_pdev *pdev);
+
+#ifdef WDI_EVENT_ENABLE
+/**
+ * dp_mon_filter_setup_rx_pkt_log_full() - Setup the Rx pktlog full mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_rx_pkt_log_full_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_rx_pkt_log_full_1_0() - Reset the Rx pktlog full mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_rx_pkt_log_full_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_setup_rx_pkt_log_lite() - Setup the Rx pktlog lite mode filter
+ * in the radio object.
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_rx_pkt_log_lite_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_rx_pkt_log_lite() - Reset the Rx pktlog lite mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_rx_pkt_log_lite_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_setup_rx_pkt_log_cbf() - Setup the Rx pktlog cbf mode filter
+ * in the radio object.
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_rx_pkt_log_cbf_1_0(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_rx_pktlog_cbf() - Reset the Rx pktlog cbf mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_rx_pktlog_cbf_1_0(struct dp_pdev *pdev);
+#else
+static inline void dp_mon_filter_setup_rx_pkt_log_full_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_rx_pkt_log_full_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_setup_rx_pkt_log_lite_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_rx_pkt_log_lite_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_setup_rx_pkt_log_cbf_1_0(struct dp_pdev *pdev)
+{
+}
+
+static inline void dp_mon_filter_reset_rx_pktlog_cbf_1_0(struct dp_pdev *pdev)
+{
+}
+#endif
+
+QDF_STATUS dp_mon_filter_update_1_0(struct dp_pdev *pdev);
+
 #endif /* _DP_MON_FILTER_1_0_H_ */

dp/wifi3.0/monitor/1.0/dp_rx_mon_1.0.h

@@ -16,4 +16,973 @@
 #ifndef _DP_RX_MON_1_0_H_
 #define _DP_RX_MON_1_0_H_
 
+#include <dp_rx.h>
+/*
+ * MON_BUF_MIN_ENTRIES macro defines minimum number of network buffers
+ * to be refilled in the RXDMA monitor buffer ring at init, remaining
+ * buffers are replenished at the time of monitor vap creation
+ */
+#define MON_BUF_MIN_ENTRIES 64
+
+/*
+ * The below macro defines the maximum number of ring entries that would
+ * be processed in a single instance when processing each of the non-monitoring
+ * RXDMA2SW ring.
+ */
+#define MON_DROP_REAP_LIMIT 64
+
+/*
+ * The maximum headroom reserved for monitor destination buffer to
+ * accomodate radiotap header and protocol flow tag
+ */
+#ifdef DP_RX_MON_MEM_FRAG
+/*
+ *  -------------------------------------------------
+ * |       Protocol & Flow TAG      | Radiotap header|
+ * |                                |  Length(128 B) |
+ * |  ((4* QDF_NBUF_MAX_FRAGS) * 2) |                |
+ *  -------------------------------------------------
+ */
+#define DP_RX_MON_MAX_RADIO_TAP_HDR (128)
+#define DP_RX_MON_PF_TAG_LEN_PER_FRAG (4)
+#define DP_RX_MON_TOT_PF_TAG_LEN \
+	((DP_RX_MON_PF_TAG_LEN_PER_FRAG) * (QDF_NBUF_MAX_FRAGS))
+#define DP_RX_MON_MAX_MONITOR_HEADER \
+	((DP_RX_MON_TOT_PF_TAG_LEN * 2) + (DP_RX_MON_MAX_RADIO_TAP_HDR))
+#endif
+
+/* l2 header pad byte in case of Raw frame is Zero and 2 in non raw */
+#define DP_RX_MON_RAW_L2_HDR_PAD_BYTE (0)
+#define DP_RX_MON_NONRAW_L2_HDR_PAD_BYTE (2)
+
+QDF_STATUS dp_rx_pdev_mon_status_buffers_alloc(struct dp_pdev *pdev,
+					       uint32_t mac_id);
+QDF_STATUS dp_rx_pdev_mon_status_desc_pool_alloc(struct dp_pdev *pdev,
+						 uint32_t mac_id);
+void dp_rx_pdev_mon_status_desc_pool_init(struct dp_pdev *pdev,
+					  uint32_t mac_id);
+void dp_rx_pdev_mon_status_desc_pool_deinit(struct dp_pdev *pdev,
+					    uint32_t mac_id);
+void dp_rx_pdev_mon_status_desc_pool_free(struct dp_pdev *pdev,
+					  uint32_t mac_id);
+void dp_rx_pdev_mon_status_buffers_free(struct dp_pdev *pdev, uint32_t mac_id);
+
+QDF_STATUS dp_rx_pdev_mon_desc_pool_alloc(struct dp_pdev *pdev);
+QDF_STATUS dp_rx_pdev_mon_buffers_alloc(struct dp_pdev *pdev);
+void dp_rx_pdev_mon_buffers_free(struct dp_pdev *pdev);
+void dp_rx_pdev_mon_desc_pool_init(struct dp_pdev *pdev);
+void dp_rx_pdev_mon_desc_pool_deinit(struct dp_pdev *pdev);
+void dp_rx_pdev_mon_desc_pool_free(struct dp_pdev *pdev);
+
+/**
+ * dp_rx_mon_dest_process() - Brain of the Rx processing functionality
+ *	Called from the bottom half (tasklet/NET_RX_SOFTIRQ)
+ * @soc: core txrx main contex
+ * @int_ctx: interrupt context
+ * @hal_ring: opaque pointer to the HAL Rx Ring, which will be serviced
+ * @quota: No. of units (packets) that can be serviced in one shot.
+ *
+ * This function implements the core of Rx functionality. This is
+ * expected to handle only non-error frames.
+ *
+ * Return: none
+ */
+#ifdef QCA_MONITOR_PKT_SUPPORT
+void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
+			    uint32_t mac_id, uint32_t quota);
+
+void dp_rx_pdev_mon_buf_buffers_free(struct dp_pdev *pdev, uint32_t mac_id);
+QDF_STATUS
+dp_rx_pdev_mon_buf_buffers_alloc(struct dp_pdev *pdev, uint32_t mac_id,
+				 bool delayed_replenish);
+QDF_STATUS
+dp_rx_pdev_mon_buf_desc_pool_alloc(struct dp_pdev *pdev, uint32_t mac_id);
+void
+dp_rx_pdev_mon_buf_desc_pool_init(struct dp_pdev *pdev, uint32_t mac_id);
+#else
+static inline
+void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
+			    uint32_t mac_id, uint32_t quota)
+{
+}
+
+static inline
+void dp_rx_pdev_mon_buf_buffers_free(struct dp_pdev *pdev, uint32_t mac_id)
+{
+}
+
+static inline QDF_STATUS
+dp_rx_pdev_mon_buf_buffers_alloc(struct dp_pdev *pdev, uint32_t mac_id,
+				 bool delayed_replenish)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline QDF_STATUS
+dp_rx_pdev_mon_buf_desc_pool_alloc(struct dp_pdev *pdev, uint32_t mac_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline void
+dp_rx_pdev_mon_buf_desc_pool_init(struct dp_pdev *pdev, uint32_t mac_id)
+{
+}
+#endif
+
+#if !defined(DISABLE_MON_CONFIG) && defined(MON_ENABLE_DROP_FOR_MAC)
+/**
+ * dp_mon_dest_srng_drop_for_mac() - Drop the mon dest ring packets for
+ *  a given mac
+ * @pdev: DP pdev
+ * @mac_id: mac id
+ *
+ * Return: None
+ */
+uint32_t
+dp_mon_dest_srng_drop_for_mac(struct dp_pdev *pdev, uint32_t mac_id);
+#endif
+
+/**
+ * dp_rxdma_err_process() - RxDMA error processing functionality
+ * @soc: core txrx main contex
+ * @mac_id: mac id which is one of 3 mac_ids
+ * @hal_ring: opaque pointer to the HAL Rx Ring, which will be serviced
+ * @quota: No. of units (packets) that can be serviced in one shot.
+ *
+ * Return: num of buffers processed
+ */
+uint32_t dp_rxdma_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
+			      uint32_t mac_id, uint32_t quota);
+
+/**
+ * dp_mon_buf_delayed_replenish() - Helper routine to replenish monitor dest buf
+ * @pdev: DP pdev object
+ *
+ * Return: None
+ */
+void dp_mon_buf_delayed_replenish(struct dp_pdev *pdev);
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+/**
+ * dp_rx_mon_link_desc_return() - Return a MPDU link descriptor to HW
+ *			      (WBM), following error handling
+ *
+ * @dp_pdev: core txrx pdev context
+ * @buf_addr_info: void pointer to monitor link descriptor buf addr info
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+dp_rx_mon_link_desc_return(struct dp_pdev *dp_pdev,
+			   hal_buff_addrinfo_t buf_addr_info,
+			   int mac_id);
+#else
+static inline QDF_STATUS
+dp_rx_mon_link_desc_return(struct dp_pdev *dp_pdev,
+			   hal_buff_addrinfo_t buf_addr_info,
+			   int mac_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
+/**
+ * dp_mon_adjust_frag_len() - MPDU and MSDU may spread across
+ *				multiple nbufs. This function
+ *                              is to return data length in
+ *				fragmented buffer
+ * @soc: Datapath soc handle
+ * @total_len: pointer to remaining data length.
+ * @frag_len: pointer to data length in this fragment.
+ * @l2_hdr_pad: l2 header padding
+ */
+static inline void dp_mon_adjust_frag_len(struct dp_soc *soc,
+					  uint32_t *total_len,
+					  uint32_t *frag_len,
+					  uint16_t l2_hdr_pad)
+{
+	uint32_t rx_pkt_tlv_len = soc->rx_pkt_tlv_size;
+
+	if (*total_len >= (RX_MONITOR_BUFFER_SIZE - rx_pkt_tlv_len)) {
+		*frag_len = RX_MONITOR_BUFFER_SIZE - rx_pkt_tlv_len -
+					l2_hdr_pad;
+		*total_len -= *frag_len;
+	} else {
+		*frag_len = *total_len;
+		*total_len = 0;
+	}
+}
+
+/**
+ * dp_rx_mon_frag_adjust_frag_len() - MPDU and MSDU may spread across
+ * multiple nbufs. This function is to return data length in
+ * fragmented buffer.
+ * It takes input as max_limit for any buffer(as it changes based
+ * on decap type and buffer sequence in MSDU.
+ *
+ * If MSDU is divided into multiple buffer then below format will
+ * be max limit.
+ * Decap type Non-Raw
+ *--------------------------------
+ *|  1st  |  2nd  | ...  | Last   |
+ *| 1662  |  1664 | 1664 | <=1664 |
+ *--------------------------------
+ * Decap type Raw
+ *--------------------------------
+ *|  1st  |  2nd  | ...  | Last   |
+ *| 1664  |  1664 | 1664 | <=1664 |
+ *--------------------------------
+ *
+ * It also calculate if current buffer has placeholder to keep padding byte.
+ *  --------------------------------
+ * |       MAX LIMIT(1662/1664)     |
+ *  --------------------------------
+ * | Actual Data | Pad byte Pholder |
+ *  --------------------------------
+ *
+ * @total_len: Remaining data length.
+ * @frag_len:  Data length in this fragment.
+ * @max_limit: Max limit of current buffer/MSDU.
+ */
+#ifdef DP_RX_MON_MEM_FRAG
+static inline
+void dp_rx_mon_frag_adjust_frag_len(uint32_t *total_len, uint32_t *frag_len,
+				    uint32_t max_limit)
+{
+	if (*total_len >= max_limit) {
+		*frag_len = max_limit;
+		*total_len -= *frag_len;
+	} else {
+		*frag_len = *total_len;
+		*total_len = 0;
+	}
+}
+
+/**
+ * DP_RX_MON_GET_NBUF_FROM_DESC() - Get nbuf from desc
+ */
+#define DP_RX_MON_GET_NBUF_FROM_DESC(rx_desc) \
+	NULL
+
+/**
+ * dp_rx_mon_add_msdu_to_list_failure_handler() - Handler for nbuf buffer
+ *                                                  attach failure
+ *
+ * @rx_tlv_hdr: rx_tlv_hdr
+ * @pdev: struct dp_pdev *
+ * @last: skb pointing to last skb in chained list at any moment
+ * @head_msdu: parent skb in the chained list
+ * @tail_msdu: Last skb in the chained list
+ * @func_name: caller function name
+ *
+ * Return: void
+ */
+static inline void
+dp_rx_mon_add_msdu_to_list_failure_handler(void *rx_tlv_hdr,
+					   struct dp_pdev *pdev,
+					   qdf_nbuf_t *last,
+					   qdf_nbuf_t *head_msdu,
+					   qdf_nbuf_t *tail_msdu,
+					   const char *func_name)
+{
+	DP_STATS_INC(pdev, replenish.nbuf_alloc_fail, 1);
+	qdf_frag_free(rx_tlv_hdr);
+	if (head_msdu)
+		qdf_nbuf_list_free(*head_msdu);
+	dp_err("[%s] failed to allocate subsequent parent buffer to hold all frag\n",
+	       func_name);
+	if (head_msdu)
+		*head_msdu = NULL;
+	if (last)
+		*last = NULL;
+	if (tail_msdu)
+		*tail_msdu = NULL;
+}
+
+/**
+ * dp_rx_mon_get_paddr_from_desc() - Get paddr from desc
+ */
+static inline
+qdf_dma_addr_t dp_rx_mon_get_paddr_from_desc(struct dp_rx_desc *rx_desc)
+{
+	return rx_desc->paddr_buf_start;
+}
+
+/**
+ * DP_RX_MON_IS_BUFFER_ADDR_NULL() - Is Buffer received from hw is NULL
+ */
+#define DP_RX_MON_IS_BUFFER_ADDR_NULL(rx_desc) \
+	(!(rx_desc->rx_buf_start))
+
+#define DP_RX_MON_IS_MSDU_NOT_NULL(msdu) \
+	true
+
+/**
+ * dp_rx_mon_buffer_free() - Free nbuf or frag memory
+ * Free nbuf if feature is disabled, else free frag.
+ *
+ * @rx_desc: Rx desc
+ */
+static inline void
+dp_rx_mon_buffer_free(struct dp_rx_desc *rx_desc)
+{
+	qdf_frag_free(rx_desc->rx_buf_start);
+}
+
+/**
+ * dp_rx_mon_buffer_unmap() - Unmap nbuf or frag memory
+ * Unmap nbuf if feature is disabled, else unmap frag.
+ *
+ * @soc: struct dp_soc *
+ * @rx_desc: struct dp_rx_desc *
+ * @size: Size to be unmapped
+ */
+static inline void
+dp_rx_mon_buffer_unmap(struct dp_soc *soc, struct dp_rx_desc *rx_desc,
+		       uint16_t size)
+{
+	qdf_mem_unmap_page(soc->osdev, rx_desc->paddr_buf_start,
+			   size, QDF_DMA_FROM_DEVICE);
+}
+
+/**
+ * dp_rx_mon_alloc_parent_buffer() - Allocate parent buffer to hold
+ * radiotap header and accommodate all frag memory in nr_frag.
+ *
+ * @head_msdu: Ptr to hold allocated Msdu
+ *
+ * Return: QDF_STATUS
+ */
+static inline
+QDF_STATUS dp_rx_mon_alloc_parent_buffer(qdf_nbuf_t *head_msdu)
+{
+	/*
+	 * Headroom should accommodate radiotap header
+	 * and protocol and flow tag for all frag
+	 * Length reserved to accommodate Radiotap header
+	 * is 128 bytes and length reserved for Protocol
+	 * flow tag will vary based on QDF_NBUF_MAX_FRAGS.
+	 */
+	/*  -------------------------------------------------
+	 * |       Protocol & Flow TAG      | Radiotap header|
+	 * |                                |  Length(128 B) |
+	 * |  ((4* QDF_NBUF_MAX_FRAGS) * 2) |                |
+	 *  -------------------------------------------------
+	 */
+
+	*head_msdu = qdf_nbuf_alloc_no_recycler(DP_RX_MON_MAX_MONITOR_HEADER,
+						DP_RX_MON_MAX_MONITOR_HEADER, 4);
+
+	if (!(*head_msdu))
+		return QDF_STATUS_E_FAILURE;
+
+	qdf_mem_zero(qdf_nbuf_head(*head_msdu), qdf_nbuf_headroom(*head_msdu));
+
+	/* Set *head_msdu->next as NULL as all msdus are
+	 * mapped via nr frags
+	 */
+	qdf_nbuf_set_next(*head_msdu, NULL);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * dp_rx_mon_parse_desc_buffer() - Parse desc buffer based.
+ *
+ * Below code will parse desc buffer, handle continuation frame,
+ * adjust frag length and update l2_hdr_padding
+ *
+ * @soc                : struct dp_soc*
+ * @msdu_info          : struct hal_rx_msdu_desc_info*
+ * @is_frag_p          : is_frag *
+ * @total_frag_len_p   : Remaining frag len to be updated
+ * @frag_len_p         : frag len
+ * @l2_hdr_offset_p    : l2 hdr offset
+ * @rx_desc_tlv        : rx_desc_tlv
+ * @is_frag_non_raw_p  : Non raw frag
+ * @data               : NBUF Data
+ */
+static inline void
+dp_rx_mon_parse_desc_buffer(struct dp_soc *dp_soc,
+			    struct hal_rx_msdu_desc_info *msdu_info,
+			    bool *is_frag_p, uint32_t *total_frag_len_p,
+			    uint32_t *frag_len_p, uint16_t *l2_hdr_offset_p,
+			    qdf_frag_t rx_desc_tlv,
+			    bool *is_frag_non_raw_p, void *data)
+{
+	struct hal_rx_mon_dest_buf_info frame_info;
+	uint16_t tot_payload_len =
+			RX_MONITOR_BUFFER_SIZE - dp_soc->rx_pkt_tlv_size;
+
+	if (msdu_info->msdu_flags & HAL_MSDU_F_MSDU_CONTINUATION) {
+		/* First buffer of MSDU */
+		if (!(*is_frag_p)) {
+			/* Set total frag_len from msdu_len */
+			*total_frag_len_p = msdu_info->msdu_len;
+
+			*is_frag_p = true;
+			if (HAL_HW_RX_DECAP_FORMAT_RAW ==
+			    hal_rx_tlv_decap_format_get(dp_soc->hal_soc,
+							rx_desc_tlv)) {
+				*l2_hdr_offset_p =
+					DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
+				frame_info.is_decap_raw = 1;
+			} else {
+				*l2_hdr_offset_p =
+					DP_RX_MON_NONRAW_L2_HDR_PAD_BYTE;
+				frame_info.is_decap_raw = 0;
+				*is_frag_non_raw_p = true;
+			}
+			dp_rx_mon_frag_adjust_frag_len(total_frag_len_p,
+						       frag_len_p,
+						       tot_payload_len -
+						       *l2_hdr_offset_p);
+
+			frame_info.first_buffer = 1;
+			frame_info.last_buffer = 0;
+			hal_rx_priv_info_set_in_tlv(dp_soc->hal_soc,
+						    rx_desc_tlv,
+						    (uint8_t *)&frame_info,
+						    sizeof(frame_info));
+		} else {
+			/*
+			 * Continuation Middle frame
+			 * Here max limit will be same for Raw and Non raw case.
+			 */
+			*l2_hdr_offset_p = DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
+			dp_rx_mon_frag_adjust_frag_len(total_frag_len_p,
+						       frag_len_p,
+						       tot_payload_len);
+
+			/* Update frame info if is non raw frame */
+			if (*is_frag_non_raw_p)
+				frame_info.is_decap_raw = 0;
+			else
+				frame_info.is_decap_raw = 1;
+
+			frame_info.first_buffer = 0;
+			frame_info.last_buffer = 0;
+			hal_rx_priv_info_set_in_tlv(dp_soc->hal_soc,
+						    rx_desc_tlv,
+						    (uint8_t *)&frame_info,
+						    sizeof(frame_info));
+		}
+	} else {
+		/**
+		 * Last buffer of MSDU spread among multiple buffer
+		 * Here max limit will be same for Raw and Non raw case.
+		 */
+		if (*is_frag_p) {
+			*l2_hdr_offset_p = DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
+
+			dp_rx_mon_frag_adjust_frag_len(total_frag_len_p,
+						       frag_len_p,
+						       tot_payload_len);
+
+			/* Update frame info if is non raw frame */
+			if (*is_frag_non_raw_p)
+				frame_info.is_decap_raw = 0;
+			else
+				frame_info.is_decap_raw = 1;
+
+			frame_info.first_buffer = 0;
+			frame_info.last_buffer = 1;
+			hal_rx_priv_info_set_in_tlv(dp_soc->hal_soc,
+						    rx_desc_tlv,
+						    (uint8_t *)&frame_info,
+						    sizeof(frame_info));
+		} else {
+			/* MSDU with single buffer */
+			*frag_len_p = msdu_info->msdu_len;
+			if (HAL_HW_RX_DECAP_FORMAT_RAW ==
+			    hal_rx_tlv_decap_format_get(dp_soc->hal_soc,
+							rx_desc_tlv)) {
+				*l2_hdr_offset_p =
+					DP_RX_MON_RAW_L2_HDR_PAD_BYTE;
+				frame_info.is_decap_raw = 1;
+			} else {
+				*l2_hdr_offset_p =
+					DP_RX_MON_NONRAW_L2_HDR_PAD_BYTE;
+				frame_info.is_decap_raw = 0;
+			}
+
+			frame_info.first_buffer = 1;
+			frame_info.last_buffer = 1;
+			hal_rx_priv_info_set_in_tlv(dp_soc->hal_soc,
+						    rx_desc_tlv,
+						    (uint8_t *)&frame_info,
+						    sizeof(frame_info));
+		}
+		/* Reset bool after complete processing of MSDU */
+		*is_frag_p = false;
+		*is_frag_non_raw_p = false;
+	}
+}
+
+/**
+ * dp_rx_mon_buffer_set_pktlen() - set pktlen for buffer
+ */
+static inline void dp_rx_mon_buffer_set_pktlen(qdf_nbuf_t msdu, uint32_t size)
+{
+}
+
+/**
+ * dp_rx_mon_add_msdu_to_list()- Add msdu to list and update head_msdu
+ *      It will add reaped buffer frag to nr frag of parent msdu.
+ * @soc: DP soc handle
+ * @head_msdu: NULL if first time called else &msdu
+ * @msdu: Msdu where frag address needs to be added via nr_frag
+ * @last: Used to traverse in list if this feature is disabled.
+ * @rx_desc_tlv: Frag address
+ * @frag_len: Frag len
+ * @l2_hdr_offset: l2 hdr padding
+ */
+static inline
+QDF_STATUS dp_rx_mon_add_msdu_to_list(struct dp_soc *soc, qdf_nbuf_t *head_msdu,
+				      qdf_nbuf_t msdu, qdf_nbuf_t *last,
+				      qdf_frag_t rx_desc_tlv, uint32_t frag_len,
+				      uint32_t l2_hdr_offset)
+{
+	uint32_t num_frags;
+	qdf_nbuf_t msdu_curr;
+
+	/* Here head_msdu and *head_msdu must not be NULL */
+	/* Dont add frag to skb if frag length is zero. Drop frame */
+	if (qdf_unlikely(!frag_len || !head_msdu || !(*head_msdu))) {
+		dp_err("[%s] frag_len[%d] || head_msdu[%pK] || *head_msdu is Null while adding frag to skb\n",
+		       __func__, frag_len, head_msdu);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/* In case of first desc of MPDU, assign curr msdu to *head_msdu */
+	if (!qdf_nbuf_get_nr_frags(*head_msdu))
+		msdu_curr = *head_msdu;
+	else
+		msdu_curr = *last;
+
+	/* Current msdu must not be NULL */
+	if (qdf_unlikely(!msdu_curr)) {
+		dp_err("[%s] Current msdu can't be Null while adding frag to skb\n",
+		       __func__);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	num_frags = qdf_nbuf_get_nr_frags(msdu_curr);
+	if (num_frags < QDF_NBUF_MAX_FRAGS) {
+		qdf_nbuf_add_rx_frag(rx_desc_tlv, msdu_curr,
+				     soc->rx_mon_pkt_tlv_size,
+				     frag_len + l2_hdr_offset,
+				     RX_MONITOR_BUFFER_SIZE,
+				     false);
+		if (*last != msdu_curr)
+			*last = msdu_curr;
+		return QDF_STATUS_SUCCESS;
+	}
+
+	/* Execution will reach here only if num_frags == QDF_NBUF_MAX_FRAGS */
+	msdu_curr = NULL;
+	if ((dp_rx_mon_alloc_parent_buffer(&msdu_curr))
+	    != QDF_STATUS_SUCCESS)
+		return QDF_STATUS_E_FAILURE;
+
+	qdf_nbuf_add_rx_frag(rx_desc_tlv, msdu_curr, soc->rx_mon_pkt_tlv_size,
+			     frag_len + l2_hdr_offset, RX_MONITOR_BUFFER_SIZE,
+			     false);
+
+	/* Add allocated nbuf in the chain */
+	qdf_nbuf_set_next(*last, msdu_curr);
+
+	/* Assign current msdu to last to avoid traversal */
+	*last = msdu_curr;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * dp_rx_mon_init_tail_msdu() - Initialize tail msdu
+ *
+ * @head_msdu: Parent buffer to hold MPDU data
+ * @msdu: Msdu to be updated in tail_msdu
+ * @last: last msdu
+ * @tail_msdu: Last msdu
+ */
+static inline
+void dp_rx_mon_init_tail_msdu(qdf_nbuf_t *head_msdu, qdf_nbuf_t msdu,
+			      qdf_nbuf_t last, qdf_nbuf_t *tail_msdu)
+{
+	if (!head_msdu || !(*head_msdu)) {
+		*tail_msdu = NULL;
+		return;
+	}
+
+	if (last)
+		qdf_nbuf_set_next(last, NULL);
+	*tail_msdu = last;
+}
+
+/**
+ * dp_rx_mon_remove_raw_frame_fcs_len() - Remove FCS length for Raw Frame
+ *
+ * If feature is disabled, then removal happens in restitch logic.
+ *
+ * @soc: Datapath soc handle
+ * @head_msdu: Head msdu
+ * @tail_msdu: Tail msdu
+ */
+static inline
+void dp_rx_mon_remove_raw_frame_fcs_len(struct dp_soc *soc,
+					qdf_nbuf_t *head_msdu,
+					qdf_nbuf_t *tail_msdu)
+{
+	qdf_frag_t addr;
+
+	if (qdf_unlikely(!head_msdu || !tail_msdu || !(*head_msdu)))
+		return;
+
+	/* If *head_msdu is valid, then *tail_msdu must be valid */
+	/* If head_msdu is valid, then it must have nr_frags */
+	/* If tail_msdu is valid, then it must have nr_frags */
+
+	/* Strip FCS_LEN for Raw frame */
+	addr = qdf_nbuf_get_frag_addr(*head_msdu, 0);
+	addr -= soc->rx_mon_pkt_tlv_size;
+	if (hal_rx_tlv_decap_format_get(soc->hal_soc, addr) ==
+		HAL_HW_RX_DECAP_FORMAT_RAW) {
+		qdf_nbuf_trim_add_frag_size(*tail_msdu,
+			qdf_nbuf_get_nr_frags(*tail_msdu) - 1,
+					-HAL_RX_FCS_LEN, 0);
+	}
+}
+
+/**
+ * dp_rx_mon_get_buffer_data()- Get data from desc buffer
+ * @rx_desc: desc
+ *
+ * Return address containing actual tlv content
+ */
+static inline
+uint8_t *dp_rx_mon_get_buffer_data(struct dp_rx_desc *rx_desc)
+{
+	return rx_desc->rx_buf_start;
+}
+
+#else
+
+#define DP_RX_MON_GET_NBUF_FROM_DESC(rx_desc) \
+	(rx_desc->nbuf)
+
+static inline void
+dp_rx_mon_add_msdu_to_list_failure_handler(void *rx_tlv_hdr,
+					   struct dp_pdev *pdev,
+					   qdf_nbuf_t *last,
+					   qdf_nbuf_t *head_msdu,
+					   qdf_nbuf_t *tail_msdu,
+					   const char *func_name)
+{
+}
+
+static inline
+qdf_dma_addr_t dp_rx_mon_get_paddr_from_desc(struct dp_rx_desc *rx_desc)
+{
+	qdf_dma_addr_t paddr = 0;
+	qdf_nbuf_t msdu = NULL;
+
+	msdu = rx_desc->nbuf;
+	if (msdu)
+		paddr = qdf_nbuf_get_frag_paddr(msdu, 0);
+
+	return paddr;
+}
+
+#define DP_RX_MON_IS_BUFFER_ADDR_NULL(rx_desc) \
+	(!(rx_desc->nbuf))
+
+#define DP_RX_MON_IS_MSDU_NOT_NULL(msdu) \
+	(msdu)
+
+static inline void
+dp_rx_mon_buffer_free(struct dp_rx_desc *rx_desc)
+{
+	qdf_nbuf_free(rx_desc->nbuf);
+}
+
+static inline void
+dp_rx_mon_buffer_unmap(struct dp_soc *soc, struct dp_rx_desc *rx_desc,
+		       uint16_t size)
+{
+	qdf_nbuf_unmap_nbytes_single(soc->osdev, rx_desc->nbuf,
+				     QDF_DMA_FROM_DEVICE, size);
+}
+
+static inline
+QDF_STATUS dp_rx_mon_alloc_parent_buffer(qdf_nbuf_t *head_msdu)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline void
+dp_rx_mon_parse_desc_buffer(struct dp_soc *dp_soc,
+			    struct hal_rx_msdu_desc_info *msdu_info,
+			    bool *is_frag_p, uint32_t *total_frag_len_p,
+			    uint32_t *frag_len_p, uint16_t *l2_hdr_offset_p,
+			    qdf_frag_t rx_desc_tlv,
+			    bool *is_frag_non_raw_p, void *data)
+{
+	/*
+	 * HW structures call this L3 header padding
+	 * -- even though this is actually the offset
+	 * from the buffer beginning where the L2
+	 * header begins.
+	 */
+	*l2_hdr_offset_p =
+	hal_rx_msdu_end_l3_hdr_padding_get(dp_soc->hal_soc, data);
+
+	if (msdu_info->msdu_flags & HAL_MSDU_F_MSDU_CONTINUATION) {
+		if (!*(is_frag_p)) {
+			*total_frag_len_p = msdu_info->msdu_len;
+			*is_frag_p = true;
+		}
+		dp_mon_adjust_frag_len(dp_soc, total_frag_len_p, frag_len_p,
+				       *l2_hdr_offset_p);
+	} else {
+		if (*is_frag_p) {
+			dp_mon_adjust_frag_len(dp_soc, total_frag_len_p,
+					       frag_len_p,
+					       *l2_hdr_offset_p);
+		} else {
+			*frag_len_p = msdu_info->msdu_len;
+		}
+		*is_frag_p = false;
+	}
+}
+
+static inline void dp_rx_mon_buffer_set_pktlen(qdf_nbuf_t msdu, uint32_t size)
+{
+	qdf_nbuf_set_pktlen(msdu, size);
+}
+
+static inline
+QDF_STATUS dp_rx_mon_add_msdu_to_list(struct dp_soc *soc, qdf_nbuf_t *head_msdu,
+				      qdf_nbuf_t msdu, qdf_nbuf_t *last,
+				      qdf_frag_t rx_desc_tlv, uint32_t frag_len,
+				      uint32_t l2_hdr_offset)
+{
+	if (head_msdu && !*head_msdu) {
+		*head_msdu = msdu;
+	} else {
+		if (*last)
+			qdf_nbuf_set_next(*last, msdu);
+	}
+	*last = msdu;
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline
+void dp_rx_mon_init_tail_msdu(qdf_nbuf_t *head_msdu, qdf_nbuf_t msdu,
+			      qdf_nbuf_t last, qdf_nbuf_t *tail_msdu)
+{
+	if (last)
+		qdf_nbuf_set_next(last, NULL);
+
+	*tail_msdu = msdu;
+}
+
+static inline
+void dp_rx_mon_remove_raw_frame_fcs_len(struct dp_soc *soc,
+					qdf_nbuf_t *head_msdu,
+					qdf_nbuf_t *tail_msdu)
+{
+}
+
+static inline
+uint8_t *dp_rx_mon_get_buffer_data(struct dp_rx_desc *rx_desc)
+{
+	qdf_nbuf_t msdu = NULL;
+	uint8_t *data = NULL;
+
+	msdu = rx_desc->nbuf;
+	if (qdf_likely(msdu))
+		data = qdf_nbuf_data(msdu);
+	return data;
+}
+
+#endif
+
+/**
+ * dp_rx_cookie_2_mon_link_desc() - Retrieve Link descriptor based on target
+ * @pdev: core physical device context
+ * @hal_buf_info: structure holding the buffer info
+ * mac_id: mac number
+ *
+ * Return: link descriptor address
+ */
+static inline
+void *dp_rx_cookie_2_mon_link_desc(struct dp_pdev *pdev,
+				   struct hal_buf_info buf_info,
+				   uint8_t mac_id)
+{
+	if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
+		return dp_rx_cookie_2_mon_link_desc_va(pdev, &buf_info,
+						       mac_id);
+
+	return dp_rx_cookie_2_link_desc_va(pdev->soc, &buf_info);
+}
+
+/**
+ * dp_rx_monitor_link_desc_return() - Return Link descriptor based on target
+ * @pdev: core physical device context
+ * @p_last_buf_addr_info: MPDU Link descriptor
+ * mac_id: mac number
+ *
+ * Return: QDF_STATUS
+ */
+static inline
+QDF_STATUS dp_rx_monitor_link_desc_return(struct dp_pdev *pdev,
+					  hal_buff_addrinfo_t
+					  p_last_buf_addr_info,
+					  uint8_t mac_id, uint8_t bm_action)
+{
+	if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
+		return dp_rx_mon_link_desc_return(pdev, p_last_buf_addr_info,
+						  mac_id);
+
+	return dp_rx_link_desc_return_by_addr(pdev->soc, p_last_buf_addr_info,
+				      bm_action);
+}
+
+/**
+ * dp_rxdma_get_mon_dst_ring() - Return the pointer to rxdma_err_dst_ring
+ *					or mon_dst_ring based on the target
+ * @pdev: core physical device context
+ * @mac_for_pdev: mac_id number
+ *
+ * Return: ring address
+ */
+static inline
+void *dp_rxdma_get_mon_dst_ring(struct dp_pdev *pdev,
+				uint8_t mac_for_pdev)
+{
+	if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
+		return pdev->soc->rxdma_mon_dst_ring[mac_for_pdev].hal_srng;
+
+	return pdev->soc->rxdma_err_dst_ring[mac_for_pdev].hal_srng;
+}
+
+/**
+ * dp_rxdma_get_mon_buf_ring() - Return monitor buf ring address
+ *				    based on target
+ * @pdev: core physical device context
+ * @mac_for_pdev: mac id number
+ *
+ * Return: ring address
+ */
+static inline
+struct dp_srng *dp_rxdma_get_mon_buf_ring(struct dp_pdev *pdev,
+					  uint8_t mac_for_pdev)
+{
+	if (pdev->soc->wlan_cfg_ctx->rxdma1_enable)
+		return &pdev->soc->rxdma_mon_buf_ring[mac_for_pdev];
+
+	/* For MCL there is only 1 rx refill ring */
+	return &pdev->soc->rx_refill_buf_ring[0];
+}
+
+/**
+ * dp_rx_get_mon_desc() - Return Rx descriptor based on target
+ * @soc: soc handle
+ * @cookie: cookie value
+ *
+ * Return: Rx descriptor
+ */
+static inline
+struct dp_rx_desc *dp_rx_get_mon_desc(struct dp_soc *soc,
+				      uint32_t cookie)
+{
+	if (soc->wlan_cfg_ctx->rxdma1_enable)
+		return dp_rx_cookie_2_va_mon_buf(soc, cookie);
+
+	return dp_rx_cookie_2_va_rxdma_buf(soc, cookie);
+}
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+/*
+ * dp_mon_htt_dest_srng_setup(): monitor dest srng setup
+ * @soc: DP SOC handle
+ * @pdev: DP PDEV handle
+ * @mac_id: MAC ID
+ * @mac_for_pdev: PDEV mac
+ *
+ * Return: status: QDF_STATUS_SUCCESS - Success, non-zero: Failure
+ */
+QDF_STATUS dp_mon_htt_dest_srng_setup(struct dp_soc *soc,
+				      struct dp_pdev *pdev,
+				      int mac_id,
+				      int mac_for_pdev);
+
+/*
+ * dp_mon_dest_rings_deinit(): deinit monitor dest rings
+ * @pdev: DP PDEV handle
+ * @lmac_id: MAC ID
+ *
+ * Return: status: None
+ */
+void dp_mon_dest_rings_deinit(struct dp_pdev *pdev, int lmac_id);
+
+/*
+ * dp_mon_dest_rings_free(): free monitor dest rings
+ * @pdev: DP PDEV handle
+ * @lmac_id: MAC ID
+ *
+ * Return: status: None
+ */
+void dp_mon_dest_rings_free(struct dp_pdev *pdev, int lmac_id);
+
+/*
+ * dp_mon_dest_rings_init(): init monitor dest rings
+ * @pdev: DP PDEV handle
+ * @lmac_id: MAC ID
+ *
+ * Return: status: QDF_STATUS_SUCCESS - Success, non-zero: Failure
+ */
+QDF_STATUS dp_mon_dest_rings_init(struct dp_pdev *pdev, int lmac_id);
+
+/*
+ * dp_mon_dest_rings_allocate(): allocate monitor dest rings
+ * @pdev: DP PDEV handle
+ * @lmac_id: MAC ID
+ *
+ * Return: status: QDF_STATUS_SUCCESS - Success, non-zero: Failure
+ */
+QDF_STATUS dp_mon_dest_rings_alloc(struct dp_pdev *pdev, int lmac_id);
+
+#else
+QDF_STATUS dp_mon_htt_dest_srng_setup(struct dp_soc *soc,
+				      struct dp_pdev *pdev,
+				      int mac_id,
+				      int mac_for_pdev)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static void dp_mon_dest_rings_deinit(struct dp_pdev *pdev, int lmac_id)
+{
+}
+
+static void dp_mon_dest_rings_free(struct dp_pdev *pdev, int lmac_id)
+{
+}
+
+static
+QDF_STATUS dp_mon_dest_rings_init(struct dp_pdev *pdev, int lmac_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static
+QDF_STATUS dp_mon_dest_rings_alloc(struct dp_pdev *pdev, int lmac_id)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif /* QCA_MONITOR_PKT_SUPPORT */
+
 #endif /* _DP_RX_MON_1_0_H_ */

dp/wifi3.0/monitor/1.0/dp_rx_mon_dest_1.0.c

@@ -29,6 +29,8 @@
 #include "wlan_cfg.h"
 #include "dp_internal.h"
 #include "dp_rx_buffer_pool.h"
+#include <dp_mon_1.0.h>
+#include <dp_rx_mon_1.0.h>
 
 #ifndef IEEE80211_FCO_SUBTYPE_ACTION_NO_ACK
 #define IEEE80211_FCO_SUBTYPE_ACTION_NO_ACK 0xe0
@@ -53,7 +55,7 @@
 #define MON_DEST_RING_STUCK_MAX_CNT 16
 
 #ifdef WLAN_TX_PKT_CAPTURE_ENH
-static inline void
+void
 dp_handle_tx_capture(struct dp_soc *soc, struct dp_pdev *pdev,
 		     qdf_nbuf_t mon_mpdu)
 {
@@ -85,19 +87,11 @@ dp_tx_capture_get_user_id(struct dp_pdev *dp_pdev, void *rx_desc_tlv)
 }
 #endif
 #else
-static inline void
-dp_handle_tx_capture(struct dp_soc *soc, struct dp_pdev *pdev,
-		     qdf_nbuf_t mon_mpdu)
-{
-}
-
-#ifdef QCA_MONITOR_PKT_SUPPORT
 static void
 dp_tx_capture_get_user_id(struct dp_pdev *dp_pdev, void *rx_desc_tlv)
 {
 }
 #endif
-#endif
 
 #ifdef QCA_MONITOR_PKT_SUPPORT
 /**
@@ -471,34 +465,6 @@ next_msdu:
 	return rx_bufs_used;
 }
 
-/**
- * dp_rx_extract_radiotap_info(): Extract and populate information in
- *				struct mon_rx_status type
- * @rx_status: Receive status
- * @mon_rx_status: Monitor mode status
- *
- * Returns: None
- */
-static inline
-void dp_rx_extract_radiotap_info(struct cdp_mon_status *rx_status,
-				 struct mon_rx_status *rx_mon_status)
-{
-	rx_mon_status->tsft = rx_status->cdp_rs_tstamp.cdp_tsf;
-	rx_mon_status->chan_freq = rx_status->rs_freq;
-	rx_mon_status->chan_num = rx_status->rs_channel;
-	rx_mon_status->chan_flags = rx_status->rs_flags;
-	rx_mon_status->rate = rx_status->rs_datarate;
-	/* TODO: rx_mon_status->ant_signal_db */
-	/* TODO: rx_mon_status->nr_ant */
-	rx_mon_status->mcs = rx_status->cdf_rs_rate_mcs;
-	rx_mon_status->is_stbc = rx_status->cdp_rs_stbc;
-	rx_mon_status->sgi = rx_status->cdp_rs_sgi;
-	/* TODO: rx_mon_status->ldpc */
-	/* TODO: rx_mon_status->beamformed */
-	/* TODO: rx_mon_status->vht_flags */
-	/* TODO: rx_mon_status->vht_flag_values1 */
-}
-
 void dp_rx_mon_dest_process(struct dp_soc *soc, struct dp_intr *int_ctx,
 			    uint32_t mac_id, uint32_t quota)
 {
@@ -2030,7 +1996,6 @@ mpdu_stitch_fail:
 #endif
 
 #ifdef DP_RX_MON_MEM_FRAG
-static inline
 qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
 				   qdf_nbuf_t head_msdu, qdf_nbuf_t tail_msdu,
 				   struct cdp_mon_status *rs)
@@ -2045,7 +2010,6 @@ qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
 							  tail_msdu, rs);
 }
 #else
-static inline
 qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
 				   qdf_nbuf_t head_msdu, qdf_nbuf_t tail_msdu,
 				   struct cdp_mon_status *rs)
@@ -2058,7 +2022,6 @@ qdf_nbuf_t dp_rx_mon_restitch_mpdu(struct dp_soc *soc, uint32_t mac_id,
 #ifdef DP_RX_MON_MEM_FRAG
 #if defined(WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG) ||\
 	defined(WLAN_SUPPORT_RX_FLOW_TAG)
-static inline
 void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
 					     qdf_nbuf_t nbuf)
 {
@@ -2111,116 +2074,12 @@ void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
 		ext_list = qdf_nbuf_queue_next(ext_list);
 	}
 }
-#else
-static inline
-void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
-					     qdf_nbuf_t nbuf)
-{
-}
-#endif
-#else
-static inline
-void dp_rx_mon_update_pf_tag_to_buf_headroom(struct dp_soc *soc,
-					     qdf_nbuf_t nbuf)
-{
-}
 #endif
-
-#ifdef DP_MON_RSSI_IN_DBM
-/*
- * dp_rx_mon_rssi_convert(): convert rssi_comb from unit dBm to dB
- * to match with radiotap further conversion requirement
- * @rx_status: monitor mode rx status pointer
- *
- * Return: none
- */
-static inline
-void dp_rx_mon_rssi_convert(struct mon_rx_status *rx_status)
-{
-	rx_status->rssi_comb = rx_status->rssi_comb -
-			rx_status->chan_noise_floor;
-}
-#else
-static inline
-void dp_rx_mon_rssi_convert(struct mon_rx_status *rx_status)
-{
-}
 #endif
 
-/**
- * dp_send_mgmt_packet_to_stack(): send indicataion to upper layers
- *
- * @soc: soc handle
- * @nbuf: Mgmt packet
- * @pdev: pdev handle
- *
- * Return: QDF_STATUS_SUCCESS on success
- *         QDF_STATUS_E_INVAL in error
- */
-#ifdef QCA_MCOPY_SUPPORT
-static inline QDF_STATUS dp_send_mgmt_packet_to_stack(struct dp_soc *soc,
-						      qdf_nbuf_t nbuf,
-						      struct dp_pdev *pdev)
-{
-	uint32_t *nbuf_data;
-	struct ieee80211_frame *wh;
-	qdf_frag_t addr;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
-
-	if (!nbuf)
-		return QDF_STATUS_E_INVAL;
-
-	/* Get addr pointing to80211 header */
-	addr = dp_rx_mon_get_nbuf_80211_hdr(nbuf);
-	if (qdf_unlikely(!addr)) {
-		qdf_nbuf_free(nbuf);
-		return QDF_STATUS_E_INVAL;
-	}
-
-	/*check if this is not a mgmt packet*/
-	wh = (struct ieee80211_frame *)addr;
-	if (((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) !=
-	     IEEE80211_FC0_TYPE_MGT) &&
-	     ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) !=
-	     IEEE80211_FC0_TYPE_CTL)) {
-		qdf_nbuf_free(nbuf);
-		return QDF_STATUS_E_INVAL;
-	}
-	nbuf_data = (uint32_t *)qdf_nbuf_push_head(nbuf, 4);
-	if (!nbuf_data) {
-		QDF_TRACE(QDF_MODULE_ID_DP,
-			  QDF_TRACE_LEVEL_ERROR,
-			  FL("No headroom"));
-		qdf_nbuf_free(nbuf);
-		return QDF_STATUS_E_INVAL;
-	}
-	*nbuf_data = mon_pdev->ppdu_info.com_info.ppdu_id;
-
-	dp_wdi_event_handler(WDI_EVENT_RX_MGMT_CTRL, soc, nbuf,
-			     HTT_INVALID_PEER,
-			     WDI_NO_VAL, pdev->pdev_id);
-	return QDF_STATUS_SUCCESS;
-}
-#else
-static inline QDF_STATUS dp_send_mgmt_packet_to_stack(struct dp_soc *soc,
-						      qdf_nbuf_t nbuf,
-						      struct dp_pdev *pdev)
-{
-	return QDF_STATUS_SUCCESS;
-}
-#endif /* QCA_MCOPY_SUPPORT */
-
-/*
- * dp_rx_mon_process_dest_pktlog(): function to log packet contents to
- * pktlog buffer and send to pktlog module
- * @soc: DP soc
- * @mac_id: MAC ID
- * @mpdu: MPDU buf
- * Return: status: 0 - Success, non-zero: Failure
- */
-static QDF_STATUS dp_rx_mon_process_dest_pktlog(struct dp_soc *soc,
-						uint32_t mac_id,
-						qdf_nbuf_t mpdu)
+QDF_STATUS dp_rx_mon_process_dest_pktlog(struct dp_soc *soc,
+					 uint32_t mac_id,
+					 qdf_nbuf_t mpdu)
 {
 	uint32_t event, msdu_timestamp = 0;
 	struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
@@ -2262,174 +2121,134 @@ static QDF_STATUS dp_rx_mon_process_dest_pktlog(struct dp_soc *soc,
 	return QDF_STATUS_SUCCESS;
 }
 
-/*
- * dp_rx_mon_deliver(): function to deliver packets to stack
- * @soc: DP soc
- * @mac_id: MAC ID
- * @head_msdu: head of msdu list
- * @tail_msdu: tail of msdu list
- *
- * Return: status: 0 - Success, non-zero: Failure
- */
-QDF_STATUS dp_rx_mon_deliver(struct dp_soc *soc, uint32_t mac_id,
-			     qdf_nbuf_t head_msdu,
-			     qdf_nbuf_t tail_msdu)
+#ifdef QCA_MONITOR_PKT_SUPPORT
+QDF_STATUS dp_mon_htt_dest_srng_setup(struct dp_soc *soc,
+				      struct dp_pdev *pdev,
+				      int mac_id,
+				      int mac_for_pdev)
 {
-	struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
-	struct cdp_mon_status *rs;
-	qdf_nbuf_t mon_skb, skb_next;
-	qdf_nbuf_t mon_mpdu = NULL;
-	struct dp_mon_vdev *mon_vdev;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev)
-		goto mon_deliver_fail;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
-	mon_pdev = pdev->monitor_pdev;
-	rs = &mon_pdev->rx_mon_recv_status;
+	if (soc->wlan_cfg_ctx->rxdma1_enable) {
+		status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
+					soc->rxdma_mon_buf_ring[mac_id]
+					.hal_srng,
+					RXDMA_MONITOR_BUF);
 
-	if (!mon_pdev->mvdev && !mon_pdev->mcopy_mode &&
-	    !mon_pdev->rx_pktlog_cbf)
-		goto mon_deliver_fail;
+		if (status != QDF_STATUS_SUCCESS) {
+			dp_mon_err("Failed to send htt srng setup message for Rxdma mon buf ring");
+			return status;
+		}
 
-	/* restitch mon MPDU for delivery via monitor interface */
-	mon_mpdu = dp_rx_mon_restitch_mpdu(soc, mac_id, head_msdu,
-					   tail_msdu, rs);
+		status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
+					soc->rxdma_mon_dst_ring[mac_id]
+					.hal_srng,
+					RXDMA_MONITOR_DST);
 
-	/* If MPDU restitch fails, free buffers*/
-	if (!mon_mpdu) {
-		dp_info("MPDU restitch failed, free buffers");
-		goto mon_deliver_fail;
-	}
+		if (status != QDF_STATUS_SUCCESS) {
+			dp_mon_err("Failed to send htt srng setup message for Rxdma mon dst ring");
+			return status;
+		}
 
-	dp_rx_mon_process_dest_pktlog(soc, mac_id, mon_mpdu);
+		status = htt_srng_setup(soc->htt_handle, mac_for_pdev,
+					soc->rxdma_mon_desc_ring[mac_id]
+					.hal_srng,
+					RXDMA_MONITOR_DESC);
 
-	/* monitor vap cannot be present when mcopy is enabled
-	 * hence same skb can be consumed
-	 */
-	if (mon_pdev->mcopy_mode)
-		return dp_send_mgmt_packet_to_stack(soc, mon_mpdu, pdev);
-
-	if (mon_mpdu && mon_pdev->mvdev &&
-	    mon_pdev->mvdev->osif_vdev &&
-	    mon_pdev->mvdev->monitor_vdev &&
-	    mon_pdev->mvdev->monitor_vdev->osif_rx_mon) {
-		mon_vdev = mon_pdev->mvdev->monitor_vdev;
-
-		mon_pdev->ppdu_info.rx_status.ppdu_id =
-			mon_pdev->ppdu_info.com_info.ppdu_id;
-		mon_pdev->ppdu_info.rx_status.device_id = soc->device_id;
-		mon_pdev->ppdu_info.rx_status.chan_noise_floor =
-			pdev->chan_noise_floor;
-		/* convert rssi_comb from dBm to positive dB value */
-		dp_rx_mon_rssi_convert(&mon_pdev->ppdu_info.rx_status);
-
-		dp_handle_tx_capture(soc, pdev, mon_mpdu);
-
-		if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status,
-					      mon_mpdu,
-					      qdf_nbuf_headroom(mon_mpdu))) {
-			DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
-			goto mon_deliver_fail;
+		if (status != QDF_STATUS_SUCCESS) {
+			dp_mon_err("Failed to send htt srng message for Rxdma mon desc ring");
+			return status;
 		}
-
-		dp_rx_mon_update_pf_tag_to_buf_headroom(soc, mon_mpdu);
-		mon_vdev->osif_rx_mon(mon_pdev->mvdev->osif_vdev,
-				      mon_mpdu,
-				      &mon_pdev->ppdu_info.rx_status);
-	} else {
-		dp_rx_mon_dest_debug("%pK: mon_mpdu=%pK monitor_vdev %pK osif_vdev %pK"
-				     , soc, mon_mpdu, mon_pdev->mvdev,
-				     (mon_pdev->mvdev ? mon_pdev->mvdev->osif_vdev
-				     : NULL));
-		goto mon_deliver_fail;
 	}
 
-	return QDF_STATUS_SUCCESS;
+	return status;
+}
+#endif /* QCA_MONITOR_PKT_SUPPORT */
 
-mon_deliver_fail:
-	mon_skb = head_msdu;
-	while (mon_skb) {
-		skb_next = qdf_nbuf_next(mon_skb);
+#ifdef QCA_MONITOR_PKT_SUPPORT
+void dp_mon_dest_rings_deinit(struct dp_pdev *pdev, int lmac_id)
+{
+	struct dp_soc *soc = pdev->soc;
 
-		 dp_rx_mon_dest_debug("%pK: [%s][%d] mon_skb=%pK len %u",
-				      soc,  __func__, __LINE__,
-				      mon_skb, mon_skb->len);
+	if (soc->wlan_cfg_ctx->rxdma1_enable) {
+		dp_srng_deinit(soc, &soc->rxdma_mon_buf_ring[lmac_id],
+			       RXDMA_MONITOR_BUF, 0);
+		dp_srng_deinit(soc, &soc->rxdma_mon_dst_ring[lmac_id],
+			       RXDMA_MONITOR_DST, 0);
+		dp_srng_deinit(soc, &soc->rxdma_mon_desc_ring[lmac_id],
+			       RXDMA_MONITOR_DESC, 0);
+	}
+}
 
-		qdf_nbuf_free(mon_skb);
-		mon_skb = skb_next;
+void dp_mon_dest_rings_free(struct dp_pdev *pdev, int lmac_id)
+{
+	struct dp_soc *soc = pdev->soc;
+
+	if (soc->wlan_cfg_ctx->rxdma1_enable) {
+		dp_srng_free(soc, &soc->rxdma_mon_buf_ring[lmac_id]);
+		dp_srng_free(soc, &soc->rxdma_mon_dst_ring[lmac_id]);
+		dp_srng_free(soc, &soc->rxdma_mon_desc_ring[lmac_id]);
 	}
-	return QDF_STATUS_E_INVAL;
 }
 
-/**
-* dp_rx_mon_deliver_non_std()
-* @soc: core txrx main contex
-* @mac_id: MAC ID
-*
-* This function delivers the radio tap and dummy MSDU
-* into user layer application for preamble only PPDU.
-*
-* Return: QDF_STATUS
-*/
-QDF_STATUS dp_rx_mon_deliver_non_std(struct dp_soc *soc,
-				     uint32_t mac_id)
+QDF_STATUS dp_mon_dest_rings_init(struct dp_pdev *pdev, int lmac_id)
 {
-	struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
-	ol_txrx_rx_mon_fp osif_rx_mon;
-	qdf_nbuf_t dummy_msdu;
-	struct dp_mon_pdev *mon_pdev;
-	struct dp_mon_vdev *mon_vdev;
+	struct dp_soc *soc = pdev->soc;
 
-	/* Sanity checking */
-	if (!pdev || !pdev->monitor_pdev)
-		goto mon_deliver_non_std_fail;
+	if (soc->wlan_cfg_ctx->rxdma1_enable) {
+		if (dp_srng_init(soc, &soc->rxdma_mon_buf_ring[lmac_id],
+				 RXDMA_MONITOR_BUF, 0, lmac_id)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_buf_ring ", soc);
+			goto fail1;
+		}
 
-	mon_pdev = pdev->monitor_pdev;
+		if (dp_srng_init(soc, &soc->rxdma_mon_dst_ring[lmac_id],
+				 RXDMA_MONITOR_DST, 0, lmac_id)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_dst_ring", soc);
+			goto fail1;
+		}
 
-	if (!mon_pdev->mvdev || !mon_pdev->mvdev ||
-	    !mon_pdev->mvdev->monitor_vdev ||
-	    !mon_pdev->mvdev->monitor_vdev->osif_rx_mon)
-		goto mon_deliver_non_std_fail;
-
-	mon_vdev = mon_pdev->mvdev->monitor_vdev;
-	/* Generate a dummy skb_buff */
-	osif_rx_mon = mon_vdev->osif_rx_mon;
-	dummy_msdu = qdf_nbuf_alloc(soc->osdev, MAX_MONITOR_HEADER,
-				    MAX_MONITOR_HEADER, 4, FALSE);
-	if (!dummy_msdu)
-		goto allocate_dummy_msdu_fail;
-
-	qdf_nbuf_set_pktlen(dummy_msdu, 0);
-	qdf_nbuf_set_next(dummy_msdu, NULL);
-
-	mon_pdev->ppdu_info.rx_status.ppdu_id =
-		mon_pdev->ppdu_info.com_info.ppdu_id;
-
-	/* Apply the radio header to this dummy skb */
-	if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status,
-				      dummy_msdu,
-				      qdf_nbuf_headroom(dummy_msdu))) {
-		DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
-		qdf_nbuf_free(dummy_msdu);
-		goto mon_deliver_non_std_fail;
+		if (dp_srng_init(soc, &soc->rxdma_mon_desc_ring[lmac_id],
+				 RXDMA_MONITOR_DESC, 0, lmac_id)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_desc_ring", soc);
+			goto fail1;
+		}
 	}
+	return QDF_STATUS_SUCCESS;
 
-	/* deliver to the user layer application */
-	osif_rx_mon(mon_pdev->mvdev->osif_vdev,
-		    dummy_msdu, NULL);
-
-	/* Clear rx_status*/
-	qdf_mem_zero(&mon_pdev->ppdu_info.rx_status,
-		     sizeof(mon_pdev->ppdu_info.rx_status));
-	mon_pdev->mon_ppdu_status = DP_PPDU_STATUS_START;
+fail1:
+	return QDF_STATUS_E_NOMEM;
+}
 
+QDF_STATUS dp_mon_dest_rings_alloc(struct dp_pdev *pdev, int lmac_id)
+{
+	int entries;
+	struct dp_soc *soc = pdev->soc;
+	struct wlan_cfg_dp_pdev_ctxt *pdev_cfg_ctx = pdev->wlan_cfg_ctx;
+
+	if (soc->wlan_cfg_ctx->rxdma1_enable) {
+		entries = wlan_cfg_get_dma_mon_buf_ring_size(pdev_cfg_ctx);
+		if (dp_srng_alloc(soc, &soc->rxdma_mon_buf_ring[lmac_id],
+				  RXDMA_MONITOR_BUF, entries, 0)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_buf_ring ", soc);
+			goto fail1;
+		}
+		entries = wlan_cfg_get_dma_mon_dest_ring_size(pdev_cfg_ctx);
+		if (dp_srng_alloc(soc, &soc->rxdma_mon_dst_ring[lmac_id],
+				  RXDMA_MONITOR_DST, entries, 0)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_dst_ring", soc);
+			goto fail1;
+		}
+		entries = wlan_cfg_get_dma_mon_desc_ring_size(pdev_cfg_ctx);
+		if (dp_srng_alloc(soc, &soc->rxdma_mon_desc_ring[lmac_id],
+				  RXDMA_MONITOR_DESC, entries, 0)) {
+			dp_mon_err("%pK: " RNG_ERR "rxdma_mon_desc_ring", soc);
+			goto fail1;
+		}
+	}
 	return QDF_STATUS_SUCCESS;
 
-allocate_dummy_msdu_fail:
-		 dp_rx_mon_dest_debug("%pK: mon_skb=%pK ",
-				      soc, dummy_msdu);
-
-mon_deliver_non_std_fail:
-	return QDF_STATUS_E_INVAL;
+fail1:
+	return QDF_STATUS_E_NOMEM;
 }
+#endif

dp/wifi3.0/monitor/dp_mon.h

@@ -42,6 +42,303 @@
 #define dp_mon_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_MON, params)
 #define dp_mon_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_MON, params)
 
+#ifndef WLAN_TX_PKT_CAPTURE_ENH
+struct dp_pdev_tx_capture {
+};
+
+struct dp_peer_tx_capture {
+};
+#endif
+
+/*
+ * dp_mon_soc_attach() - DP monitor soc attach
+ * @soc: Datapath SOC handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_NOMEM: Error
+ */
+QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc);
+
+/*
+ * dp_mon_soc_detach() - DP monitor soc detach
+ * @soc: Datapath SOC handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc);
+
+/*
+ * dp_mon_soc_cfg_init() - DP monitor soc config init
+ * @soc: Datapath SOC handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_soc_cfg_init(struct dp_soc *soc);
+
+/*
+ * dp_mon_pdev_attach() - DP monitor pdev attach
+ * @pdev: Datapath pdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_NOMEM: Error
+ */
+QDF_STATUS dp_mon_pdev_attach(struct dp_pdev *pdev);
+
+/*
+ * dp_mon_pdev_detach() - DP monitor pdev detach
+ * @pdev: Datapath pdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_pdev_detach(struct dp_pdev *pdev);
+
+/*
+ * dp_mon_pdev_init() - DP monitor pdev init
+ * @pdev: Datapath pdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_pdev_init(struct dp_pdev *pdev);
+
+/*
+ * dp_mon_pdev_deinit() - DP monitor pdev deinit
+ * @pdev: Datapath pdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_pdev_deinit(struct dp_pdev *pdev);
+
+/*
+ * dp_mon_vdev_attach() - DP monitor vdev attach
+ * @vdev: Datapath vdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_NOMEM: Error
+ */
+QDF_STATUS dp_mon_vdev_attach(struct dp_vdev *vdev);
+
+/*
+ * dp_mon_vdev_detach() - DP monitor vdev detach
+ * @vdev: Datapath vdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_vdev_detach(struct dp_vdev *vdev);
+
+/*
+ * dp_mon_peer_attach() - DP monitor peer attach
+ * @peer: Datapath peer handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_NOMEM: Error
+ */
+QDF_STATUS dp_mon_peer_attach(struct dp_peer *peer);
+
+/*
+ * dp_mon_peer_detach() - DP monitor peer detach
+ * @peer: Datapath peer handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_peer_detach(struct dp_peer *peer);
+
+/*
+ * dp_mon_cdp_ops_register() - Register monitor cdp ops
+ * @soc: Datapath soc handle
+ *
+ */
+void dp_mon_cdp_ops_register(struct dp_soc *soc);
+
+/*
+ * dp_mon_cdp_ops_deregister() - deregister monitor cdp ops
+ * @soc: Datapath soc handle
+ *
+ */
+void dp_mon_cdp_ops_deregister(struct dp_soc *soc);
+
+/*
+ * dp_mon_ops_register() - Register monitor ops
+ * @soc: Datapath soc handle
+ *
+ */
+void dp_mon_ops_register(struct dp_soc *soc);
+
+/*
+ * dp_mon_htt_srng_setup() - DP mon htt srng setup
+ * @soc: Datapath soc handle
+ * @pdev: Datapath pdev handle
+ * @mac_id: mac id
+ * @mac_for_pdev: mac id mapped pdev
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_FAILURE: Error
+ */
+QDF_STATUS dp_mon_htt_srng_setup(struct dp_soc *soc,
+				 struct dp_pdev *pdev,
+				 int mac_id,
+				 int mac_for_pdev);
+
+/*
+ * dp_config_debug_sniffer()- API to enable/disable debug sniffer
+ * @pdev: DP_PDEV handle
+ * @val: user provided value
+ *
+ * Return: 0 for success. nonzero for failure.
+ */
+#if defined(QCA_MCOPY_SUPPORT) || defined(QCA_TX_CAPTURE_SUPPORT)
+QDF_STATUS
+dp_config_debug_sniffer(struct dp_pdev *pdev, int val);
+#else
+static inline QDF_STATUS
+dp_config_debug_sniffer(struct dp_pdev *pdev, int val) {
+	return QDF_STATUS_E_INVAL;
+}
+#endif /* QCA_MCOPY_SUPPORT || QCA_TX_CAPTURE_SUPPORT */
+
+/*
+ * dp_htt_ppdu_stats_attach() - attach resources for HTT PPDU stats processing
+ * @pdev: Datapath PDEV handle
+ *
+ * Return: QDF_STATUS_SUCCESS: Success
+ *         QDF_STATUS_E_NOMEM: Error
+ */
+QDF_STATUS dp_htt_ppdu_stats_attach(struct dp_pdev *pdev);
+
+/*
+ * dp_htt_ppdu_stats_detach() - detach stats resources
+ * @pdev: Datapath PDEV handle
+ *
+ * Return: void
+ */
+void dp_htt_ppdu_stats_detach(struct dp_pdev *pdev);
+
+/*
+ *dp_set_bpr_enable() - API to enable/disable bpr feature
+ *@pdev_handle: DP_PDEV handle.
+ *@val: Provided value.
+ *
+ *Return: 0 for success. nonzero for failure.
+ */
+#ifdef QCA_SUPPORT_BPR
+QDF_STATUS
+dp_set_bpr_enable(struct dp_pdev *pdev, int val);
+#endif
+
+#ifdef ATH_SUPPORT_NAC
+int dp_set_filter_neigh_peers(struct dp_pdev *pdev,
+				     bool val);
+#endif /* ATH_SUPPORT_NAC */
+
+#ifdef WLAN_ATF_ENABLE
+void dp_set_atf_stats_enable(struct dp_pdev *pdev, bool value);
+#endif
+
+/**
+ * dp_set_bsscolor() - sets bsscolor for tx capture
+ * @pdev: Datapath PDEV handle
+ * @bsscolor: new bsscolor
+ */
+void
+dp_mon_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor);
+
+/**
+ * dp_pdev_get_filter_ucast_data() - get DP PDEV monitor ucast filter
+ * @soc : data path soc handle
+ * @pdev_id : pdev_id
+ * Return: true on ucast filter flag set
+ */
+bool dp_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle);
+
+/**
+ * dp_pdev_get_filter_mcast_data() - get DP PDEV monitor mcast filter
+ * @pdev_handle: Datapath PDEV handle
+ * Return: true on mcast filter flag set
+ */
+bool dp_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle);
+
+/**
+ * dp_pdev_get_filter_non_data() - get DP PDEV monitor non_data filter
+ * @pdev_handle: Datapath PDEV handle
+ * Return: true on non data filter flag set
+ */
+bool dp_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle);
+
+/*
+ * dp_set_pktlog_wifi3() - attach txrx vdev
+ * @pdev: Datapath PDEV handle
+ * @event: which event's notifications are being subscribed to
+ * @enable: WDI event subscribe or not. (True or False)
+ *
+ * Return: Success, NULL on failure
+ */
+#ifdef WDI_EVENT_ENABLE
+int dp_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
+			bool enable);
+#endif
+
+/* MCL specific functions */
+#if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
+/**
+ * dp_pktlogmod_exit() - API to cleanup pktlog info
+ * @pdev: Pdev handle
+ *
+ * Return: none
+ */
+void dp_pktlogmod_exit(struct dp_pdev *pdev);
+#else
+static inline
+void dp_pktlogmod_exit(struct dp_pdev *handle)
+{
+}
+#endif
+
+#ifdef QCA_MONITOR_PKT_SUPPORT
+/**
+ * dp_vdev_set_monitor_mode_buf_rings () - set monitor mode buf rings
+ *
+ * Allocate SW descriptor pool, buffers, link descriptor memory
+ * Initialize monitor related SRNGs
+ *
+ * @pdev: DP pdev object
+ *
+ * Return: void
+ */
+void dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev);
+
+/**
+ * dp_vdev_set_monitor_mode_rings () - set monitor mode rings
+ *
+ * Allocate SW descriptor pool, buffers, link descriptor memory
+ * Initialize monitor related SRNGs
+ *
+ * @pdev: DP pdev object
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
+					  uint8_t delayed_replenish);
+
+#else
+static inline void
+dp_vdev_set_monitor_mode_buf_rings(struct dp_pdev *pdev)
+{
+}
+
+static inline QDF_STATUS
+dp_vdev_set_monitor_mode_rings(struct dp_pdev *pdev,
+			       uint8_t delayed_replenish)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
 struct dp_mon_ops {
 	QDF_STATUS (*mon_soc_cfg_init)(struct dp_soc *soc);
 	QDF_STATUS (*mon_pdev_attach)(struct dp_pdev *pdev);
@@ -69,10 +366,10 @@ struct dp_mon_ops {
 	void (*mon_service_rings)(struct  dp_soc *soc, uint32_t quota);
 #endif
 #ifndef DISABLE_MON_CONFIG
-	uint32_t (*mon_process)(struct dp_soc *soc,
-				struct dp_intr *int_ctx,
-				uint32_t mac_id,
-				uint32_t quota);
+	uint32_t (*mon_rx_process)(struct dp_soc *soc,
+				   struct dp_intr *int_ctx,
+				   uint32_t mac_id,
+				   uint32_t quota);
 #endif
 	void (*mon_peer_tx_init)(struct dp_pdev *pdev, struct dp_peer *peer);
 	void (*mon_peer_tx_cleanup)(struct dp_vdev *vdev,
@@ -135,6 +432,8 @@ struct dp_mon_ops {
 	void (*mon_pktlogmod_exit)(struct dp_pdev *pdev);
 #endif
 	void (*mon_vdev_set_monitor_mode_buf_rings)(struct dp_pdev *pdev);
+	QDF_STATUS (*mon_vdev_set_monitor_mode_rings)(struct dp_pdev *pdev,
+						      uint8_t delayed_replenish);
 	void (*mon_neighbour_peers_detach)(struct dp_pdev *pdev);
 #ifdef FEATURE_NAC_RSSI
 	QDF_STATUS (*mon_filter_neighbour_peer)(struct dp_pdev *pdev,
@@ -159,6 +458,47 @@ struct dp_mon_ops {
 					   uint8_t *mac_addr,
 					   qdf_nbuf_t nbuf,
 					   uint32_t flags);
+#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);
+#endif
+#ifdef QCA_MCOPY_SUPPORT
+	void (*mon_filter_setup_mcopy_mode)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_mcopy_mode)(struct dp_pdev *pdev);
+#endif
+#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
+	void (*mon_filter_setup_smart_monitor)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_smart_monitor)(struct dp_pdev *pdev);
+#endif
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+	void (*mon_filter_setup_rx_enh_capture)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_rx_enh_capture)(struct dp_pdev *pdev);
+#endif
+	void (*mon_filter_setup_mon_mode)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_mon_mode)(struct dp_pdev *pdev);
+#ifdef WDI_EVENT_ENABLE
+	void (*mon_filter_setup_rx_pkt_log_full)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_rx_pkt_log_full)(struct dp_pdev *pdev);
+	void (*mon_filter_setup_rx_pkt_log_lite)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_rx_pkt_log_lite)(struct dp_pdev *pdev);
+	void (*mon_filter_setup_rx_pkt_log_cbf)(struct dp_pdev *pdev);
+	void (*mon_filter_reset_rx_pkt_log_cbf)(struct dp_pdev *pdev);
+#endif
+	QDF_STATUS (*mon_filter_update)(struct dp_pdev *pdev);
+
+	QDF_STATUS (*mon_rings_alloc)(struct dp_soc* soc, struct dp_pdev *pdev);
+	void (*mon_rings_free)(struct dp_pdev *pdev);
+	QDF_STATUS (*mon_rings_init)(struct dp_soc* soc, struct dp_pdev *pdev);
+	void (*mon_rings_deinit)(struct dp_pdev *pdev);
+
+	QDF_STATUS (*rx_pdev_mon_buffers_alloc)(struct dp_pdev *pdev);
+	void (*rx_pdev_mon_buffers_free)(struct dp_pdev *pdev);
+	void (*rx_pdev_mon_desc_pool_init)(struct dp_pdev *pdev);
+	void (*rx_pdev_mon_desc_pool_deinit)(struct dp_pdev *pdev);
+	QDF_STATUS (*rx_pdev_mon_desc_pool_alloc)(struct dp_pdev *pdev);
+	void (*rx_pdev_mon_desc_pool_free)(struct dp_pdev *pdev);
+	QDF_STATUS (*mon_buffers_alloc)(struct dp_pdev *pdev);
+	QDF_STATUS (*mon_buffers_free)(struct dp_pdev *pdev);
 };
 
 struct dp_mon_soc {
@@ -563,16 +903,6 @@ dp_cpu_ring_map[DP_NSS_CPU_RING_MAP_MAX][WLAN_CFG_INT_NUM_CONTEXTS_MAX];
 
 int
 dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(uint32_t bitmap);
-/**
- * dp_ppdu_desc_user_stats_update(): Function to update TX user stats
- * @pdev: DP pdev handle
- * @ppdu_info: per PPDU TLV descriptor
- *
- * return: void
- */
-void
-dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
-			       struct ppdu_info *ppdu_info);
 
 #ifdef WDI_EVENT_ENABLE
 void dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn);
@@ -1409,12 +1739,12 @@ uint32_t dp_monitor_process(struct dp_soc *soc, struct dp_intr *int_ctx,
 	}
 
 	monitor_ops = mon_soc->mon_ops;
-	if (!monitor_ops || !monitor_ops->mon_process) {
+	if (!monitor_ops || !monitor_ops->mon_rx_process) {
 		dp_mon_debug("callback not registered");
 		return 0;
 	}
 
-	return monitor_ops->mon_process(soc, int_ctx, mac_id, quota);
+	return monitor_ops->mon_rx_process(soc, int_ctx, mac_id, quota);
 }
 #else
 static inline
@@ -2606,23 +2936,166 @@ void dp_monitor_pdev_reset_scan_spcl_vap_stats_enable(struct dp_pdev *pdev,
 }
 #endif
 
-QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc);
-QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc);
-QDF_STATUS dp_mon_pdev_attach(struct dp_pdev *pdev);
-QDF_STATUS dp_mon_pdev_detach(struct dp_pdev *pdev);
-QDF_STATUS dp_mon_pdev_init(struct dp_pdev *pdev);
-QDF_STATUS dp_mon_pdev_deinit(struct dp_pdev *pdev);
-QDF_STATUS dp_mon_soc_cfg_init(struct dp_soc *soc);
-void dp_mon_cdp_ops_register(struct dp_soc *soc);
-void dp_mon_cdp_ops_deregister(struct dp_soc *soc);
-void dp_mon_ops_register(struct dp_mon_soc *mon_soc);
-QDF_STATUS dp_mon_htt_srng_setup(struct dp_soc *soc,
-				 struct dp_pdev *pdev,
-				 int mac_id,
-				 int mac_for_pdev);
 #ifdef QCA_ENHANCED_STATS_SUPPORT
 QDF_STATUS dp_peer_qos_stats_notify(struct dp_pdev *dp_pdev,
 				    struct cdp_rx_stats_ppdu_user *ppdu_user);
 #endif
 
+/*
+ * dp_print_pdev_rx_mon_stats() - print rx mon stats
+ * @pdev: device object
+ *
+ * Return: void
+ */
+void
+dp_print_pdev_rx_mon_stats(struct dp_pdev *pdev);
+
+/**
+ * dp_mcopy_check_deliver() - mcopy check deliver
+ * @pdev: DP pdev handle
+ * @peer_id: peer id
+ * @ppdu_id: ppdu
+ * @first_msdu: flag to indicate first msdu of ppdu
+ * Return: 0 on success, not 0 on failure
+ */
+QDF_STATUS dp_mcopy_check_deliver(struct dp_pdev *pdev,
+				  uint16_t peer_id,
+				  uint32_t ppdu_id,
+				  uint8_t first_msdu);
+
+/**
+ * dp_pdev_set_advance_monitor_filter() - Set DP PDEV monitor filter
+ * @soc: soc handle
+ * @pdev_id: id of Datapath PDEV handle
+ * @filter_val: Flag to select Filter for monitor mode
+ * Return: 0 on success, not 0 on failure
+ */
+#ifdef QCA_ADVANCE_MON_FILTER_SUPPORT
+QDF_STATUS
+dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
+				   struct cdp_monitor_filter *filter_val);
+#else
+static inline QDF_STATUS
+dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
+				   struct cdp_monitor_filter *filter_val)
+{
+	return QDF_STATUS_E_INVAL;
+}
+#endif /* QCA_ADVANCE_MON_FILTER_SUPPORT */
+
+/**
+ * dp_deliver_tx_mgmt() - Deliver mgmt frame for tx capture
+ * @cdp_soc : data path soc handle
+ * @pdev_id : pdev_id
+ * @nbuf: Management frame buffer
+ */
+QDF_STATUS
+dp_deliver_tx_mgmt(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, qdf_nbuf_t nbuf);
+
+/**
+ * dp_filter_neighbour_peer() - API to filter neighbour peer
+ * @pdev : DP pdev handle
+ * @rx_pkt_hdr : packet header
+ *
+ * return: QDF_STATUS_SUCCESS on success
+ *	   QDF_STATUS_E_FAILURE on failure
+ */
+#ifdef FEATURE_NAC_RSSI
+QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
+				    uint8_t *rx_pkt_hdr);
+#else
+static inline
+QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
+				    uint8_t *rx_pkt_hdr)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif /* FEATURE_NAC_RSSI */
+
+/*
+ * dp_neighbour_peers_detach() - Detach neighbour peers(nac clients)
+ * @pdev: device object
+ *
+ * Return: void
+ */
+void dp_neighbour_peers_detach(struct dp_pdev *pdev);
+
+/**
+ * dp_reset_monitor_mode() - Disable monitor mode
+ * @soc_hdl: Datapath soc handle
+ * @pdev_id: id of datapath PDEV handle
+ * @smart_monitor: smart monitor flag
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl,
+				 uint8_t pdev_id,
+				 uint8_t smart_monitor);
+
+static inline
+struct dp_mon_ops *dp_mon_ops_get(struct dp_soc *soc)
+{
+	if (soc && soc->monitor_soc)
+		return soc->monitor_soc->mon_ops;
+
+	return NULL;
+}
+
+static inline
+struct cdp_mon_ops *dp_mon_cdp_ops_get(struct dp_soc *soc)
+{
+	struct cdp_ops *ops = soc->cdp_soc.ops;
+
+	return ops->mon_ops;
+}
+
+/**
+ * dp_ppdu_desc_user_stats_update(): Function to update TX user stats
+ * @pdev: DP pdev handle
+ * @ppdu_info: per PPDU TLV descriptor
+ *
+ * return: void
+ */
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+void
+dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
+			       struct ppdu_info *ppdu_info);
+#else
+static inline void
+dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
+			       struct ppdu_info *ppdu_info)
+{
+}
+#endif /* QCA_ENHANCED_STATS_SUPPORT */
+
+/**
+ * dp_mon_ops_get_1_0(): Get legacy monitor ops
+ *
+ * return: Pointer to dp_mon_ops
+ */
+struct dp_mon_ops *dp_mon_ops_get_1_0(void);
+
+/**
+ * dp_mon_cdp_ops_get_1_0(): Get legacy monitor cdp ops
+ *
+ * return: Pointer to dp_mon_cdp_ops
+ */
+struct cdp_mon_ops *dp_mon_cdp_ops_get_1_0(void);
+
+#ifdef QCA_MONITOR_2_0_SUPPORT
+/**
+ * dp_mon_ops_get_2_0(): Get BE monitor ops
+ *
+ * return: Pointer to dp_mon_ops
+ */
+struct dp_mon_ops *dp_mon_ops_get_2_0(void);
+
+/**
+ * dp_mon_cdp_ops_get_2_0(): Get BE monitor cdp ops
+ *
+ * return: Pointer to dp_mon_cdp_ops
+ */
+struct cdp_mon_ops *dp_mon_cdp_ops_get_2_0(void);
+#endif
+
 #endif /* _DP_MON_H_ */

dp/wifi3.0/monitor/dp_mon_filter.c

@@ -15,94 +15,14 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
-
-#include <hal_api.h>
-#include <wlan_cfg.h>
-#include "dp_types.h"
-#include "dp_internal.h"
-#include "dp_htt.h"
-#include "dp_mon.h"
-#include "dp_mon_filter.h"
-
-/**
- * dp_mon_filter_mode_type_to_str
- *	Monitor Filter mode to string
- */
-static int8_t *dp_mon_filter_mode_type_to_str[DP_MON_FILTER_MAX_MODE] = {
-#ifdef QCA_ENHANCED_STATS_SUPPORT
-	"DP MON FILTER ENHACHED STATS MODE",
-#endif /* QCA_ENHANCED_STATS_SUPPORT */
-#ifdef QCA_MCOPY_SUPPORT
-	"DP MON FILTER MCOPY MODE",
-#endif /* QCA_MCOPY_SUPPORT */
-#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
-	"DP MON FILTER SMART MONITOR MODE",
-#endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
-	"DP_MON FILTER MONITOR MODE",
-#ifdef	WLAN_RX_PKT_CAPTURE_ENH
-	"DP MON FILTER RX CAPTURE MODE",
-#endif /* WLAN_RX_PKT_CAPTURE_ENH */
-#ifdef WDI_EVENT_ENABLE
-	"DP MON FILTER PKT LOG FULL MODE",
-	"DP MON FILTER PKT LOG LITE_MODE",
-#endif /* WDI_EVENT_ENABLE */
-};
-
-/**
- * dp_mon_filter_show_filter() - Show the set filters
- * @mon_pdev: Monitor pdev handle
- * @mode: The filter modes
- * @tlv_filter: tlv filter
- */
-static void dp_mon_filter_show_filter(struct dp_mon_pdev *mon_pdev,
-				      enum dp_mon_filter_mode mode,
-				      struct dp_mon_filter *filter)
-{
-	struct htt_rx_ring_tlv_filter *tlv_filter = &filter->tlv_filter;
-
-	DP_MON_FILTER_PRINT("[%s]: Valid: %d",
-			    dp_mon_filter_mode_type_to_str[mode],
-			    filter->valid);
-	DP_MON_FILTER_PRINT("mpdu_start: %d", tlv_filter->mpdu_start);
-	DP_MON_FILTER_PRINT("msdu_start: %d", tlv_filter->msdu_start);
-	DP_MON_FILTER_PRINT("packet: %d", tlv_filter->packet);
-	DP_MON_FILTER_PRINT("msdu_end: %d", tlv_filter->msdu_end);
-	DP_MON_FILTER_PRINT("mpdu_end: %d", tlv_filter->mpdu_end);
-	DP_MON_FILTER_PRINT("packet_header: %d",
-			    tlv_filter->packet_header);
-	DP_MON_FILTER_PRINT("attention: %d", tlv_filter->attention);
-	DP_MON_FILTER_PRINT("ppdu_start: %d", tlv_filter->ppdu_start);
-	DP_MON_FILTER_PRINT("ppdu_end: %d", tlv_filter->ppdu_end);
-	DP_MON_FILTER_PRINT("ppdu_end_user_stats: %d",
-			    tlv_filter->ppdu_end_user_stats);
-	DP_MON_FILTER_PRINT("ppdu_end_user_stats_ext: %d",
-			    tlv_filter->ppdu_end_user_stats_ext);
-	DP_MON_FILTER_PRINT("ppdu_end_status_done: %d",
-			    tlv_filter->ppdu_end_status_done);
-	DP_MON_FILTER_PRINT("header_per_msdu: %d", tlv_filter->header_per_msdu);
-	DP_MON_FILTER_PRINT("enable_fp: %d", tlv_filter->enable_fp);
-	DP_MON_FILTER_PRINT("enable_md: %d", tlv_filter->enable_md);
-	DP_MON_FILTER_PRINT("enable_mo: %d", tlv_filter->enable_mo);
-	DP_MON_FILTER_PRINT("fp_mgmt_filter: 0x%x", tlv_filter->fp_mgmt_filter);
-	DP_MON_FILTER_PRINT("mo_mgmt_filter: 0x%x", tlv_filter->mo_mgmt_filter);
-	DP_MON_FILTER_PRINT("fp_ctrl_filter: 0x%x", tlv_filter->fp_ctrl_filter);
-	DP_MON_FILTER_PRINT("mo_ctrl_filter: 0x%x", tlv_filter->mo_ctrl_filter);
-	DP_MON_FILTER_PRINT("fp_data_filter: 0x%x", tlv_filter->fp_data_filter);
-	DP_MON_FILTER_PRINT("mo_data_filter: 0x%x", tlv_filter->mo_data_filter);
-	DP_MON_FILTER_PRINT("md_data_filter: 0x%x", tlv_filter->md_data_filter);
-	DP_MON_FILTER_PRINT("md_mgmt_filter: 0x%x", tlv_filter->md_mgmt_filter);
-	DP_MON_FILTER_PRINT("md_ctrl_filter: 0x%x", tlv_filter->md_ctrl_filter);
-}
-
-/**
- * dp_mon_ht2_rx_ring_cfg() - Send the tlv config to fw for a srng_type
- * based on target
- * @soc: DP soc handle
- * @pdev: DP pdev handle
- * @srng_type: The srng type for which filter wll be set
- * @tlv_filter: tlv filter
- */
-static QDF_STATUS
+#include <dp_types.h>
+#include <dp_htt.h>
+#include <dp_internal.h>
+#include <dp_rx_mon.h>
+#include <dp_mon_filter.h>
+#include <dp_mon.h>
+
+QDF_STATUS
 dp_mon_ht2_rx_ring_cfg(struct dp_soc *soc,
 		       struct dp_pdev *pdev,
 		       enum dp_mon_filter_srng_type srng_type,
@@ -182,270 +102,186 @@ dp_mon_ht2_rx_ring_cfg(struct dp_soc *soc,
 	return status;
 }
 
-/**
- * dp_mon_filter_ht2_setup() - Setup the filter for the Target setup
- * @soc: DP soc handle
- * @pdev: DP pdev handle
- * @srng_type: The srng type for which filter wll be set
- * @tlv_filter: tlv filter
- */
-static void dp_mon_filter_ht2_setup(struct dp_soc *soc, struct dp_pdev *pdev,
-				    enum dp_mon_filter_srng_type srng_type,
-				    struct dp_mon_filter *filter)
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+void dp_mon_filter_setup_enhanced_stats(struct dp_pdev *pdev)
 {
-	int32_t current_mode = 0;
-	struct htt_rx_ring_tlv_filter *tlv_filter = &filter->tlv_filter;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	struct dp_mon_ops *mon_ops = NULL;
 
-	/*
-	 * Loop through all the modes.
-	 */
-	for (current_mode = 0; current_mode < DP_MON_FILTER_MAX_MODE;
-						current_mode++) {
-		struct dp_mon_filter *mon_filter =
-			&mon_pdev->filter[current_mode][srng_type];
-		uint32_t src_filter = 0, dst_filter = 0;
-
-		/*
-		 * Check if the correct mode is enabled or not.
-		 */
-		if (!mon_filter->valid)
-			continue;
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_enhanced_stats)
+		mon_ops->mon_filter_setup_enhanced_stats(pdev);
+}
 
-		filter->valid = true;
-
-		/*
-		 * Set the super bit fields
-		 */
-		src_filter =
-			DP_MON_FILTER_GET(&mon_filter->tlv_filter, FILTER_TLV);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_TLV);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_TLV, dst_filter);
-
-		/*
-		 * Set the filter management filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_FP_MGMT);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_FP_MGMT);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_FP_MGMT, dst_filter);
-
-		/*
-		 * Set the monitor other management filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_MO_MGMT);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_MGMT);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_MO_MGMT, dst_filter);
-
-		/*
-		 * Set the filter pass control filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_FP_CTRL);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_FP_CTRL);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_FP_CTRL, dst_filter);
-
-		/*
-		 * Set the monitor other control filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_MO_CTRL);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_CTRL);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_MO_CTRL, dst_filter);
-
-		/*
-		 * Set the filter pass data filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_FP_DATA);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter,
-					       FILTER_FP_DATA);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter,
-				  FILTER_FP_DATA, dst_filter);
-
-		/*
-		 * Set the monitor other data filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_MO_DATA);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MO_DATA);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_MO_DATA, dst_filter);
-
-		/*
-		 * Set the monitor direct data filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_MD_DATA);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter,
-					       FILTER_MD_DATA);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter,
-				  FILTER_MD_DATA, dst_filter);
-
-		/*
-		 * Set the monitor direct management filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_MD_MGMT);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MD_MGMT);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_MD_MGMT, dst_filter);
-
-		/*
-		 * Set the monitor direct management filter.
-		 */
-		src_filter = DP_MON_FILTER_GET(&mon_filter->tlv_filter,
-					       FILTER_MD_CTRL);
-		dst_filter = DP_MON_FILTER_GET(tlv_filter, FILTER_MD_CTRL);
-		dst_filter |= src_filter;
-		DP_MON_FILTER_SET(tlv_filter, FILTER_MD_CTRL, dst_filter);
-	}
+void dp_mon_filter_reset_enhanced_stats(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
 
-	dp_mon_filter_show_filter(mon_pdev, 0, filter);
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_enhanced_stats)
+		mon_ops->mon_filter_reset_enhanced_stats(pdev);
 }
+#endif /* QCA_ENHANCED_STATS_SUPPORT */
 
-#ifdef QCA_MONITOR_PKT_SUPPORT
-/**
- * dp_mon_filter_reset_mon_srng()
- * @soc: DP SoC handle
- * @pdev: DP pdev handle
- * @mon_srng_type: Monitor srng type
- */
-static void
-dp_mon_filter_reset_mon_srng(struct dp_soc *soc, struct dp_pdev *pdev,
-			     enum dp_mon_filter_srng_type mon_srng_type)
+#ifdef QCA_MCOPY_SUPPORT
+void dp_mon_filter_setup_mcopy_mode(struct dp_pdev *pdev)
 {
-	struct htt_rx_ring_tlv_filter tlv_filter = {0};
+	struct dp_mon_ops *mon_ops = NULL;
 
-	if (dp_mon_ht2_rx_ring_cfg(soc, pdev, mon_srng_type,
-				   &tlv_filter) != QDF_STATUS_SUCCESS) {
-		dp_mon_filter_err("%pK: Monitor destinatin ring filter setting failed",
-				  soc);
-	}
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_mcopy_mode)
+		mon_ops->mon_filter_setup_mcopy_mode(pdev);
 }
-#endif
 
-#if defined(QCA_MCOPY_SUPPORT) || defined(ATH_SUPPORT_NAC_RSSI) \
-	|| defined(ATH_SUPPORT_NAC) || defined(WLAN_RX_PKT_CAPTURE_ENH)
-/**
- * dp_mon_filter_check_co_exist() - Check the co-existing of the
- * enabled modes.
- * @pdev: DP pdev handle
- *
- * Return: QDF_STATUS
- */
-static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev)
+void dp_mon_filter_reset_mcopy_mode(struct dp_pdev *pdev)
 {
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	struct dp_mon_ops *mon_ops = NULL;
 
-	/*
-	 * Check if the Rx Enhanced capture mode, monitor mode,
-	 * smart_monitor_mode and mcopy mode can co-exist together.
-	 */
-	if ((mon_pdev->rx_enh_capture_mode != CDP_RX_ENH_CAPTURE_DISABLED) &&
-	    ((mon_pdev->neighbour_peers_added && mon_pdev->mvdev) ||
-		 mon_pdev->mcopy_mode)) {
-		dp_mon_filter_err("%pK:Rx Capture mode can't exist with modes:\n"
-				  "Smart Monitor Mode:%d\n"
-				  "M_Copy Mode:%d", pdev->soc,
-				  mon_pdev->neighbour_peers_added,
-				  mon_pdev->mcopy_mode);
-		return QDF_STATUS_E_FAILURE;
-	}
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_mcopy_mode)
+		mon_ops->mon_filter_reset_mcopy_mode(pdev);
+}
+#endif /* QCA_MCOPY_SUPPORT */
 
-	/*
-	 * Check if the monitor mode cannot co-exist with any other mode.
-	 */
-	if ((mon_pdev->mvdev && mon_pdev->monitor_configured) &&
-	    (mon_pdev->mcopy_mode || mon_pdev->neighbour_peers_added)) {
-		dp_mon_filter_err("%pK: Monitor mode can't exist with modes\n"
-				  "M_Copy Mode:%d\n"
-				  "Smart Monitor Mode:%d",
-				  pdev->soc, mon_pdev->mcopy_mode,
-				  mon_pdev->neighbour_peers_added);
-		return QDF_STATUS_E_FAILURE;
-	}
+#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
+void dp_mon_filter_setup_smart_monitor(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
 
-	/*
-	 * Check if the smart monitor mode can co-exist with any other mode
-	 */
-	if (mon_pdev->neighbour_peers_added &&
-	    ((mon_pdev->mcopy_mode) || mon_pdev->monitor_configured)) {
-		dp_mon_filter_err("%pk: Smart Monitor mode can't exist with modes\n"
-				  "M_Copy Mode:%d\n"
-				  "Monitor Mode:%d",
-				  pdev->soc, mon_pdev->mcopy_mode,
-				  mon_pdev->monitor_configured);
-		return QDF_STATUS_E_FAILURE;
-	}
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_smart_monitor)
+		mon_ops->mon_filter_setup_smart_monitor(pdev);
+}
 
-	/*
-	 * Check if the m_copy, monitor mode and the smart_monitor_mode
-	 * can co-exist togther.
-	 */
-	if (mon_pdev->mcopy_mode &&
-	    (mon_pdev->mvdev || mon_pdev->neighbour_peers_added)) {
-		dp_mon_filter_err("%pK: mcopy mode can't exist with modes\n"
-				  "Monitor Mode:%pK\n"
-				  "Smart Monitor Mode:%d",
-				  pdev->soc, mon_pdev->mvdev,
-				  mon_pdev->neighbour_peers_added);
-		return QDF_STATUS_E_FAILURE;
-	}
+void dp_mon_filter_reset_smart_monitor(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
 
-	/*
-	 * Check if the Rx packet log lite or full can co-exist with
-	 * the enable modes.
-	 */
-	if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) &&
-	    !mon_pdev->rx_pktlog_cbf &&
-	    (mon_pdev->mvdev || mon_pdev->monitor_configured)) {
-		dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n"
-				  "Monitor Mode:%d", pdev->soc,
-				  mon_pdev->monitor_configured);
-		return QDF_STATUS_E_FAILURE;
-	}
-	return QDF_STATUS_SUCCESS;
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_smart_monitor)
+		mon_ops->mon_filter_reset_smart_monitor(pdev);
 }
-#else
-static QDF_STATUS dp_mon_filter_check_co_exist(struct dp_pdev *pdev)
+#endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
+
+#ifdef WLAN_RX_PKT_CAPTURE_ENH
+void dp_mon_filter_setup_rx_enh_capture(struct dp_pdev *pdev)
 {
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+	struct dp_mon_ops *mon_ops = NULL;
 
-	/*
-	 * Check if the Rx packet log lite or full can co-exist with
-	 * the enable modes.
-	 */
-	if ((mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) &&
-	    (mon_pdev->mvdev || mon_pdev->monitor_configured)) {
-		dp_mon_filter_err("%pK: Rx pktlog full/lite can't exist with modes\n"
-				  "Monitor Mode:%d", pdev->soc,
-				  mon_pdev->monitor_configured);
-		return QDF_STATUS_E_FAILURE;
-	}
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_rx_enh_capture)
+		mon_ops->mon_filter_setup_rx_enh_capture(pdev);
+}
 
-	return QDF_STATUS_SUCCESS;
+void dp_mon_filter_reset_rx_enh_capture(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_rx_enh_capture)
+		mon_ops->mon_filter_reset_rx_enh_capture(pdev);
 }
-#endif
+#endif /* WLAN_RX_PKT_CAPTURE_ENH */
 
-#ifdef QCA_MONITOR_PKT_SUPPORT
-/**
- * dp_mon_filter_set_mon_cmn() - Setp the common mon filters
- * @mon_pdev: Monitor pdev handle
- * @filter: DP mon filter
- *
- * Return: QDF_STATUS
- */
-static void dp_mon_filter_set_mon_cmn(struct dp_mon_pdev *mon_pdev,
-				      struct dp_mon_filter *filter)
+void dp_mon_filter_setup_mon_mode(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_mon_mode)
+		mon_ops->mon_filter_setup_mon_mode(pdev);
+}
+
+void dp_mon_filter_reset_mon_mode(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_mon_mode)
+		mon_ops->mon_filter_reset_mon_mode(pdev);
+}
+
+#ifdef WDI_EVENT_ENABLE
+void dp_mon_filter_setup_rx_pkt_log_full(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_rx_pkt_log_full)
+		mon_ops->mon_filter_setup_rx_pkt_log_full(pdev);
+}
+
+void dp_mon_filter_reset_rx_pkt_log_full(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_rx_pkt_log_full)
+		mon_ops->mon_filter_reset_rx_pkt_log_full(pdev);
+}
+
+void dp_mon_filter_setup_rx_pkt_log_lite(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_rx_pkt_log_lite)
+		mon_ops->mon_filter_setup_rx_pkt_log_lite(pdev);
+}
+
+void dp_mon_filter_reset_rx_pkt_log_lite(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_rx_pkt_log_lite)
+		mon_ops->mon_filter_reset_rx_pkt_log_lite(pdev);
+}
+
+void dp_mon_filter_setup_rx_pkt_log_cbf(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_setup_rx_pkt_log_cbf)
+		mon_ops->mon_filter_setup_rx_pkt_log_cbf(pdev);
+}
+
+void dp_mon_filter_reset_rx_pktlog_cbf(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_reset_rx_pkt_log_cbf)
+		mon_ops->mon_filter_reset_rx_pkt_log_cbf(pdev);
+}
+#endif /* WDI_EVENT_ENABLE */
+
+QDF_STATUS dp_mon_filter_update(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *mon_ops = NULL;
+
+	mon_ops = dp_mon_ops_get(pdev->soc);
+	if (mon_ops && mon_ops->mon_filter_update)
+		return mon_ops->mon_filter_update(pdev);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+void
+dp_mon_filter_reset_mon_srng(struct dp_soc *soc, struct dp_pdev *pdev,
+			     enum dp_mon_filter_srng_type mon_srng_type)
+{
+	struct htt_rx_ring_tlv_filter tlv_filter = {0};
+
+	if (dp_mon_ht2_rx_ring_cfg(soc, pdev, mon_srng_type,
+				   &tlv_filter) != QDF_STATUS_SUCCESS) {
+		dp_mon_filter_err("%pK: Monitor destinatin ring filter setting failed",
+				  soc);
+	}
+}
+
+void dp_mon_filter_set_mon_cmn(struct dp_mon_pdev *mon_pdev,
+			       struct dp_mon_filter *filter)
 {
 	filter->tlv_filter.mpdu_start = 1;
 	filter->tlv_filter.msdu_start = 1;
@@ -473,17 +309,9 @@ static void dp_mon_filter_set_mon_cmn(struct dp_mon_pdev *mon_pdev,
 	filter->tlv_filter.mo_data_filter = mon_pdev->mo_data_filter;
 	filter->tlv_filter.offset_valid = false;
 }
-#endif
 
-/**
- * dp_mon_filter_set_status_cmn() - Setp the common status filters
- * @mon_pdev: Monitor pdev handle
- * @filter: Dp mon filters
- *
- * Return: QDF_STATUS
- */
-static void dp_mon_filter_set_status_cmn(struct dp_mon_pdev *mon_pdev,
-					 struct dp_mon_filter *filter)
+void dp_mon_filter_set_status_cmn(struct dp_mon_pdev *mon_pdev,
+				  struct dp_mon_filter *filter)
 {
 	filter->tlv_filter.mpdu_start = 1;
 	filter->tlv_filter.msdu_start = 0;
@@ -513,15 +341,8 @@ static void dp_mon_filter_set_status_cmn(struct dp_mon_pdev *mon_pdev,
 	}
 }
 
-/**
- * dp_mon_filter_set_status_cbf() - Set the cbf status filters
- * @pdev: DP pdev handle
- * @filter: Dp mon filters
- *
- * Return: void
- */
-static void dp_mon_filter_set_status_cbf(struct dp_pdev *pdev,
-					 struct dp_mon_filter *filter)
+void dp_mon_filter_set_status_cbf(struct dp_pdev *pdev,
+				  struct dp_mon_filter *filter)
 {
 	filter->tlv_filter.mpdu_start = 1;
 	filter->tlv_filter.msdu_start = 0;
@@ -543,16 +364,8 @@ static void dp_mon_filter_set_status_cbf(struct dp_pdev *pdev,
 	filter->tlv_filter.enable_mo = 0;
 }
 
-#ifdef QCA_MONITOR_PKT_SUPPORT
-/**
- * dp_mon_filter_set_cbf_cmn() - Set the common cbf mode filters
- * @pdev: DP pdev handle
- * @filter: Dp mon filters
- *
- * Return: void
- */
-static void dp_mon_filter_set_cbf_cmn(struct dp_pdev *pdev,
-				      struct dp_mon_filter *filter)
+void dp_mon_filter_set_cbf_cmn(struct dp_pdev *pdev,
+			       struct dp_mon_filter *filter)
 {
 	filter->tlv_filter.mpdu_start = 1;
 	filter->tlv_filter.msdu_start = 1;
@@ -571,846 +384,6 @@ static void dp_mon_filter_set_cbf_cmn(struct dp_pdev *pdev,
 	filter->tlv_filter.offset_valid = false;
 	filter->tlv_filter.enable_mo = 0;
 }
-#endif
-
-#ifdef QCA_ENHANCED_STATS_SUPPORT
-/**
- * dp_mon_filter_setup_enhanced_stats() - Setup the enhanced stats filter
- * @mon_pdev: Monitor pdev handle
- */
-void dp_mon_filter_setup_enhanced_stats(struct dp_mon_pdev *mon_pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-
-	if (!mon_pdev) {
-		dp_mon_filter_err("Monitor pdev Context is null");
-		return;
-	}
-
-	/* Enabled the filter */
-	filter.valid = true;
-
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter
- * @mon_pdev: Monitor pdev handle
- */
-void dp_mon_filter_reset_enhanced_stats(struct dp_mon_pdev *mon_pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_ENHACHED_STATS_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-
-	if (!mon_pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-#endif /* QCA_ENHANCED_STATS_SUPPORT */
-
-#ifdef QCA_MCOPY_SUPPORT
-#ifdef QCA_MONITOR_PKT_SUPPORT
-static void
-dp_mon_filter_set_reset_mcopy_mon_buf(struct dp_pdev *pdev,
-				      struct dp_mon_filter *pfilter)
-{
-	struct dp_soc *soc = pdev->soc;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE;
-	enum dp_mon_filter_srng_type srng_type;
-
-	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
-
-	/* Set the filter */
-	if (pfilter->valid) {
-		dp_mon_filter_set_mon_cmn(mon_pdev, pfilter);
-
-		pfilter->tlv_filter.fp_data_filter = 0;
-		pfilter->tlv_filter.mo_data_filter = 0;
-
-		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
-		mon_pdev->filter[mode][srng_type] = *pfilter;
-	} else /* Reset the filter */
-		mon_pdev->filter[mode][srng_type] = *pfilter;
-}
-#else
-static void
-dp_mon_filter_set_reset_mcopy_mon_buf(struct dp_pdev *pdev,
-				      struct dp_mon_filter *pfilter)
-{
-}
-#endif
-
-/**
- * dp_mon_filter_setup_mcopy_mode() - Setup the m_copy mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_mcopy_mode(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	if (!mon_pdev) {
-		dp_mon_filter_err("monitor pdev Context is null");
-		return;
-	}
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_reset_mcopy_mon_buf(pdev, &filter);
-
-	/* Clear the filter as the same filter will be used to set the
-	 * monitor status ring
-	 */
-	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
-
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-
-	/* Setup the filter */
-	filter.tlv_filter.enable_mo = 1;
-	filter.tlv_filter.packet_header = 1;
-	filter.tlv_filter.mpdu_end = 1;
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_mcopy_mode() - Reset the m_copy mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_mcopy_mode(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_MCOPY_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	dp_mon_filter_set_reset_mcopy_mon_buf(pdev, &filter);
-
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-#endif /* QCA_MCOPY_SUPPORT */
-
-#if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
-/**
- * dp_mon_filter_setup_smart_monitor() - Setup the smart monitor mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_smart_monitor(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	struct dp_mon_soc *mon_soc;
-
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_soc = soc->monitor_soc;
-	mon_pdev = pdev->monitor_pdev;
-
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-
-	if (mon_soc->hw_nac_monitor_support) {
-		filter.tlv_filter.enable_md = 1;
-		filter.tlv_filter.packet_header = 1;
-		filter.tlv_filter.md_data_filter = FILTER_DATA_ALL;
-	}
-
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_smart_monitor() - Reset the smart monitor mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_smart_monitor(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_SMART_MONITOR_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("monitor pdev Context is null");
-		return;
-	}
-	mon_pdev = pdev->monitor_pdev;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-#endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
-
-#ifdef WLAN_RX_PKT_CAPTURE_ENH
-#ifdef QCA_MONITOR_PKT_SUPPORT
-static void
-dp_mon_filter_set_reset_rx_enh_capture_mon_buf(struct dp_pdev *pdev,
-					       struct dp_mon_filter *pfilter)
-{
-	struct dp_soc *soc = pdev->soc;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE;
-	enum dp_mon_filter_srng_type srng_type;
-
-	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
-
-	/* Set the filter */
-	if (pfilter->valid) {
-		dp_mon_filter_set_mon_cmn(mon_pdev, pfilter);
-
-		pfilter->tlv_filter.fp_mgmt_filter = 0;
-		pfilter->tlv_filter.fp_ctrl_filter = 0;
-		pfilter->tlv_filter.fp_data_filter = 0;
-		pfilter->tlv_filter.mo_mgmt_filter = 0;
-		pfilter->tlv_filter.mo_ctrl_filter = 0;
-		pfilter->tlv_filter.mo_data_filter = 0;
-
-		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
-		pdev->monitor_pdev->filter[mode][srng_type] = *pfilter;
-	} else /* Reset the filter */
-		pdev->monitor_pdev->filter[mode][srng_type] = *pfilter;
-}
-#else
-static void
-dp_mon_filter_set_reset_rx_enh_capture_mon_buf(struct dp_pdev *pdev,
-					       struct dp_mon_filter *pfilter)
-{
-}
-#endif
-
-/**
- * dp_mon_filter_setup_rx_enh_capture() - Setup the Rx capture mode filters
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_rx_enh_capture(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_reset_rx_enh_capture_mon_buf(pdev, &filter);
-
-	/* Clear the filter as the same filter will be used to set the
-	 * monitor status ring
-	 */
-	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
-
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-
-	/* Setup the filter */
-	filter.tlv_filter.mpdu_end = 1;
-	filter.tlv_filter.enable_mo = 1;
-	filter.tlv_filter.packet_header = 1;
-
-	if (mon_pdev->rx_enh_capture_mode == CDP_RX_ENH_CAPTURE_MPDU) {
-		filter.tlv_filter.header_per_msdu = 0;
-		filter.tlv_filter.enable_mo = 0;
-	} else if (mon_pdev->rx_enh_capture_mode ==
-			CDP_RX_ENH_CAPTURE_MPDU_MSDU) {
-		bool is_rx_mon_proto_flow_tag_enabled =
-		wlan_cfg_is_rx_mon_protocol_flow_tag_enabled(soc->wlan_cfg_ctx);
-		filter.tlv_filter.header_per_msdu = 1;
-		filter.tlv_filter.enable_mo = 0;
-		if (mon_pdev->is_rx_enh_capture_trailer_enabled ||
-		    is_rx_mon_proto_flow_tag_enabled)
-			filter.tlv_filter.msdu_end = 1;
-	}
-
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_rx_enh_capture() - Reset the Rx capture mode filters
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_rx_enh_capture(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_RX_CAPTURE_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	dp_mon_filter_set_reset_rx_enh_capture_mon_buf(pdev, &filter);
-
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-#endif /* WLAN_RX_PKT_CAPTURE_ENH */
-
-#ifdef QCA_MONITOR_PKT_SUPPORT
-static void dp_mon_filter_set_reset_mon_buf(struct dp_pdev *pdev,
-					    struct dp_mon_filter *pfilter)
-{
-	struct dp_soc *soc = pdev->soc;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE;
-	enum dp_mon_filter_srng_type srng_type;
-
-	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
-
-	/* set the filter */
-	if (pfilter->valid) {
-		dp_mon_filter_set_mon_cmn(mon_pdev, pfilter);
-
-		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
-		mon_pdev->filter[mode][srng_type] = *pfilter;
-	} else /* reset the filter */
-		mon_pdev->filter[mode][srng_type] = *pfilter;
-}
-#else
-static void dp_mon_filter_set_reset_mon_buf(struct dp_pdev *pdev,
-					    struct dp_mon_filter *pfilter)
-{
-}
-#endif
-
-/**
- * dp_mon_filter_setup_mon_mode() - Setup the Rx monitor mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_mon_mode(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	filter.valid = true;
-	dp_mon_filter_set_reset_mon_buf(pdev, &filter);
-
-	/* Clear the filter as the same filter will be used to set the
-	 * monitor status ring
-	 */
-	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
-
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-
-	/* Store the above filter */
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_mon_mode() - Reset the Rx monitor mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_mon_mode(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_MONITOR_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	dp_mon_filter_set_reset_mon_buf(pdev, &filter);
-
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-#ifdef WDI_EVENT_ENABLE
-/**
- * dp_mon_filter_setup_rx_pkt_log_full() - Setup the Rx pktlog full mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_rx_pkt_log_full(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-
-	/* Setup the filter */
-	filter.tlv_filter.packet_header = 1;
-	filter.tlv_filter.msdu_start = 1;
-	filter.tlv_filter.msdu_end = 1;
-	filter.tlv_filter.mpdu_end = 1;
-	filter.tlv_filter.attention = 1;
-
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_rx_pkt_log_full() - Reset the Rx pktlog full mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_rx_pkt_log_full(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_FULL_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_setup_rx_pkt_log_lite() - Setup the Rx pktlog lite mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_rx_pkt_log_lite(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cmn(mon_pdev, &filter);
-
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-/**
- * dp_mon_filter_reset_rx_pkt_log_lite() - Reset the Rx pktlog lite mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_rx_pkt_log_lite(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_LITE_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("dp pdev Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-
-#ifdef QCA_MONITOR_PKT_SUPPORT
-static void
-dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(struct dp_pdev *pdev,
-					       struct dp_mon_filter *pfilter)
-{
-	struct dp_soc *soc = pdev->soc;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
-	enum dp_mon_filter_srng_type srng_type;
-
-	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
-
-	/*set the filter */
-	if (pfilter->valid) {
-		dp_mon_filter_set_cbf_cmn(pdev, pfilter);
-
-		dp_mon_filter_show_filter(mon_pdev, mode, pfilter);
-		mon_pdev->filter[mode][srng_type] = *pfilter;
-	} else /* reset the filter */
-		mon_pdev->filter[mode][srng_type] = *pfilter;
-}
-#else
-static void
-dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(struct dp_pdev *pdev,
-					       struct dp_mon_filter *pfilter)
-{
-}
-#endif
-
-/**
- * dp_mon_filter_setup_rx_pkt_log_cbf() - Setup the Rx pktlog CBF mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_setup_rx_pkt_log_cbf(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return;
-	}
-
-	/* Enabled the filter */
-	filter.valid = true;
-	dp_mon_filter_set_status_cbf(pdev, &filter);
-	dp_mon_filter_show_filter(mon_pdev, mode, &filter);
-	mon_pdev->filter[mode][srng_type] = filter;
-
-	/* Clear the filter as the same filter will be used to set the
-	 * monitor status ring
-	 */
-	qdf_mem_zero(&(filter), sizeof(struct dp_mon_filter));
-
-	filter.valid = true;
-	dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(pdev, &filter);
-}
-
-/**
- * dp_mon_filter_reset_rx_pktlog_cbf() - Reset the Rx pktlog CBF mode filter
- * @pdev: DP pdev handle
- */
-void dp_mon_filter_reset_rx_pktlog_cbf(struct dp_pdev *pdev)
-{
-	struct dp_mon_filter filter = {0};
-	struct dp_soc *soc = NULL;
-	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
-	enum dp_mon_filter_srng_type srng_type =
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR,
-			  FL("pdev Context is null"));
-		return;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	soc = pdev->soc;
-	if (!soc) {
-		QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR,
-			  FL("Soc Context is null"));
-		return;
-	}
-
-	dp_mon_filter_set_reset_rx_pkt_log_cbf_mon_buf(pdev, &filter);
-
-	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
-	mon_pdev->filter[mode][srng_type] = filter;
-}
-#endif /* WDI_EVENT_ENABLE */
-
-#ifdef WLAN_DP_RESET_MON_BUF_RING_FILTER
-/**
- * dp_mon_should_reset_buf_ring_filter() - Reset the monitor buf ring filter
- * @pdev: DP PDEV handle
- *
- * WIN has targets which does not support monitor mode, but still do the
- * monitor mode init/deinit, only the rxdma1_enable flag will be set to 0.
- * MCL need to do the monitor buffer ring filter reset always, but this is
- * not needed for WIN targets where rxdma1 is not enabled (the indicator
- * that monitor mode is not enabled.
- * This function is used as WAR till WIN cleans up the monitor mode
- * function for targets where monitor mode is not enabled.
- *
- * Returns: true
- */
-static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev)
-{
-	return (pdev->monitor_pdev->mvdev) ? true : false;
-}
-#else
-static inline bool dp_mon_should_reset_buf_ring_filter(struct dp_pdev *pdev)
-{
-	return false;
-}
-#endif
-
-#ifdef QCA_MONITOR_PKT_SUPPORT
-static QDF_STATUS dp_mon_filter_mon_buf_update(struct dp_pdev *pdev,
-					       struct dp_mon_filter *pfilter,
-					       bool *pmon_mode_set)
-{
-	struct dp_soc *soc = pdev->soc;
-	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
-	enum dp_mon_filter_srng_type srng_type;
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
-
-	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
-
-	dp_mon_filter_ht2_setup(soc, pdev, srng_type, pfilter);
-
-	*pmon_mode_set = pfilter->valid;
-	if (dp_mon_should_reset_buf_ring_filter(pdev) || *pmon_mode_set) {
-		status = dp_mon_ht2_rx_ring_cfg(soc, pdev,
-						srng_type,
-						&pfilter->tlv_filter);
-	} else {
-		/*
-		 * For WIN case the monitor buffer ring is used and it does need
-		 * reset when monitor mode gets enabled/disabled.
-		 */
-		if (soc->wlan_cfg_ctx->rxdma1_enable) {
-			if (mon_pdev->monitor_configured || *pmon_mode_set) {
-				status = dp_mon_ht2_rx_ring_cfg(soc, pdev,
-								srng_type,
-								&pfilter->tlv_filter);
-			}
-		}
-	}
-
-	return status;
-}
-
-static void dp_mon_filter_mon_buf_reset(struct dp_pdev *pdev)
-{
-	struct dp_soc *soc = pdev->soc;
-	enum dp_mon_filter_srng_type srng_type;
-
-	srng_type = ((soc->wlan_cfg_ctx->rxdma1_enable) ?
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_MON_BUF :
-			DP_MON_FILTER_SRNG_TYPE_RXDMA_BUF);
-
-	dp_mon_filter_reset_mon_srng(soc, pdev, srng_type);
-}
-#else
-static QDF_STATUS dp_mon_filter_mon_buf_update(struct dp_pdev *pdev,
-					       struct dp_mon_filter *pfilter,
-					       bool *pmon_mode_set)
-{
-	return QDF_STATUS_SUCCESS;
-}
-
-static void dp_mon_filter_mon_buf_reset(struct dp_pdev *pdev)
-{
-}
-#endif
-
-/**
- * dp_mon_filter_update() - Setup the monitor filter setting for a srng
- * type
- * @pdev: DP pdev handle
- *
- * Return: QDF_STATUS
- */
-QDF_STATUS dp_mon_filter_update(struct dp_pdev *pdev)
-{
-	struct dp_soc *soc;
-	bool mon_mode_set = false;
-	struct dp_mon_filter filter = {0};
-	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	struct dp_mon_pdev *mon_pdev;
-
-	if (!pdev) {
-		dp_mon_filter_err("pdev Context is null");
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	mon_pdev = pdev->monitor_pdev;
-	soc = pdev->soc;
-	if (!soc) {
-		dp_mon_filter_err("Soc Context is null");
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	status = dp_mon_filter_check_co_exist(pdev);
-	if (status != QDF_STATUS_SUCCESS)
-		return status;
-
-	if (soc->monitor_soc->monitor_mode_v2) {
-		dp_mon_filter_err(" Mon ring not supported for this arch");
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	/*
-	 * Setup the filters for the monitor destination ring.
-	 */
-	status = dp_mon_filter_mon_buf_update(pdev, &filter,
-					      &mon_mode_set);
-
-	if (status != QDF_STATUS_SUCCESS) {
-		dp_mon_filter_err("%pK: Monitor destination ring filter setting failed",
-				  soc);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	/*
-	 * Setup the filters for the status ring.
-	 */
-	qdf_mem_zero(&(filter), sizeof(filter));
-	dp_mon_filter_ht2_setup(soc, pdev,
-				DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS,
-				&filter);
-
-	/*
-	 * Reset the monitor filters if the all the modes for the status rings
-	 * are disabled. This is done to prevent the HW backpressure from the
-	 * monitor destination ring in case the status ring filters
-	 * are not enabled.
-	 */
-	if (!filter.valid && mon_mode_set)
-		dp_mon_filter_mon_buf_reset(pdev);
-
-	if (dp_mon_ht2_rx_ring_cfg(soc, pdev,
-				   DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS,
-				   &filter.tlv_filter) != QDF_STATUS_SUCCESS) {
-		dp_mon_filter_err("%pK: Monitor status ring filter setting failed",
-				  soc);
-		dp_mon_filter_mon_buf_reset(pdev);
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	return status;
-}
 
 /**
  * dp_mon_filter_dealloc() - Deallocate the filter objects to be stored in

dp/wifi3.0/monitor/dp_mon_filter.h

@@ -19,50 +19,6 @@
 #ifndef _DP_MON_FILTER_H_
 #define _DP_MON_FILTER_H_
 
-/**
- * Accessor Macros to access the software
- * defined HTT filter htt_rx_ring_tlv_filter.
- */
-#define DP_MON_FILTER_TLV_OFFSET                      0x00000000
-#define DP_MON_FILTER_TLV_MASK                        0xffffffff
-#define DP_MON_FILTER_TLV_LSB                         0
-
-#define DP_MON_FILTER_FP_MGMT_OFFSET                  0x00000004
-#define DP_MON_FILTER_FP_MGMT_MASK                    0x0000ffff
-#define DP_MON_FILTER_FP_MGMT_LSB                     0
-
-#define DP_MON_FILTER_MO_MGMT_OFFSET                  0x00000004
-#define DP_MON_FILTER_MO_MGMT_MASK                    0xffff0000
-#define DP_MON_FILTER_MO_MGMT_LSB                     16
-
-#define DP_MON_FILTER_FP_CTRL_OFFSET                  0x00000008
-#define DP_MON_FILTER_FP_CTRL_MASK                    0x0000ffff
-#define DP_MON_FILTER_FP_CTRL_LSB                     0
-
-#define DP_MON_FILTER_MO_CTRL_OFFSET                  0x00000008
-#define DP_MON_FILTER_MO_CTRL_MASK                    0xffff0000
-#define DP_MON_FILTER_MO_CTRL_LSB                     16
-
-#define DP_MON_FILTER_FP_DATA_OFFSET                  0x0000000c
-#define DP_MON_FILTER_FP_DATA_MASK                    0x0000ffff
-#define DP_MON_FILTER_FP_DATA_LSB                     0
-
-#define DP_MON_FILTER_MO_DATA_OFFSET                  0x0000000c
-#define DP_MON_FILTER_MO_DATA_MASK                    0xffff0000
-#define DP_MON_FILTER_MO_DATA_LSB                     16
-
-#define DP_MON_FILTER_MD_DATA_OFFSET                  0x00000010
-#define DP_MON_FILTER_MD_DATA_MASK                    0x0000ffff
-#define DP_MON_FILTER_MD_DATA_LSB                     0
-
-#define DP_MON_FILTER_MD_MGMT_OFFSET                  0x00000010
-#define DP_MON_FILTER_MD_MGMT_MASK                    0xffff0000
-#define DP_MON_FILTER_MD_MGMT_LSB                     16
-
-#define DP_MON_FILTER_MD_CTRL_OFFSET                  0x00000014
-#define DP_MON_FILTER_MD_CTRL_MASK                    0x0000ffff
-#define DP_MON_FILTER_MD_CTRL_LSB                     0
-
 #define DP_MON_FILTER_GET(src, field) \
 	((*((uint32_t *)((uint8_t *)(src) + DP_MON_ ## field ## _OFFSET)) & \
 	(DP_MON_ ## field ## _MASK)) >> DP_MON_ ## field ## _LSB) \
@@ -157,15 +113,15 @@ enum dp_mon_filter_action {
 #ifdef QCA_ENHANCED_STATS_SUPPORT
 /**
  * dp_mon_filter_setup_enhanced_stats() - Setup the enhanced stats filter
- * @mon_pdev: Monitor pdev handle
+ * @pdev: DP pdev handle
  */
-void dp_mon_filter_setup_enhanced_stats(struct dp_mon_pdev *mon_pdev);
+void dp_mon_filter_setup_enhanced_stats(struct dp_pdev *pdev);
 
 /***
  * dp_mon_filter_reset_enhanced_stats() - Reset the enhanced stats filter
- * @mon_pdev: Monitor pdev handle
+ * @pdev: DP pdev handle
  */
-void dp_mon_filter_reset_enhanced_stats(struct dp_mon_pdev *mon_pdev);
+void dp_mon_filter_reset_enhanced_stats(struct dp_pdev *pdev);
 #endif /* QCA_ENHANCED_STATS_SUPPORT */
 
 #ifdef QCA_MCOPY_SUPPORT
@@ -262,6 +218,16 @@ void dp_mon_filter_setup_rx_pkt_log_cbf(struct dp_pdev *pdev);
 void dp_mon_filter_reset_rx_pktlog_cbf(struct dp_pdev *pdev);
 #endif /* WDI_EVENT_ENABLE */
 
+/**
+ * dp_mon_filter_set_status_cbf() - Set the cbf status filters
+ * @pdev: DP pdev handle
+ * @filter: Dp mon filters
+ *
+ * Return: void
+ */
+void dp_mon_filter_set_status_cbf(struct dp_pdev *pdev,
+				  struct dp_mon_filter *filter);
+
 /**
  * dp_mon_filter_update() - Setup the monitor filter setting for a srng
  * type
@@ -284,4 +250,104 @@ void dp_mon_filter_dealloc(struct dp_mon_pdev *mon_pdev);
  * @mon_pdev: monitor pdev handle
  */
 struct dp_mon_filter  **dp_mon_filter_alloc(struct dp_mon_pdev *mon_pdev);
+
+/**
+ * dp_mon_filter_show_filter() - Show the set filters
+ * @pdev: DP pdev handle
+ * @mode: The filter modes
+ * @tlv_filter: tlv filter
+ */
+void dp_mon_filter_show_filter(struct dp_mon_pdev *mon_pdev,
+			       enum dp_mon_filter_mode mode,
+			       struct dp_mon_filter *filter);
+
+/**
+ * dp_mon_ht2_rx_ring_cfg() - Send the tlv config to fw for a srng_type
+ * based on target
+ * @soc: DP soc handle
+ * @pdev: DP pdev handle
+ * @srng_type: The srng type for which filter wll be set
+ * @tlv_filter: tlv filter
+ */
+QDF_STATUS
+dp_mon_ht2_rx_ring_cfg(struct dp_soc *soc,
+		       struct dp_pdev *pdev,
+		       enum dp_mon_filter_srng_type srng_type,
+		       struct htt_rx_ring_tlv_filter *tlv_filter);
+
+/**
+ * dp_mon_filter_reset_mon_srng()
+ * @soc: DP SoC handle
+ * @pdev: DP pdev handle
+ * @mon_srng_type: Monitor srng type
+ */
+void
+dp_mon_filter_reset_mon_srng(struct dp_soc *soc, struct dp_pdev *pdev,
+			     enum dp_mon_filter_srng_type mon_srng_type);
+
+/**
+ * dp_mon_filter_set_mon_cmn() - Setp the common mon filters
+ * @pdev: DP pdev handle
+ * @filter: DP mon filter
+ *
+ * Return: QDF_STATUS
+ */
+void dp_mon_filter_set_mon_cmn(struct dp_mon_pdev *mon_pdev,
+			       struct dp_mon_filter *filter);
+
+/**
+ * dp_mon_filter_set_status_cmn() - Setp the common status filters
+ * @pdev: DP pdev handle
+ * @filter: Dp mon filters
+ *
+ * Return: QDF_STATUS
+ */
+void dp_mon_filter_set_status_cmn(struct dp_mon_pdev *mon_pdev,
+				  struct dp_mon_filter *filter);
+
+/**
+ * dp_mon_filter_setup_mon_mode() - Setup the Rx monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_setup_mon_mode(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_reset_mon_mode() - Reset the Rx monitor mode filter
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_reset_mon_mode(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_set_cbf_cmn() - Set the common cbf mode filters
+ * @pdev: DP pdev handle
+ * @filter: Dp mon filters
+ *
+ * Return: void
+ */
+void dp_mon_filter_set_cbf_cmn(struct dp_pdev *pdev,
+			       struct dp_mon_filter *filter);
+
+/**
+ * dp_mon_filter_update() - Setup the monitor filter setting for a srng
+ * type
+ * @pdev: DP pdev handle
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS dp_mon_filter_update(struct dp_pdev *pdev);
+
+/**
+ * dp_mon_filter_dealloc() - Deallocate the filter objects to be stored in
+ * the radio object.
+ * @pdev: DP pdev handle
+ */
+void dp_mon_filter_dealloc(struct dp_mon_pdev *mon_pdev);
+
+/**
+ * dp_mon_filter_alloc() - Allocate the filter objects to be stored in
+ * the radio object.
+ * @mon_pdev: DP pdev handle
+ */
+struct dp_mon_filter **dp_mon_filter_alloc(struct dp_mon_pdev *mon_pdev);
+
 #endif /* #ifndef _DP_MON_FILTER_H_ */

dp/wifi3.0/monitor/dp_rx_mon.c

@@ -15,3 +15,1507 @@
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  * PERFORMANCE OF THIS SOFTWARE.
  */
+
+#include "hal_hw_headers.h"
+#include "dp_types.h"
+#include "dp_rx.h"
+#include "dp_peer.h"
+#include "hal_rx.h"
+#include "hal_api.h"
+#include "qdf_trace.h"
+#include "qdf_nbuf.h"
+#include "hal_api_mon.h"
+#include "dp_internal.h"
+#include "qdf_mem.h"   /* qdf_mem_malloc,free */
+#include "dp_htt.h"
+#include "dp_mon.h"
+#include "dp_rx_mon.h"
+
+#include "htt.h"
+#ifdef FEATURE_PERPKT_INFO
+#include "dp_ratetable.h"
+#endif
+
+#if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
+void
+dp_rx_mon_handle_cfr_mu_info(struct dp_pdev *pdev,
+			     struct hal_rx_ppdu_info *ppdu_info,
+			     struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	struct dp_peer *peer;
+	struct dp_soc *soc = pdev->soc;
+	struct dp_ast_entry *ast_entry;
+	struct mon_rx_user_status *rx_user_status;
+	struct cdp_rx_stats_ppdu_user *rx_stats_peruser;
+	uint32_t num_users;
+	int user_id;
+	uint32_t ast_index;
+
+	qdf_spin_lock_bh(&soc->ast_lock);
+
+	num_users = ppdu_info->com_info.num_users;
+	for (user_id = 0; user_id < num_users; user_id++) {
+		if (user_id > OFDMA_NUM_USERS) {
+			qdf_spin_unlock_bh(&soc->ast_lock);
+			return;
+		}
+
+		rx_user_status =  &ppdu_info->rx_user_status[user_id];
+		rx_stats_peruser = &cdp_rx_ppdu->user[user_id];
+		ast_index = rx_user_status->ast_index;
+
+		if (ast_index >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
+			rx_stats_peruser->peer_id = HTT_INVALID_PEER;
+			continue;
+		}
+
+		ast_entry = soc->ast_table[ast_index];
+		if (!ast_entry || ast_entry->peer_id == HTT_INVALID_PEER) {
+			rx_stats_peruser->peer_id = HTT_INVALID_PEER;
+			continue;
+		}
+
+		peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
+					     DP_MOD_ID_RX_PPDU_STATS);
+		if (!peer) {
+			rx_stats_peruser->peer_id = HTT_INVALID_PEER;
+			continue;
+		}
+
+		qdf_mem_copy(rx_stats_peruser->mac_addr,
+			     peer->mac_addr.raw, QDF_MAC_ADDR_SIZE);
+		dp_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS);
+	}
+
+	qdf_spin_unlock_bh(&soc->ast_lock);
+}
+
+void
+dp_rx_mon_populate_cfr_ppdu_info(struct dp_pdev *pdev,
+				 struct hal_rx_ppdu_info *ppdu_info,
+				 struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	int chain;
+
+	cdp_rx_ppdu->ppdu_id = ppdu_info->com_info.ppdu_id;
+	cdp_rx_ppdu->timestamp = ppdu_info->rx_status.tsft;
+	cdp_rx_ppdu->u.ppdu_type = ppdu_info->rx_status.reception_type;
+	cdp_rx_ppdu->num_users = ppdu_info->com_info.num_users;
+
+	for (chain = 0; chain < MAX_CHAIN; chain++)
+		cdp_rx_ppdu->per_chain_rssi[chain] =
+			ppdu_info->rx_status.rssi[chain];
+
+	cdp_rx_ppdu->u.ltf_size = ppdu_info->rx_status.ltf_size;
+	cdp_rx_ppdu->beamformed = ppdu_info->rx_status.beamformed;
+	cdp_rx_ppdu->u.ldpc = ppdu_info->rx_status.ldpc;
+
+	if (ppdu_info->rx_status.preamble_type == HAL_RX_PKT_TYPE_11AC) {
+		cdp_rx_ppdu->u.stbc = ppdu_info->rx_status.is_stbc;
+	} else if (ppdu_info->rx_status.preamble_type ==
+			HAL_RX_PKT_TYPE_11AX) {
+		cdp_rx_ppdu->u.stbc = (ppdu_info->rx_status.he_data3 >>
+				       QDF_MON_STATUS_STBC_SHIFT) & 0x1;
+		cdp_rx_ppdu->u.dcm = (ppdu_info->rx_status.he_data3 >>
+				      QDF_MON_STATUS_DCM_SHIFT) & 0x1;
+	}
+
+	dp_rx_mon_handle_cfr_mu_info(pdev, ppdu_info, cdp_rx_ppdu);
+}
+
+bool
+dp_cfr_rcc_mode_status(struct dp_pdev *pdev)
+{
+	return pdev->cfr_rcc_mode;
+}
+
+void
+dp_rx_mon_populate_cfr_info(struct dp_pdev *pdev,
+			    struct hal_rx_ppdu_info *ppdu_info,
+			    struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	struct cdp_rx_ppdu_cfr_info *cfr_info;
+
+	if (!dp_cfr_rcc_mode_status(pdev))
+		return;
+
+	cfr_info = &cdp_rx_ppdu->cfr_info;
+
+	cfr_info->bb_captured_channel
+		= ppdu_info->cfr_info.bb_captured_channel;
+	cfr_info->bb_captured_timeout
+		= ppdu_info->cfr_info.bb_captured_timeout;
+	cfr_info->bb_captured_reason
+		= ppdu_info->cfr_info.bb_captured_reason;
+	cfr_info->rx_location_info_valid
+		= ppdu_info->cfr_info.rx_location_info_valid;
+	cfr_info->chan_capture_status
+		= ppdu_info->cfr_info.chan_capture_status;
+	cfr_info->rtt_che_buffer_pointer_high8
+		= ppdu_info->cfr_info.rtt_che_buffer_pointer_high8;
+	cfr_info->rtt_che_buffer_pointer_low32
+		= ppdu_info->cfr_info.rtt_che_buffer_pointer_low32;
+	cfr_info->rtt_cfo_measurement
+		= (int16_t)ppdu_info->cfr_info.rtt_cfo_measurement;
+	cfr_info->agc_gain_info0
+		= ppdu_info->cfr_info.agc_gain_info0;
+	cfr_info->agc_gain_info1
+		= ppdu_info->cfr_info.agc_gain_info1;
+	cfr_info->agc_gain_info2
+		= ppdu_info->cfr_info.agc_gain_info2;
+	cfr_info->agc_gain_info3
+		= ppdu_info->cfr_info.agc_gain_info3;
+	cfr_info->rx_start_ts
+		= ppdu_info->cfr_info.rx_start_ts;
+	cfr_info->mcs_rate
+		= ppdu_info->cfr_info.mcs_rate;
+	cfr_info->gi_type
+		= ppdu_info->cfr_info.gi_type;
+}
+
+void
+dp_update_cfr_dbg_stats(struct dp_pdev *pdev,
+			struct hal_rx_ppdu_info *ppdu_info)
+{
+	struct hal_rx_ppdu_cfr_info *cfr = &ppdu_info->cfr_info;
+
+	DP_STATS_INC(pdev,
+		     rcc.chan_capture_status[cfr->chan_capture_status], 1);
+	if (cfr->rx_location_info_valid) {
+		DP_STATS_INC(pdev, rcc.rx_loc_info_valid_cnt, 1);
+		if (cfr->bb_captured_channel) {
+			DP_STATS_INC(pdev, rcc.bb_captured_channel_cnt, 1);
+			DP_STATS_INC(pdev,
+				     rcc.reason_cnt[cfr->bb_captured_reason],
+				     1);
+		} else if (cfr->bb_captured_timeout) {
+			DP_STATS_INC(pdev, rcc.bb_captured_timeout_cnt, 1);
+			DP_STATS_INC(pdev,
+				     rcc.reason_cnt[cfr->bb_captured_reason],
+				     1);
+		}
+	}
+}
+
+void
+dp_rx_handle_cfr(struct dp_soc *soc, struct dp_pdev *pdev,
+		 struct hal_rx_ppdu_info *ppdu_info)
+{
+	qdf_nbuf_t ppdu_nbuf;
+	struct cdp_rx_indication_ppdu *cdp_rx_ppdu;
+
+	dp_update_cfr_dbg_stats(pdev, ppdu_info);
+	if (!ppdu_info->cfr_info.bb_captured_channel)
+		return;
+
+	ppdu_nbuf = qdf_nbuf_alloc(soc->osdev,
+				   sizeof(struct cdp_rx_indication_ppdu),
+				   0,
+				   0,
+				   FALSE);
+	if (ppdu_nbuf) {
+		cdp_rx_ppdu = (struct cdp_rx_indication_ppdu *)ppdu_nbuf->data;
+
+		dp_rx_mon_populate_cfr_info(pdev, ppdu_info, cdp_rx_ppdu);
+		dp_rx_mon_populate_cfr_ppdu_info(pdev, ppdu_info, cdp_rx_ppdu);
+		qdf_nbuf_put_tail(ppdu_nbuf,
+				  sizeof(struct cdp_rx_indication_ppdu));
+		dp_wdi_event_handler(WDI_EVENT_RX_PPDU_DESC, soc,
+				     ppdu_nbuf, HTT_INVALID_PEER,
+				     WDI_NO_VAL, pdev->pdev_id);
+	}
+}
+
+void
+dp_rx_populate_cfr_non_assoc_sta(struct dp_pdev *pdev,
+				 struct hal_rx_ppdu_info *ppdu_info,
+				 struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	if (!dp_cfr_rcc_mode_status(pdev))
+		return;
+
+	if (ppdu_info->cfr_info.bb_captured_channel)
+		dp_rx_mon_populate_cfr_ppdu_info(pdev, ppdu_info, cdp_rx_ppdu);
+}
+
+/**
+ * dp_bb_captured_chan_status() - Get the bb_captured_channel status
+ * @ppdu_info: structure for rx ppdu ring
+ *
+ * Return: Success/ Failure
+ */
+static inline QDF_STATUS
+dp_bb_captured_chan_status(struct dp_pdev *pdev,
+			   struct hal_rx_ppdu_info *ppdu_info)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct hal_rx_ppdu_cfr_info *cfr = &ppdu_info->cfr_info;
+
+	if (dp_cfr_rcc_mode_status(pdev)) {
+		if (cfr->bb_captured_channel)
+			status = QDF_STATUS_SUCCESS;
+	}
+
+	return status;
+}
+#else
+static inline QDF_STATUS
+dp_bb_captured_chan_status(struct dp_pdev *pdev,
+			   struct hal_rx_ppdu_info *ppdu_info)
+{
+	return QDF_STATUS_E_NOSUPPORT;
+}
+#endif /* WLAN_CFR_ENABLE */
+
+#ifdef QCA_ENHANCED_STATS_SUPPORT
+void
+dp_rx_populate_rx_rssi_chain(struct hal_rx_ppdu_info *ppdu_info,
+			     struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	uint8_t chain, bw;
+	int8_t rssi;
+
+	for (chain = 0; chain < SS_COUNT; chain++) {
+		for (bw = 0; bw < MAX_BW; bw++) {
+			rssi = ppdu_info->rx_status.rssi_chain[chain][bw];
+			if (rssi != DP_RSSI_INVAL)
+				cdp_rx_ppdu->rssi_chain[chain][bw] = rssi;
+			else
+				cdp_rx_ppdu->rssi_chain[chain][bw] = 0;
+		}
+	}
+}
+
+void
+dp_rx_populate_su_evm_details(struct hal_rx_ppdu_info *ppdu_info,
+			      struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	uint8_t pilot_evm;
+	uint8_t nss_count;
+	uint8_t pilot_count;
+
+	nss_count = ppdu_info->evm_info.nss_count;
+	pilot_count = ppdu_info->evm_info.pilot_count;
+
+	if ((nss_count * pilot_count) > DP_RX_MAX_SU_EVM_COUNT) {
+		qdf_err("pilot evm count is more than expected");
+		return;
+	}
+	cdp_rx_ppdu->evm_info.pilot_count = pilot_count;
+	cdp_rx_ppdu->evm_info.nss_count = nss_count;
+
+	/* Populate evm for pilot_evm  = nss_count*pilot_count */
+	for (pilot_evm = 0; pilot_evm < nss_count * pilot_count; pilot_evm++) {
+		cdp_rx_ppdu->evm_info.pilot_evm[pilot_evm] =
+			ppdu_info->evm_info.pilot_evm[pilot_evm];
+	}
+}
+
+/**
+ * dp_rx_inc_rusize_cnt() - increment pdev stats based on RU size
+ * @pdev: pdev ctx
+ * @rx_user_status: mon rx user status
+ *
+ * Return: bool
+ */
+static inline bool
+dp_rx_inc_rusize_cnt(struct dp_pdev *pdev,
+		     struct mon_rx_user_status *rx_user_status)
+{
+	uint32_t ru_size;
+	bool is_data;
+
+	ru_size = rx_user_status->ofdma_ru_size;
+
+	if (dp_is_subtype_data(rx_user_status->frame_control)) {
+		DP_STATS_INC(pdev,
+			     ul_ofdma.data_rx_ru_size[ru_size], 1);
+		is_data = true;
+	} else {
+		DP_STATS_INC(pdev,
+			     ul_ofdma.nondata_rx_ru_size[ru_size], 1);
+		is_data = false;
+	}
+
+	return is_data;
+}
+
+/**
+ * dp_rx_populate_cdp_indication_ppdu_user() - Populate per user cdp indication
+ * @pdev: pdev ctx
+ * @ppdu_info: ppdu info structure from ppdu ring
+ * @cdp_rx_ppdu: Rx PPDU indication structure
+ *
+ * Return: none
+ */
+static void
+dp_rx_populate_cdp_indication_ppdu_user(struct dp_pdev *pdev,
+					struct hal_rx_ppdu_info *ppdu_info,
+					struct cdp_rx_indication_ppdu
+					*cdp_rx_ppdu)
+{
+	struct dp_peer *peer;
+	struct dp_soc *soc = pdev->soc;
+	struct dp_ast_entry *ast_entry;
+	uint32_t ast_index;
+	int i;
+	struct mon_rx_user_status *rx_user_status;
+	struct mon_rx_user_info *rx_user_info;
+	struct cdp_rx_stats_ppdu_user *rx_stats_peruser;
+	int ru_size;
+	bool is_data = false;
+	uint32_t num_users;
+
+	num_users = ppdu_info->com_info.num_users;
+	for (i = 0; i < num_users; i++) {
+		if (i > OFDMA_NUM_USERS)
+			return;
+
+		rx_user_status =  &ppdu_info->rx_user_status[i];
+		rx_user_info = &ppdu_info->rx_user_info[i];
+		rx_stats_peruser = &cdp_rx_ppdu->user[i];
+
+		ast_index = rx_user_status->ast_index;
+		if (ast_index >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
+			rx_stats_peruser->peer_id = HTT_INVALID_PEER;
+			continue;
+		}
+
+		ast_entry = soc->ast_table[ast_index];
+		if (!ast_entry || ast_entry->peer_id == HTT_INVALID_PEER) {
+			rx_stats_peruser->peer_id = HTT_INVALID_PEER;
+			continue;
+		}
+
+		peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
+					     DP_MOD_ID_RX_PPDU_STATS);
+		if (!peer) {
+			rx_stats_peruser->peer_id = HTT_INVALID_PEER;
+			continue;
+		}
+		rx_stats_peruser->is_bss_peer = peer->bss_peer;
+
+		rx_stats_peruser->first_data_seq_ctrl =
+			rx_user_status->first_data_seq_ctrl;
+
+		rx_stats_peruser->frame_control_info_valid =
+			rx_user_status->frame_control_info_valid;
+		rx_stats_peruser->frame_control =
+			rx_user_status->frame_control;
+
+		rx_stats_peruser->qos_control_info_valid =
+			rx_user_info->qos_control_info_valid;
+		rx_stats_peruser->qos_control =
+			rx_user_info->qos_control;
+		rx_stats_peruser->tcp_msdu_count =
+			rx_user_status->tcp_msdu_count;
+		rx_stats_peruser->udp_msdu_count =
+			rx_user_status->udp_msdu_count;
+		rx_stats_peruser->other_msdu_count =
+			rx_user_status->other_msdu_count;
+
+		rx_stats_peruser->num_msdu =
+			rx_stats_peruser->tcp_msdu_count +
+			rx_stats_peruser->udp_msdu_count +
+			rx_stats_peruser->other_msdu_count;
+
+		rx_stats_peruser->preamble_type =
+			rx_user_status->preamble_type;
+		rx_stats_peruser->mpdu_cnt_fcs_ok =
+			rx_user_status->mpdu_cnt_fcs_ok;
+		rx_stats_peruser->mpdu_cnt_fcs_err =
+			rx_user_status->mpdu_cnt_fcs_err;
+		qdf_mem_copy(&rx_stats_peruser->mpdu_fcs_ok_bitmap,
+			     &rx_user_status->mpdu_fcs_ok_bitmap,
+			     HAL_RX_NUM_WORDS_PER_PPDU_BITMAP *
+			     sizeof(rx_user_status->mpdu_fcs_ok_bitmap[0]));
+		rx_stats_peruser->mpdu_ok_byte_count =
+			rx_user_status->mpdu_ok_byte_count;
+		rx_stats_peruser->mpdu_err_byte_count =
+			rx_user_status->mpdu_err_byte_count;
+
+		cdp_rx_ppdu->num_mpdu += rx_user_status->mpdu_cnt_fcs_ok;
+		cdp_rx_ppdu->num_msdu += rx_stats_peruser->num_msdu;
+		rx_stats_peruser->retries =
+			CDP_FC_IS_RETRY_SET(rx_stats_peruser->frame_control) ?
+			rx_stats_peruser->mpdu_cnt_fcs_ok : 0;
+
+		if (rx_stats_peruser->mpdu_cnt_fcs_ok > 1)
+			rx_stats_peruser->is_ampdu = 1;
+		else
+			rx_stats_peruser->is_ampdu = 0;
+
+		rx_stats_peruser->tid = ppdu_info->rx_status.tid;
+
+		qdf_mem_copy(rx_stats_peruser->mac_addr,
+			     peer->mac_addr.raw, QDF_MAC_ADDR_SIZE);
+		rx_stats_peruser->peer_id = peer->peer_id;
+		cdp_rx_ppdu->vdev_id = peer->vdev->vdev_id;
+		rx_stats_peruser->vdev_id = peer->vdev->vdev_id;
+		rx_stats_peruser->mu_ul_info_valid = 0;
+
+		dp_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS);
+		if (cdp_rx_ppdu->u.ppdu_type == HAL_RX_TYPE_MU_OFDMA ||
+		    cdp_rx_ppdu->u.ppdu_type == HAL_RX_TYPE_MU_MIMO) {
+			if (rx_user_status->mu_ul_info_valid) {
+				rx_stats_peruser->nss = rx_user_status->nss;
+				rx_stats_peruser->mcs = rx_user_status->mcs;
+				rx_stats_peruser->mu_ul_info_valid =
+					rx_user_status->mu_ul_info_valid;
+				rx_stats_peruser->ofdma_ru_start_index =
+					rx_user_status->ofdma_ru_start_index;
+				rx_stats_peruser->ofdma_ru_width =
+					rx_user_status->ofdma_ru_width;
+				rx_stats_peruser->user_index = i;
+				ru_size = rx_user_status->ofdma_ru_size;
+				/*
+				 * max RU size will be equal to
+				 * HTT_UL_OFDMA_V0_RU_SIZE_RU_996x2
+				 */
+				if (ru_size >= OFDMA_NUM_RU_SIZE) {
+					dp_err("invalid ru_size %d\n",
+					       ru_size);
+					return;
+				}
+				is_data = dp_rx_inc_rusize_cnt(pdev,
+							       rx_user_status);
+			}
+			if (is_data) {
+				/* counter to get number of MU OFDMA */
+				pdev->stats.ul_ofdma.data_rx_ppdu++;
+				pdev->stats.ul_ofdma.data_users[num_users]++;
+			}
+		}
+	}
+}
+
+/**
+ * dp_rx_populate_cdp_indication_ppdu() - Populate cdp rx indication structure
+ * @pdev: pdev ctx
+ * @ppdu_info: ppdu info structure from ppdu ring
+ * @cdp_rx_ppdu: Rx PPDU indication structure
+ *
+ * Return: none
+ */
+static void
+dp_rx_populate_cdp_indication_ppdu(struct dp_pdev *pdev,
+				   struct hal_rx_ppdu_info *ppdu_info,
+				   struct cdp_rx_indication_ppdu *cdp_rx_ppdu)
+{
+	struct dp_peer *peer;
+	struct dp_soc *soc = pdev->soc;
+	struct dp_ast_entry *ast_entry;
+	uint32_t ast_index;
+	uint32_t i;
+
+	cdp_rx_ppdu->first_data_seq_ctrl =
+		ppdu_info->rx_status.first_data_seq_ctrl;
+	cdp_rx_ppdu->frame_ctrl =
+		ppdu_info->rx_status.frame_control;
+	cdp_rx_ppdu->tcp_msdu_count = ppdu_info->rx_status.tcp_msdu_count;
+	cdp_rx_ppdu->udp_msdu_count = ppdu_info->rx_status.udp_msdu_count;
+	cdp_rx_ppdu->other_msdu_count = ppdu_info->rx_status.other_msdu_count;
+	cdp_rx_ppdu->u.preamble = ppdu_info->rx_status.preamble_type;
+	/* num mpdu is consolidated and added together in num user loop */
+	cdp_rx_ppdu->num_mpdu = ppdu_info->com_info.mpdu_cnt_fcs_ok;
+	/* num msdu is consolidated and added together in num user loop */
+	cdp_rx_ppdu->num_msdu = (cdp_rx_ppdu->tcp_msdu_count +
+				 cdp_rx_ppdu->udp_msdu_count +
+				 cdp_rx_ppdu->other_msdu_count);
+
+	cdp_rx_ppdu->retries = CDP_FC_IS_RETRY_SET(cdp_rx_ppdu->frame_ctrl) ?
+		ppdu_info->com_info.mpdu_cnt_fcs_ok : 0;
+
+	if (ppdu_info->com_info.mpdu_cnt_fcs_ok > 1)
+		cdp_rx_ppdu->is_ampdu = 1;
+	else
+		cdp_rx_ppdu->is_ampdu = 0;
+	cdp_rx_ppdu->tid = ppdu_info->rx_status.tid;
+
+
+	ast_index = ppdu_info->rx_status.ast_index;
+	if (ast_index >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
+		cdp_rx_ppdu->peer_id = HTT_INVALID_PEER;
+		cdp_rx_ppdu->num_users = 0;
+		goto end;
+	}
+
+	ast_entry = soc->ast_table[ast_index];
+	if (!ast_entry || ast_entry->peer_id == HTT_INVALID_PEER) {
+		cdp_rx_ppdu->peer_id = HTT_INVALID_PEER;
+		cdp_rx_ppdu->num_users = 0;
+		goto end;
+	}
+	peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
+				     DP_MOD_ID_RX_PPDU_STATS);
+	if (!peer) {
+		cdp_rx_ppdu->peer_id = HTT_INVALID_PEER;
+		cdp_rx_ppdu->num_users = 0;
+		goto end;
+	}
+
+	qdf_mem_copy(cdp_rx_ppdu->mac_addr,
+		     peer->mac_addr.raw, QDF_MAC_ADDR_SIZE);
+	cdp_rx_ppdu->peer_id = peer->peer_id;
+	cdp_rx_ppdu->vdev_id = peer->vdev->vdev_id;
+
+	cdp_rx_ppdu->ppdu_id = ppdu_info->com_info.ppdu_id;
+	cdp_rx_ppdu->length = ppdu_info->rx_status.ppdu_len;
+	cdp_rx_ppdu->duration = ppdu_info->rx_status.duration;
+	cdp_rx_ppdu->u.bw = ppdu_info->rx_status.bw;
+	cdp_rx_ppdu->u.nss = ppdu_info->rx_status.nss;
+	cdp_rx_ppdu->u.mcs = ppdu_info->rx_status.mcs;
+	if ((ppdu_info->rx_status.sgi == VHT_SGI_NYSM) &&
+	    (ppdu_info->rx_status.preamble_type == HAL_RX_PKT_TYPE_11AC))
+		cdp_rx_ppdu->u.gi = CDP_SGI_0_4_US;
+	else
+		cdp_rx_ppdu->u.gi = ppdu_info->rx_status.sgi;
+	cdp_rx_ppdu->u.ldpc = ppdu_info->rx_status.ldpc;
+	cdp_rx_ppdu->u.ppdu_type = ppdu_info->rx_status.reception_type;
+	cdp_rx_ppdu->u.ltf_size = (ppdu_info->rx_status.he_data5 >>
+				   QDF_MON_STATUS_HE_LTF_SIZE_SHIFT) & 0x3;
+	cdp_rx_ppdu->rssi = ppdu_info->rx_status.rssi_comb;
+	cdp_rx_ppdu->timestamp = ppdu_info->rx_status.tsft;
+	cdp_rx_ppdu->channel = ppdu_info->rx_status.chan_num;
+	cdp_rx_ppdu->beamformed = ppdu_info->rx_status.beamformed;
+	cdp_rx_ppdu->num_bytes = ppdu_info->rx_status.ppdu_len;
+	cdp_rx_ppdu->lsig_a = ppdu_info->rx_status.rate;
+	cdp_rx_ppdu->u.ltf_size = ppdu_info->rx_status.ltf_size;
+
+	if (ppdu_info->rx_status.preamble_type == HAL_RX_PKT_TYPE_11AC) {
+		cdp_rx_ppdu->u.stbc = ppdu_info->rx_status.is_stbc;
+	} else if (ppdu_info->rx_status.preamble_type ==
+			HAL_RX_PKT_TYPE_11AX) {
+		cdp_rx_ppdu->u.stbc = (ppdu_info->rx_status.he_data3 >>
+				       QDF_MON_STATUS_STBC_SHIFT) & 0x1;
+		cdp_rx_ppdu->u.dcm = (ppdu_info->rx_status.he_data3 >>
+				      QDF_MON_STATUS_DCM_SHIFT) & 0x1;
+	}
+
+	dp_rx_populate_rx_rssi_chain(ppdu_info, cdp_rx_ppdu);
+	dp_rx_populate_su_evm_details(ppdu_info, cdp_rx_ppdu);
+	cdp_rx_ppdu->rx_antenna = ppdu_info->rx_status.rx_antenna;
+
+	cdp_rx_ppdu->nf = ppdu_info->rx_status.chan_noise_floor;
+	for (i = 0; i < MAX_CHAIN; i++)
+		cdp_rx_ppdu->per_chain_rssi[i] = ppdu_info->rx_status.rssi[i];
+
+	cdp_rx_ppdu->is_mcast_bcast = ppdu_info->nac_info.mcast_bcast;
+
+	cdp_rx_ppdu->num_users = ppdu_info->com_info.num_users;
+
+	cdp_rx_ppdu->num_mpdu = 0;
+	cdp_rx_ppdu->num_msdu = 0;
+
+	dp_rx_populate_cdp_indication_ppdu_user(pdev, ppdu_info, cdp_rx_ppdu);
+
+	dp_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS);
+
+	return;
+end:
+	dp_rx_populate_cfr_non_assoc_sta(pdev, ppdu_info, cdp_rx_ppdu);
+}
+
+/**
+ * dp_rx_stats_update() - Update per-peer statistics
+ * @soc: Datapath SOC handle
+ * @peer: Datapath peer handle
+ * @ppdu: PPDU Descriptor
+ *
+ * Return: None
+ */
+static inline void dp_rx_rate_stats_update(struct dp_peer *peer,
+					   struct cdp_rx_indication_ppdu *ppdu,
+					   uint32_t user)
+{
+	uint32_t ratekbps = 0;
+	uint32_t ppdu_rx_rate = 0;
+	uint32_t nss = 0;
+	uint8_t mcs = 0;
+	uint32_t rix;
+	uint16_t ratecode;
+	struct cdp_rx_stats_ppdu_user *ppdu_user = NULL;
+
+	if (!peer || !ppdu)
+		return;
+
+	ppdu_user = &ppdu->user[user];
+
+	if (ppdu->u.ppdu_type != HAL_RX_TYPE_SU) {
+		if (ppdu_user->nss == 0)
+			nss = 0;
+		else
+			nss = ppdu_user->nss - 1;
+		mcs = ppdu_user->mcs;
+
+	} else {
+		if (ppdu->u.nss == 0)
+			nss = 0;
+		else
+			nss = ppdu->u.nss - 1;
+		mcs = ppdu->u.mcs;
+	}
+
+	ratekbps = dp_getrateindex(ppdu->u.gi,
+				   mcs,
+				   nss,
+				   ppdu->u.preamble,
+				   ppdu->u.bw,
+				   &rix,
+				   &ratecode);
+
+	if (!ratekbps) {
+		ppdu->rix = 0;
+		ppdu->rx_ratekbps = 0;
+		ppdu->rx_ratecode = 0;
+		ppdu_user->rx_ratekbps = 0;
+		return;
+	}
+
+	ppdu->rix = rix;
+	DP_STATS_UPD(peer, rx.last_rx_rate, ratekbps);
+	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);
+	ppdu->rx_ratekbps = ratekbps;
+	ppdu->rx_ratecode = ratecode;
+	ppdu_user->rx_ratekbps = ratekbps;
+
+	if (peer->vdev)
+		peer->vdev->stats.rx.last_rx_rate = ratekbps;
+}
+
+static void dp_rx_stats_update(struct dp_pdev *pdev,
+			       struct cdp_rx_indication_ppdu *ppdu)
+{
+	struct dp_soc *soc = NULL;
+	uint8_t mcs, preamble, ac = 0, nss, ppdu_type;
+	uint16_t num_msdu;
+	uint8_t pkt_bw_offset;
+	struct dp_peer *peer;
+	struct cdp_rx_stats_ppdu_user *ppdu_user;
+	uint32_t i;
+	enum cdp_mu_packet_type mu_pkt_type;
+
+	if (pdev)
+		soc = pdev->soc;
+	else
+		return;
+
+	if (!soc || soc->process_rx_status)
+		return;
+
+	preamble = ppdu->u.preamble;
+	ppdu_type = ppdu->u.ppdu_type;
+
+	for (i = 0; i < ppdu->num_users && i < CDP_MU_MAX_USERS; i++) {
+		peer = NULL;
+		ppdu_user = &ppdu->user[i];
+		peer = dp_peer_get_ref_by_id(soc, ppdu_user->peer_id,
+					     DP_MOD_ID_RX_PPDU_STATS);
+
+		if (!peer)
+			peer = pdev->invalid_peer;
+
+		if ((preamble == DOT11_A) || (preamble == DOT11_B))
+			ppdu->u.nss = 1;
+
+		if (ppdu_type == HAL_RX_TYPE_SU) {
+			mcs = ppdu->u.mcs;
+			nss = ppdu->u.nss;
+		} else {
+			mcs = ppdu_user->mcs;
+			nss = ppdu_user->nss;
+		}
+
+		num_msdu = ppdu_user->num_msdu;
+		switch (ppdu->u.bw) {
+		case CMN_BW_20MHZ:
+			pkt_bw_offset = PKT_BW_GAIN_20MHZ;
+			break;
+		case CMN_BW_40MHZ:
+			pkt_bw_offset = PKT_BW_GAIN_40MHZ;
+			break;
+		case CMN_BW_80MHZ:
+			pkt_bw_offset = PKT_BW_GAIN_80MHZ;
+			break;
+		case CMN_BW_160MHZ:
+			pkt_bw_offset = PKT_BW_GAIN_160MHZ;
+			break;
+		default:
+			pkt_bw_offset = 0;
+			dp_rx_mon_status_debug("%pK: Invalid BW index = %d",
+					       soc, ppdu->u.bw);
+		}
+
+		DP_STATS_UPD(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);
+		else
+			CDP_SNR_UPDATE_AVG(peer->stats.rx.avg_snr,
+					   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(peer, rx.mpdu_cnt_fcs_ok,
+				     ppdu_user->mpdu_cnt_fcs_ok);
+			DP_STATS_INC(peer, rx.mpdu_cnt_fcs_err,
+				     ppdu_user->mpdu_cnt_fcs_err);
+		}
+
+		if (ppdu_type >= HAL_RX_TYPE_MU_MIMO &&
+		    ppdu_type <= HAL_RX_TYPE_MU_OFDMA) {
+			if (ppdu_type == HAL_RX_TYPE_MU_MIMO)
+				mu_pkt_type = RX_TYPE_MU_MIMO;
+			else
+				mu_pkt_type = RX_TYPE_MU_OFDMA;
+
+			if (nss) {
+				DP_STATS_INC(peer, rx.nss[nss - 1], num_msdu);
+				DP_STATS_INC(peer,
+					rx.rx_mu[mu_pkt_type].ppdu_nss[nss - 1],
+					1);
+			}
+
+			DP_STATS_INC(peer,
+				     rx.rx_mu[mu_pkt_type].mpdu_cnt_fcs_ok,
+				     ppdu_user->mpdu_cnt_fcs_ok);
+			DP_STATS_INC(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],
+			     num_msdu);
+		DP_STATS_INC(peer, rx.ppdu_cnt[ppdu->u.ppdu_type], 1);
+		DP_STATS_INCC(peer, rx.ampdu_cnt, num_msdu,
+			      ppdu_user->is_ampdu);
+		DP_STATS_INCC(peer, rx.non_ampdu_cnt, num_msdu,
+			      !(ppdu_user->is_ampdu));
+		DP_STATS_UPD(peer, rx.rx_rate, mcs);
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
+			((mcs >= MAX_MCS_11A) && (preamble == DOT11_A)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+			((mcs < MAX_MCS_11A) && (preamble == DOT11_A)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
+			((mcs >= MAX_MCS_11B) && (preamble == DOT11_B)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+			((mcs < MAX_MCS_11B) && (preamble == DOT11_B)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
+			((mcs >= MAX_MCS_11A) && (preamble == DOT11_N)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+			((mcs < MAX_MCS_11A) && (preamble == DOT11_N)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
+			((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+			((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
+			((mcs >= (MAX_MCS - 1)) && (preamble == DOT11_AX)));
+		DP_STATS_INCC(peer,
+			rx.pkt_type[preamble].mcs_count[mcs], num_msdu,
+			((mcs < (MAX_MCS - 1)) && (preamble == DOT11_AX)));
+		DP_STATS_INCC(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,
+			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,
+			rx.rx_mu[RX_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,
+			rx.rx_mu[RX_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,
+			rx.rx_mu[RX_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,
+			rx.rx_mu[RX_TYPE_MU_MIMO].ppdu.mcs_count[mcs],
+			1, ((mcs < (MAX_MCS - 1)) &&
+			(preamble == DOT11_AX) &&
+			(ppdu_type == HAL_RX_TYPE_MU_MIMO)));
+
+		/*
+		 * If invalid TID, it could be a non-qos frame, hence do not
+		 * update any AC counters
+		 */
+		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_peer_stats_notify(pdev, peer);
+		DP_STATS_UPD(peer, rx.last_snr, ppdu->rssi);
+
+		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_peer_unref_delete(peer, DP_MOD_ID_RX_PPDU_STATS);
+	}
+}
+
+void
+dp_rx_handle_ppdu_stats(struct dp_soc *soc, struct dp_pdev *pdev,
+			struct hal_rx_ppdu_info *ppdu_info)
+{
+	qdf_nbuf_t ppdu_nbuf;
+	struct cdp_rx_indication_ppdu *cdp_rx_ppdu;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	/*
+	 * Do not allocate if fcs error,
+	 * ast idx invalid / fctl invalid
+	 *
+	 * In CFR RCC mode - PPDU status TLVs of error pkts are also needed
+	 */
+	if (ppdu_info->com_info.mpdu_cnt_fcs_ok == 0)
+		return;
+
+	if (ppdu_info->nac_info.fc_valid &&
+	    ppdu_info->nac_info.to_ds_flag &&
+	    ppdu_info->nac_info.mac_addr2_valid) {
+		struct dp_neighbour_peer *peer = NULL;
+		uint8_t rssi = ppdu_info->rx_status.rssi_comb;
+
+		qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
+		if (mon_pdev->neighbour_peers_added) {
+			TAILQ_FOREACH(peer, &mon_pdev->neighbour_peers_list,
+				      neighbour_peer_list_elem) {
+				if (!qdf_mem_cmp(&peer->neighbour_peers_macaddr,
+						 &ppdu_info->nac_info.mac_addr2,
+						 QDF_MAC_ADDR_SIZE)) {
+					peer->rssi = rssi;
+					break;
+				}
+			}
+		}
+		qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
+	} else {
+		dp_info("Neighbour peers RSSI update failed! fc_valid = %d, to_ds_flag = %d and mac_addr2_valid = %d",
+			ppdu_info->nac_info.fc_valid,
+			ppdu_info->nac_info.to_ds_flag,
+			ppdu_info->nac_info.mac_addr2_valid);
+	}
+
+	/* need not generate wdi event when mcopy, cfr rcc mode and
+	 * enhanced stats are not enabled
+	 */
+	if (!mon_pdev->mcopy_mode && !mon_pdev->enhanced_stats_en &&
+	    !dp_cfr_rcc_mode_status(pdev))
+		return;
+
+	if (dp_cfr_rcc_mode_status(pdev))
+		dp_update_cfr_dbg_stats(pdev, ppdu_info);
+
+	if (!ppdu_info->rx_status.frame_control_info_valid ||
+	    (ppdu_info->rx_status.ast_index == HAL_AST_IDX_INVALID)) {
+		if (!(mon_pdev->mcopy_mode ||
+		      (dp_bb_captured_chan_status(pdev, ppdu_info) ==
+		       QDF_STATUS_SUCCESS)))
+			return;
+	}
+
+	ppdu_nbuf = qdf_nbuf_alloc(soc->osdev,
+				   sizeof(struct cdp_rx_indication_ppdu),
+				   0, 0, FALSE);
+	if (ppdu_nbuf) {
+		cdp_rx_ppdu = (struct cdp_rx_indication_ppdu *)qdf_nbuf_data(ppdu_nbuf);
+
+		qdf_mem_zero(cdp_rx_ppdu, sizeof(struct cdp_rx_indication_ppdu));
+		dp_rx_mon_populate_cfr_info(pdev, ppdu_info, cdp_rx_ppdu);
+		dp_rx_populate_cdp_indication_ppdu(pdev,
+						   ppdu_info, cdp_rx_ppdu);
+		if (!qdf_nbuf_put_tail(ppdu_nbuf,
+				       sizeof(struct cdp_rx_indication_ppdu)))
+			return;
+
+		dp_rx_stats_update(pdev, cdp_rx_ppdu);
+
+		if (cdp_rx_ppdu->peer_id != HTT_INVALID_PEER) {
+			dp_wdi_event_handler(WDI_EVENT_RX_PPDU_DESC,
+					     soc, ppdu_nbuf,
+					     cdp_rx_ppdu->peer_id,
+					     WDI_NO_VAL, pdev->pdev_id);
+		} else if (mon_pdev->mcopy_mode || dp_cfr_rcc_mode_status(pdev)) {
+			dp_wdi_event_handler(WDI_EVENT_RX_PPDU_DESC, soc,
+					     ppdu_nbuf, HTT_INVALID_PEER,
+					     WDI_NO_VAL, pdev->pdev_id);
+		} else {
+			qdf_nbuf_free(ppdu_nbuf);
+		}
+	}
+}
+#endif/* QCA_ENHANCED_STATS_SUPPORT */
+
+#ifdef QCA_MCOPY_SUPPORT
+QDF_STATUS
+dp_rx_handle_mcopy_mode(struct dp_soc *soc, struct dp_pdev *pdev,
+			struct hal_rx_ppdu_info *ppdu_info, qdf_nbuf_t nbuf,
+			uint8_t fcs_ok_mpdu_cnt, bool deliver_frame)
+{
+	uint16_t size = 0;
+	struct ieee80211_frame *wh;
+	uint32_t *nbuf_data;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (!ppdu_info->ppdu_msdu_info[fcs_ok_mpdu_cnt].first_msdu_payload)
+		return QDF_STATUS_SUCCESS;
+
+	/* For M_COPY mode only one msdu per ppdu is sent to upper layer*/
+	if (mon_pdev->mcopy_mode == M_COPY) {
+		if (mon_pdev->m_copy_id.rx_ppdu_id == ppdu_info->com_info.ppdu_id)
+			return QDF_STATUS_SUCCESS;
+	}
+
+	wh = (struct ieee80211_frame *)(ppdu_info->ppdu_msdu_info[fcs_ok_mpdu_cnt].first_msdu_payload + 4);
+
+	size = (ppdu_info->ppdu_msdu_info[fcs_ok_mpdu_cnt].first_msdu_payload -
+				qdf_nbuf_data(nbuf));
+
+	if (qdf_nbuf_pull_head(nbuf, size) == NULL)
+		return QDF_STATUS_SUCCESS;
+
+	if (((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
+	     IEEE80211_FC0_TYPE_MGT) ||
+	     ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
+	     IEEE80211_FC0_TYPE_CTL)) {
+		return QDF_STATUS_SUCCESS;
+	}
+
+	nbuf_data = (uint32_t *)qdf_nbuf_data(nbuf);
+	*nbuf_data = mon_pdev->ppdu_info.com_info.ppdu_id;
+	/* only retain RX MSDU payload in the skb */
+	qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - ppdu_info->ppdu_msdu_info[fcs_ok_mpdu_cnt].payload_len);
+	if (deliver_frame) {
+		mon_pdev->m_copy_id.rx_ppdu_id = ppdu_info->com_info.ppdu_id;
+		dp_wdi_event_handler(WDI_EVENT_RX_DATA, soc,
+				     nbuf, HTT_INVALID_PEER,
+				     WDI_NO_VAL, pdev->pdev_id);
+	}
+	return QDF_STATUS_E_ALREADY;
+}
+
+void
+dp_rx_mcopy_handle_last_mpdu(struct dp_soc *soc, struct dp_pdev *pdev,
+			     struct hal_rx_ppdu_info *ppdu_info,
+			     qdf_nbuf_t status_nbuf)
+{
+	QDF_STATUS mcopy_status;
+	qdf_nbuf_t nbuf_clone = NULL;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	/* If the MPDU end tlv and RX header are received in different buffers,
+	 * process the RX header based on fcs status.
+	 */
+	if (mon_pdev->mcopy_status_nbuf) {
+		/* For M_COPY mode only one msdu per ppdu is sent to upper layer*/
+		if (mon_pdev->mcopy_mode == M_COPY) {
+			if (mon_pdev->m_copy_id.rx_ppdu_id ==
+			    ppdu_info->com_info.ppdu_id)
+				goto end1;
+		}
+
+		if (ppdu_info->is_fcs_passed) {
+			nbuf_clone = qdf_nbuf_clone(mon_pdev->mcopy_status_nbuf);
+			if (!nbuf_clone) {
+				QDF_TRACE(QDF_MODULE_ID_TXRX,
+					  QDF_TRACE_LEVEL_ERROR,
+					  "Failed to clone nbuf");
+				goto end1;
+			}
+
+			mon_pdev->m_copy_id.rx_ppdu_id = ppdu_info->com_info.ppdu_id;
+			dp_wdi_event_handler(WDI_EVENT_RX_DATA, soc,
+					     nbuf_clone,
+					     HTT_INVALID_PEER,
+					     WDI_NO_VAL, pdev->pdev_id);
+			ppdu_info->is_fcs_passed = false;
+		}
+end1:
+		qdf_nbuf_free(mon_pdev->mcopy_status_nbuf);
+		mon_pdev->mcopy_status_nbuf = NULL;
+	}
+
+	/* If the MPDU end tlv and RX header are received in different buffers,
+	 * preserve the RX header as the fcs status will be received in MPDU
+	 * end tlv in next buffer. So, cache the buffer to be processd in next
+	 * iteration
+	 */
+	if ((ppdu_info->fcs_ok_cnt + ppdu_info->fcs_err_cnt) !=
+	    ppdu_info->com_info.mpdu_cnt) {
+		mon_pdev->mcopy_status_nbuf = qdf_nbuf_clone(status_nbuf);
+		if (mon_pdev->mcopy_status_nbuf) {
+			mcopy_status = dp_rx_handle_mcopy_mode(
+							soc, pdev,
+							ppdu_info,
+							mon_pdev->mcopy_status_nbuf,
+							ppdu_info->fcs_ok_cnt,
+							false);
+			if (mcopy_status == QDF_STATUS_SUCCESS) {
+				qdf_nbuf_free(mon_pdev->mcopy_status_nbuf);
+				mon_pdev->mcopy_status_nbuf = NULL;
+			}
+		}
+	}
+}
+
+void
+dp_rx_mcopy_process_ppdu_info(struct dp_pdev *pdev,
+			      struct hal_rx_ppdu_info *ppdu_info,
+			      uint32_t tlv_status)
+{
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (!mon_pdev->mcopy_mode)
+		return;
+
+	/* The fcs status is received in MPDU end tlv. If the RX header
+	 * and its MPDU end tlv are received in different status buffer then
+	 * to process that header ppdu_info->is_fcs_passed is used.
+	 * If end tlv is received in next status buffer then com_info.mpdu_cnt
+	 * will be 0 at the time of receiving MPDU end tlv and we update the
+	 * is_fcs_passed flag based on ppdu_info->fcs_err.
+	 */
+	if (tlv_status != HAL_TLV_STATUS_MPDU_END)
+		return;
+
+	if (!ppdu_info->fcs_err) {
+		if (ppdu_info->fcs_ok_cnt >
+		    HAL_RX_MAX_MPDU_H_PER_STATUS_BUFFER) {
+			dp_err("No. of MPDUs(%d) per status buff exceeded",
+					ppdu_info->fcs_ok_cnt);
+			return;
+		}
+		if (ppdu_info->com_info.mpdu_cnt)
+			ppdu_info->fcs_ok_cnt++;
+		else
+			ppdu_info->is_fcs_passed = true;
+	} else {
+		if (ppdu_info->com_info.mpdu_cnt)
+			ppdu_info->fcs_err_cnt++;
+		else
+			ppdu_info->is_fcs_passed = false;
+	}
+}
+
+void
+dp_rx_process_mcopy_mode(struct dp_soc *soc, struct dp_pdev *pdev,
+			 struct hal_rx_ppdu_info *ppdu_info,
+			 uint32_t tlv_status,
+			 qdf_nbuf_t status_nbuf)
+{
+	QDF_STATUS mcopy_status;
+	qdf_nbuf_t nbuf_clone = NULL;
+	uint8_t fcs_ok_mpdu_cnt = 0;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	dp_rx_mcopy_handle_last_mpdu(soc, pdev, ppdu_info, status_nbuf);
+
+	if (qdf_unlikely(!ppdu_info->com_info.mpdu_cnt))
+		goto end;
+
+	if (qdf_unlikely(!ppdu_info->fcs_ok_cnt))
+		goto end;
+
+	/* For M_COPY mode only one msdu per ppdu is sent to upper layer*/
+	if (mon_pdev->mcopy_mode == M_COPY)
+		ppdu_info->fcs_ok_cnt = 1;
+
+	while (fcs_ok_mpdu_cnt < ppdu_info->fcs_ok_cnt) {
+		nbuf_clone = qdf_nbuf_clone(status_nbuf);
+		if (!nbuf_clone) {
+			QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+				  "Failed to clone nbuf");
+			goto end;
+		}
+
+		mcopy_status = dp_rx_handle_mcopy_mode(soc, pdev,
+						       ppdu_info,
+						       nbuf_clone,
+						       fcs_ok_mpdu_cnt,
+						       true);
+
+		if (mcopy_status == QDF_STATUS_SUCCESS)
+			qdf_nbuf_free(nbuf_clone);
+
+		fcs_ok_mpdu_cnt++;
+	}
+end:
+	qdf_nbuf_free(status_nbuf);
+	ppdu_info->fcs_ok_cnt = 0;
+	ppdu_info->fcs_err_cnt = 0;
+	ppdu_info->com_info.mpdu_cnt = 0;
+	qdf_mem_zero(&ppdu_info->ppdu_msdu_info,
+		     HAL_RX_MAX_MPDU_H_PER_STATUS_BUFFER
+		     * sizeof(struct hal_rx_msdu_payload_info));
+}
+#endif /* QCA_MCOPY_SUPPORT */
+
+int
+dp_rx_handle_smart_mesh_mode(struct dp_soc *soc, struct dp_pdev *pdev,
+			      struct hal_rx_ppdu_info *ppdu_info,
+			      qdf_nbuf_t nbuf)
+{
+	uint8_t size = 0;
+	struct dp_mon_vdev *mon_vdev;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (!mon_pdev->mvdev) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "[%s]:[%d] Monitor vdev is NULL !!",
+			  __func__, __LINE__);
+		return 1;
+	}
+
+	mon_vdev = mon_pdev->mvdev->monitor_vdev;
+
+	if (!ppdu_info->msdu_info.first_msdu_payload) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "[%s]:[%d] First msdu payload not present",
+			  __func__, __LINE__);
+		return 1;
+	}
+
+	/* Adding 4 bytes to get to start of 802.11 frame after phy_ppdu_id */
+	size = (ppdu_info->msdu_info.first_msdu_payload -
+		qdf_nbuf_data(nbuf)) + 4;
+	ppdu_info->msdu_info.first_msdu_payload = NULL;
+
+	if (!qdf_nbuf_pull_head(nbuf, size)) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "[%s]:[%d] No header present",
+			  __func__, __LINE__);
+		return 1;
+	}
+
+	/* Only retain RX MSDU payload in the skb */
+	qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) -
+			   ppdu_info->msdu_info.payload_len);
+	if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status, nbuf,
+				      qdf_nbuf_headroom(nbuf))) {
+		DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
+		return 1;
+	}
+
+	mon_vdev->osif_rx_mon(mon_pdev->mvdev->osif_vdev,
+			      nbuf, NULL);
+	mon_pdev->ppdu_info.rx_status.monitor_direct_used = 0;
+	return 0;
+}
+
+qdf_nbuf_t
+dp_rx_nbuf_prepare(struct dp_soc *soc, struct dp_pdev *pdev)
+{
+	uint8_t *buf;
+	int32_t nbuf_retry_count;
+	QDF_STATUS ret;
+	qdf_nbuf_t nbuf = NULL;
+
+	for (nbuf_retry_count = 0; nbuf_retry_count <
+		QDF_NBUF_ALLOC_MAP_RETRY_THRESHOLD;
+			nbuf_retry_count++) {
+		/* Allocate a new skb using alloc_skb */
+		nbuf = qdf_nbuf_alloc_no_recycler(RX_MON_STATUS_BUF_SIZE,
+						  RX_MON_STATUS_BUF_RESERVATION,
+						  RX_DATA_BUFFER_ALIGNMENT);
+
+		if (!nbuf) {
+			DP_STATS_INC(pdev, replenish.nbuf_alloc_fail, 1);
+			continue;
+		}
+
+		buf = qdf_nbuf_data(nbuf);
+
+		memset(buf, 0, RX_MON_STATUS_BUF_SIZE);
+
+		ret = qdf_nbuf_map_nbytes_single(soc->osdev, nbuf,
+						 QDF_DMA_FROM_DEVICE,
+						 RX_MON_STATUS_BUF_SIZE);
+
+		/* nbuf map failed */
+		if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
+			qdf_nbuf_free(nbuf);
+			DP_STATS_INC(pdev, replenish.map_err, 1);
+			continue;
+		}
+		/* qdf_nbuf alloc and map succeeded */
+		break;
+	}
+
+	/* qdf_nbuf still alloc or map failed */
+	if (qdf_unlikely(nbuf_retry_count >=
+			QDF_NBUF_ALLOC_MAP_RETRY_THRESHOLD))
+		return NULL;
+
+	return nbuf;
+}
+
+#ifndef DISABLE_MON_CONFIG
+uint32_t
+dp_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
+	       uint32_t mac_id, uint32_t quota)
+{
+	struct dp_mon_ops *mon_ops;
+
+	mon_ops = dp_mon_ops_get(soc);
+	if (mon_ops && mon_ops->mon_rx_process)
+		return mon_ops->mon_rx_process(soc, int_ctx,
+					       mac_id, quota);
+	return 0;
+}
+#else
+uint32_t
+dp_mon_process(struct dp_soc *soc, struct dp_intr *int_ctx,
+	       uint32_t mac_id, uint32_t quota)
+{
+	return 0;
+}
+#endif
+
+/**
+ * dp_send_mgmt_packet_to_stack(): send indicataion to upper layers
+ *
+ * @soc: soc handle
+ * @nbuf: Mgmt packet
+ * @pdev: pdev handle
+ *
+ * Return: QDF_STATUS_SUCCESS on success
+ *         QDF_STATUS_E_INVAL in error
+ */
+#ifdef QCA_MCOPY_SUPPORT
+static inline QDF_STATUS
+dp_send_mgmt_packet_to_stack(struct dp_soc *soc,
+			     qdf_nbuf_t nbuf,
+			     struct dp_pdev *pdev)
+{
+	uint32_t *nbuf_data;
+	struct ieee80211_frame *wh;
+	qdf_frag_t addr;
+	struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
+
+	if (!nbuf)
+		return QDF_STATUS_E_INVAL;
+
+	/* Get addr pointing to80211 header */
+	addr = dp_rx_mon_get_nbuf_80211_hdr(nbuf);
+	if (qdf_unlikely(!addr)) {
+		qdf_nbuf_free(nbuf);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	/*check if this is not a mgmt packet*/
+	wh = (struct ieee80211_frame *)addr;
+	if (((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) !=
+	     IEEE80211_FC0_TYPE_MGT) &&
+	     ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) !=
+	     IEEE80211_FC0_TYPE_CTL)) {
+		qdf_nbuf_free(nbuf);
+		return QDF_STATUS_E_INVAL;
+	}
+	nbuf_data = (uint32_t *)qdf_nbuf_push_head(nbuf, 4);
+	if (!nbuf_data) {
+		QDF_TRACE(QDF_MODULE_ID_DP,
+			  QDF_TRACE_LEVEL_ERROR,
+			  FL("No headroom"));
+		qdf_nbuf_free(nbuf);
+		return QDF_STATUS_E_INVAL;
+	}
+	*nbuf_data = mon_pdev->ppdu_info.com_info.ppdu_id;
+
+	dp_wdi_event_handler(WDI_EVENT_RX_MGMT_CTRL, soc, nbuf,
+			     HTT_INVALID_PEER,
+			     WDI_NO_VAL, pdev->pdev_id);
+	return QDF_STATUS_SUCCESS;
+}
+#else
+static inline QDF_STATUS
+dp_send_mgmt_packet_to_stack(struct dp_soc *soc,
+			     qdf_nbuf_t nbuf,
+			     struct dp_pdev *pdev)
+{
+	return QDF_STATUS_SUCCESS;
+}
+#endif /* QCA_MCOPY_SUPPORT */
+
+QDF_STATUS dp_rx_mon_deliver(struct dp_soc *soc, uint32_t mac_id,
+			     qdf_nbuf_t head_msdu, qdf_nbuf_t tail_msdu)
+{
+	struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
+	struct cdp_mon_status *rs;
+	qdf_nbuf_t mon_skb, skb_next;
+	qdf_nbuf_t mon_mpdu = NULL;
+	struct dp_mon_vdev *mon_vdev;
+	struct dp_mon_pdev *mon_pdev;
+
+	if (!pdev)
+		goto mon_deliver_fail;
+
+	mon_pdev = pdev->monitor_pdev;
+	rs = &mon_pdev->rx_mon_recv_status;
+
+	if (!mon_pdev->mvdev && !mon_pdev->mcopy_mode &&
+	    !mon_pdev->rx_pktlog_cbf)
+		goto mon_deliver_fail;
+
+	/* restitch mon MPDU for delivery via monitor interface */
+	mon_mpdu = dp_rx_mon_restitch_mpdu(soc, mac_id, head_msdu,
+					   tail_msdu, rs);
+
+	/* If MPDU restitch fails, free buffers*/
+	if (!mon_mpdu) {
+		dp_info("MPDU restitch failed, free buffers");
+		goto mon_deliver_fail;
+	}
+
+	dp_rx_mon_process_dest_pktlog(soc, mac_id, mon_mpdu);
+
+	/* monitor vap cannot be present when mcopy is enabled
+	 * hence same skb can be consumed
+	 */
+	if (mon_pdev->mcopy_mode)
+		return dp_send_mgmt_packet_to_stack(soc, mon_mpdu, pdev);
+
+	if (mon_mpdu && mon_pdev->mvdev &&
+	    mon_pdev->mvdev->osif_vdev &&
+	    mon_pdev->mvdev->monitor_vdev &&
+	    mon_pdev->mvdev->monitor_vdev->osif_rx_mon) {
+		mon_vdev = mon_pdev->mvdev->monitor_vdev;
+
+		mon_pdev->ppdu_info.rx_status.ppdu_id =
+			mon_pdev->ppdu_info.com_info.ppdu_id;
+		mon_pdev->ppdu_info.rx_status.device_id = soc->device_id;
+		mon_pdev->ppdu_info.rx_status.chan_noise_floor =
+			pdev->chan_noise_floor;
+		/* convert rssi_comb from dBm to positive dB value */
+		dp_rx_mon_rssi_convert(&mon_pdev->ppdu_info.rx_status);
+
+		dp_handle_tx_capture(soc, pdev, mon_mpdu);
+
+		if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status,
+					      mon_mpdu,
+					      qdf_nbuf_headroom(mon_mpdu))) {
+			DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
+			goto mon_deliver_fail;
+		}
+
+		dp_rx_mon_update_pf_tag_to_buf_headroom(soc, mon_mpdu);
+		mon_vdev->osif_rx_mon(mon_pdev->mvdev->osif_vdev,
+				      mon_mpdu,
+				      &mon_pdev->ppdu_info.rx_status);
+	} else {
+		dp_rx_mon_dest_debug("%pK: mon_mpdu=%pK monitor_vdev %pK osif_vdev %pK"
+				     , soc, mon_mpdu, mon_pdev->mvdev,
+				     (mon_pdev->mvdev ? mon_pdev->mvdev->osif_vdev
+				     : NULL));
+		goto mon_deliver_fail;
+	}
+
+	return QDF_STATUS_SUCCESS;
+
+mon_deliver_fail:
+	mon_skb = head_msdu;
+	while (mon_skb) {
+		skb_next = qdf_nbuf_next(mon_skb);
+
+		 dp_rx_mon_dest_debug("%pK: [%s][%d] mon_skb=%pK len %u",
+				      soc,  __func__, __LINE__, mon_skb, mon_skb->len);
+
+		qdf_nbuf_free(mon_skb);
+		mon_skb = skb_next;
+	}
+	return QDF_STATUS_E_INVAL;
+}
+
+QDF_STATUS dp_rx_mon_deliver_non_std(struct dp_soc *soc,
+				     uint32_t mac_id)
+{
+	struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
+	ol_txrx_rx_mon_fp osif_rx_mon;
+	qdf_nbuf_t dummy_msdu;
+	struct dp_mon_pdev *mon_pdev;
+	struct dp_mon_vdev *mon_vdev;
+
+	/* Sanity checking */
+	if (!pdev || !pdev->monitor_pdev)
+		goto mon_deliver_non_std_fail;
+
+	mon_pdev = pdev->monitor_pdev;
+
+	if (!mon_pdev->mvdev || !mon_pdev->mvdev ||
+	    !mon_pdev->mvdev->monitor_vdev ||
+	    !mon_pdev->mvdev->monitor_vdev->osif_rx_mon)
+		goto mon_deliver_non_std_fail;
+
+	mon_vdev = mon_pdev->mvdev->monitor_vdev;
+	/* Generate a dummy skb_buff */
+	osif_rx_mon = mon_vdev->osif_rx_mon;
+	dummy_msdu = qdf_nbuf_alloc(soc->osdev, MAX_MONITOR_HEADER,
+				    MAX_MONITOR_HEADER, 4, FALSE);
+	if (!dummy_msdu)
+		goto allocate_dummy_msdu_fail;
+
+	qdf_nbuf_set_pktlen(dummy_msdu, 0);
+	qdf_nbuf_set_next(dummy_msdu, NULL);
+
+	mon_pdev->ppdu_info.rx_status.ppdu_id =
+		mon_pdev->ppdu_info.com_info.ppdu_id;
+
+	/* Apply the radio header to this dummy skb */
+	if (!qdf_nbuf_update_radiotap(&mon_pdev->ppdu_info.rx_status, dummy_msdu,
+				      qdf_nbuf_headroom(dummy_msdu))) {
+		DP_STATS_INC(pdev, dropped.mon_radiotap_update_err, 1);
+		qdf_nbuf_free(dummy_msdu);
+		goto mon_deliver_non_std_fail;
+	}
+
+	/* deliver to the user layer application */
+	osif_rx_mon(mon_pdev->mvdev->osif_vdev,
+		    dummy_msdu, NULL);
+
+	/* Clear rx_status*/
+	qdf_mem_zero(&mon_pdev->ppdu_info.rx_status,
+		     sizeof(mon_pdev->ppdu_info.rx_status));
+	mon_pdev->mon_ppdu_status = DP_PPDU_STATUS_START;
+
+	return QDF_STATUS_SUCCESS;
+
+allocate_dummy_msdu_fail:
+		 dp_rx_mon_dest_debug("%pK: mon_skb=%pK ",
+				      soc, dummy_msdu);
+
+mon_deliver_non_std_fail:
+	return QDF_STATUS_E_INVAL;
+}