qcacmn: Add lite mon rx filter setup/reset functions

Add function to setup/reset lite monitor filters
whenever lite monitor mode is enabled/disabled
respectively through cmd line.
Also add function to configure rx header tlv dma length.

Change-Id: Ia5d8bc36e1d033b3e15737bb6b9854f6a7cdd5df
CRs-Fixed: 3143570

dp/inc/cdp_txrx_mon_struct.h

@@ -27,31 +27,84 @@
 #define _CDP_TXRX_MON_STRUCT_H_
 
 #ifdef QCA_SUPPORT_LITE_MONITOR
-#define CDP_LITE_MON_MODE_MAX 3
+
-#define CDP_LITE_MON_FRM_TYPE_MAX 3
 #define CDP_LITE_MON_PEER_MAX 16
 
+#define CDP_LITE_MON_LEN_64B 0x40
+#define CDP_LITE_MON_LEN_128B 0x80
+#define CDP_LITE_MON_LEN_256B 0x100
+#define CDP_LITE_MON_LEN_FULL 0xFFFF
+
+#define CDP_LITE_MON_FILTER_ALL 0xFFFF
+
+#define CDP_LITE_MON_RX_PACKET_OFFSET 8
+
+/* This should align with nac mac type enumerations in ieee80211_ioctl.h */
+#define CDP_LITE_MON_PEER_MAC_TYPE_CLIENT 2
+
+/* lite mon filter modes */
+enum cdp_lite_mon_filter_mode {
+	/* mode filter pass */
+	CDP_LITE_MON_MODE_FP = 0,
+	/* mode monitor direct */
+	CDP_LITE_MON_MODE_MD = 1,
+	/* mode monitor other */
+	CDP_LITE_MON_MODE_MO = 2,
+	/* mode filter pass monitor other */
+	CDP_LITE_MON_MODE_FP_MO = 3,
+	/* max filter modes */
+	CDP_LITE_MON_MODE_MAX = 4,
+};
+
+/* lite mon frame levels */
+enum cdp_lite_mon_level {
+	/* level invalid */
+	CDP_LITE_MON_LEVEL_INVALID = 0,
+	/* level msdu */
+	CDP_LITE_MON_LEVEL_MSDU = 1,
+	/* level mpdu */
+	CDP_LITE_MON_LEVEL_MPDU = 2,
+	/* level ppdu */
+	CDP_LITE_MON_LEVEL_PPDU = 3,
+};
+
+/* lite mon frame types */
+enum cdp_lite_mon_frm_type {
+	/* frm type mgmt */
+	CDP_LITE_MON_FRM_TYPE_MGMT = 0,
+	/* frm type ctrl */
+	CDP_LITE_MON_FRM_TYPE_CTRL = 1,
+	/* frm type data */
+	CDP_LITE_MON_FRM_TYPE_DATA = 2,
+	/* max frame types */
+	CDP_LITE_MON_FRM_TYPE_MAX = 3,
+};
+
 /* lite mon peer action */
 enum cdp_lite_mon_peer_action {
+	/* peer add */
 	CDP_LITE_MON_PEER_ADD = 0,
+	/* peer remove */
 	CDP_LITE_MON_PEER_REMOVE = 1,
 };
 
 /* lite mon peer types */
 enum cdp_lite_mon_peer_type {
+	/* associated peer */
 	CDP_LITE_MON_PEER_TYPE_ASSOCIATED = 0,
+	/* non associated peer */
 	CDP_LITE_MON_PEER_TYPE_NON_ASSOCIATED = 1,
+	/* max peer types */
 	CDP_LITE_MON_PEER_TYPE_MAX = 2,
 };
 
 /* lite mon config direction */
 enum cdp_lite_mon_direction {
+	/* lite mon config direction rx */
 	CDP_LITE_MON_DIRECTION_RX = 1,
+	/* lite mon config direction tx */
 	CDP_LITE_MON_DIRECTION_TX = 2,
 };
-
-/* This should align with nac mac type enumerations in ieee80211_ioctl.h */
-#define CDP_LITE_MON_PEER_MAC_TYPE_CLIENT 2
 #endif
 
 /* XXX not really a mode; there are really multiple PHY's */

dp/wifi3.0/dp_htt.c

@@ -1082,6 +1082,7 @@ int htt_h2t_rx_ring_cfg(struct htt_soc *htt_soc, int pdev_id,
 		ring_buf_size);
 
 	dp_mon_rx_packet_length_set(soc->dp_soc, msg_word, htt_tlv_filter);
+	dp_mon_rx_hdr_length_set(soc->dp_soc, msg_word, htt_tlv_filter);
 
 	/* word 2 */
 	msg_word++;

dp/wifi3.0/dp_htt.h

@@ -613,6 +613,7 @@ struct htt_tx_ring_tlv_filter {
  * @mgmt_dma_length: configure length for mgmt packet
  * @ctrl_dma_length: configure length for ctrl packet
  * @data_dma_length: configure length for data packet
+ * @rx_hdr_length: configure length for rx header tlv
  * @mgmt_mpdu_log: enable mgmt mpdu level logging
  * @ctrl_mpdu_log: enable ctrl mpdu level logging
  * @data_mpdu_log: enable data mpdu level logging
@@ -671,6 +672,7 @@ struct htt_rx_ring_tlv_filter {
 	uint16_t mgmt_dma_length:3,
 		 ctrl_dma_length:3,
 		 data_dma_length:3,
+		 rx_hdr_length:3,
 		 mgmt_mpdu_log:1,
 		 ctrl_mpdu_log:1,
 		 data_mpdu_log:1,

dp/wifi3.0/dp_internal.h

@@ -697,6 +697,12 @@ static inline bool dp_monitor_is_configured(struct dp_pdev *pdev)
 {
 	return false;
 }
+
+static inline void
+dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word,
+			 struct htt_rx_ring_tlv_filter *tlv_filter)
+{
+}
 #endif
 
 /**

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

@@ -1128,6 +1128,7 @@ dp_mon_register_feature_ops_1_0(struct dp_soc *soc)
 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
 	mon_ops->mon_pktlogmod_exit = dp_pktlogmod_exit;
 #endif
+	mon_ops->rx_hdr_length_set = NULL;
 	mon_ops->rx_packet_length_set = NULL;
 	mon_ops->rx_mon_enable = NULL;
 	mon_ops->rx_wmask_subscribe = NULL;
@@ -1229,6 +1230,7 @@ struct dp_mon_ops monitor_ops_1_0 = {
 	.mon_lite_mon_alloc = NULL,
 	.mon_lite_mon_dealloc = NULL,
 	.mon_lite_mon_vdev_delete = NULL,
+	.mon_lite_mon_disable_rx = NULL,
 };
 
 struct cdp_mon_ops dp_ops_mon_1_0 = {

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

@@ -1289,6 +1289,7 @@ dp_mon_register_feature_ops_2_0(struct dp_soc *soc)
 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
 	mon_ops->mon_pktlogmod_exit = dp_pktlogmod_exit;
 #endif
+	mon_ops->rx_hdr_length_set = dp_rx_mon_hdr_length_set;
 	mon_ops->rx_packet_length_set = dp_rx_mon_packet_length_set;
 	mon_ops->rx_mon_enable = dp_rx_mon_enable_set;
 	mon_ops->rx_wmask_subscribe = dp_rx_mon_word_mask_subscribe;
@@ -1399,6 +1400,7 @@ struct dp_mon_ops monitor_ops_2_0 = {
 	.mon_lite_mon_alloc = dp_lite_mon_alloc,
 	.mon_lite_mon_dealloc = dp_lite_mon_dealloc,
 	.mon_lite_mon_vdev_delete = dp_lite_mon_vdev_delete,
+	.mon_lite_mon_disable_rx = dp_lite_mon_disable_rx,
 };
 
 struct cdp_mon_ops dp_ops_mon_2_0 = {

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

@@ -30,6 +30,9 @@
 #include <dp_rx_mon_2.0.h>
 #include <dp_mon_filter_2.0.h>
 #include <dp_be.h>
+#ifdef QCA_SUPPORT_LITE_MONITOR
+#include "dp_lite_mon.h"
+#endif
 
 #define HTT_MSG_BUF_SIZE(msg_bytes) \
    ((msg_bytes) + HTC_HEADER_LEN + HTC_HDR_ALIGNMENT_PADDING)
@@ -103,6 +106,18 @@ fail:
 	return QDF_STATUS_E_FAILURE;
 }
 
+void dp_rx_mon_hdr_length_set(uint32_t *msg_word,
+			      struct htt_rx_ring_tlv_filter *tlv_filter)
+{
+#ifdef FW_SUPPORT_NOT_YET
+	if (!msg_word || !tlv_filter)
+		return;
+
+	HTT_RX_RING_SELECTION_CFG_RX_HDR_LEN_SET(*msg_word,
+						 tlv_filter->rx_hdr_length);
+#endif
+}
+
 void dp_rx_mon_packet_length_set(uint32_t *msg_word,
 				 struct htt_rx_ring_tlv_filter *tlv_filter)
 {
@@ -1368,6 +1383,8 @@ static void dp_rx_mon_filter_show_filter(struct dp_mon_filter_be *filter)
 			    rx_tlv_filter->rx_mpdu_start_wmask);
 	DP_MON_FILTER_PRINT("rx_msdu_end_wmask: 0x%x",
 			    rx_tlv_filter->rx_msdu_end_wmask);
+	DP_MON_FILTER_PRINT("rx_hdr_length: %d",
+			    rx_tlv_filter->rx_hdr_length);
 }
 
 static void dp_tx_mon_filter_show_filter(struct dp_mon_filter_be *filter)
@@ -2054,6 +2071,14 @@ dp_rx_mon_filter_h2t_setup(struct dp_soc *soc, struct dp_pdev *pdev,
 			tlv_filter->rx_msdu_end_wmask =
 				src_tlv_filter->rx_msdu_end_wmask;
 
+		/*
+		 * set hdr tlv length
+		 */
+		if (src_tlv_filter->rx_hdr_length &&
+		    !tlv_filter->rx_hdr_length)
+			tlv_filter->rx_hdr_length =
+				src_tlv_filter->rx_hdr_length;
+
 		dp_mon_filter_show_filter_be(current_mode, mon_filter);
 	}
 }
@@ -2207,3 +2232,147 @@ QDF_STATUS dp_rx_mon_filter_update_2_0(struct dp_pdev *pdev)
 				     &filter);
 	return QDF_STATUS_SUCCESS;
 }
+
+#ifdef QCA_SUPPORT_LITE_MONITOR
+void
+dp_mon_filter_reset_rx_lite_mon(struct dp_mon_pdev_be *be_mon_pdev)
+{
+	struct dp_mon_filter_be filter = {0};
+	enum dp_mon_filter_mode filter_mode =
+				DP_MON_FILTER_LITE_MON_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXMON_DEST;
+
+	be_mon_pdev->mon_pdev.current_filter_mode = filter_mode;
+	be_mon_pdev->filter_be[filter_mode][srng_type] = filter;
+}
+
+void
+dp_mon_filter_setup_rx_lite_mon(struct dp_mon_pdev_be *be_mon_pdev)
+{
+	struct dp_mon_filter_be filter = {0};
+	struct dp_mon_filter *rx_tlv_filter;
+	enum dp_mon_filter_mode filter_mode =
+				DP_MON_FILTER_LITE_MON_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+				DP_MON_FILTER_SRNG_TYPE_RXMON_DEST;
+	struct dp_lite_mon_rx_config *config = NULL;
+	uint16_t max_custom_len = 0;
+	uint16_t mgmt_len = 0;
+	uint16_t ctrl_len = 0;
+	uint16_t data_len = 0;
+
+	config = be_mon_pdev->lite_mon_rx_config;
+	if (!config)
+		return;
+
+	rx_tlv_filter = &filter.rx_tlv_filter;
+	rx_tlv_filter->valid = true;
+	/* configure fp filters if enabled */
+	if (config->rx_config.fp_enabled) {
+		rx_tlv_filter->tlv_filter.enable_fp = 1;
+		rx_tlv_filter->tlv_filter.fp_mgmt_filter =
+			config->rx_config.mgmt_filter[CDP_LITE_MON_MODE_FP];
+		rx_tlv_filter->tlv_filter.fp_ctrl_filter =
+			config->rx_config.ctrl_filter[CDP_LITE_MON_MODE_FP];
+		rx_tlv_filter->tlv_filter.fp_data_filter =
+			config->rx_config.data_filter[CDP_LITE_MON_MODE_FP];
+	}
+
+	/* configure md filters if enabled */
+	if (config->rx_config.md_enabled) {
+		rx_tlv_filter->tlv_filter.enable_md = 1;
+		rx_tlv_filter->tlv_filter.md_mgmt_filter =
+			config->rx_config.mgmt_filter[CDP_LITE_MON_MODE_MD];
+		rx_tlv_filter->tlv_filter.md_ctrl_filter =
+			config->rx_config.ctrl_filter[CDP_LITE_MON_MODE_MD];
+		rx_tlv_filter->tlv_filter.md_data_filter =
+			config->rx_config.data_filter[CDP_LITE_MON_MODE_MD];
+	}
+
+	/* configure mo filters if enabled */
+	if (config->rx_config.mo_enabled) {
+		rx_tlv_filter->tlv_filter.enable_mo = 1;
+		rx_tlv_filter->tlv_filter.mo_mgmt_filter =
+			config->rx_config.mgmt_filter[CDP_LITE_MON_MODE_MO];
+		rx_tlv_filter->tlv_filter.mo_ctrl_filter =
+			config->rx_config.ctrl_filter[CDP_LITE_MON_MODE_MO];
+		rx_tlv_filter->tlv_filter.mo_data_filter =
+			config->rx_config.data_filter[CDP_LITE_MON_MODE_MO];
+	}
+
+	mgmt_len = config->rx_config.len[CDP_LITE_MON_FRM_TYPE_MGMT];
+	ctrl_len = config->rx_config.len[CDP_LITE_MON_FRM_TYPE_CTRL];
+	data_len = config->rx_config.len[CDP_LITE_MON_FRM_TYPE_DATA];
+	/* if full len is configured for any of the types, subscribe
+	 * for full dma length else set it to min dma length(fw sets
+	 * full length by default) to avoid unnecessary dma since we
+	 * do not have hw support to control rx pkt tlvs per type. To
+	 * get custom len pkt we make use of rx hdr tlv instead.
+	 */
+	if (dp_lite_mon_is_full_len_configured(mgmt_len,
+					       ctrl_len,
+					       data_len)) {
+		rx_tlv_filter->tlv_filter.packet = 1;
+		rx_tlv_filter->tlv_filter.rx_packet_offset =
+					CDP_LITE_MON_RX_PACKET_OFFSET;
+		if (mgmt_len == CDP_LITE_MON_LEN_FULL)
+			rx_tlv_filter->tlv_filter.mgmt_dma_length =
+							DEFAULT_DMA_LENGTH;
+		else
+			rx_tlv_filter->tlv_filter.mgmt_dma_length =
+							DMA_LENGTH_64B;
+
+		if (ctrl_len == CDP_LITE_MON_LEN_FULL)
+			rx_tlv_filter->tlv_filter.ctrl_dma_length =
+							DEFAULT_DMA_LENGTH;
+		else
+			rx_tlv_filter->tlv_filter.ctrl_dma_length =
+							DMA_LENGTH_64B;
+
+		if (data_len == CDP_LITE_MON_LEN_FULL)
+			rx_tlv_filter->tlv_filter.data_dma_length =
+							DEFAULT_DMA_LENGTH;
+		else
+			rx_tlv_filter->tlv_filter.data_dma_length =
+							DMA_LENGTH_64B;
+	} else  {
+		/* if full len not configured set to min len */
+		rx_tlv_filter->tlv_filter.mgmt_dma_length = DMA_LENGTH_64B;
+		rx_tlv_filter->tlv_filter.ctrl_dma_length = DMA_LENGTH_64B;
+		rx_tlv_filter->tlv_filter.data_dma_length = DMA_LENGTH_64B;
+	}
+
+	rx_tlv_filter->tlv_filter.packet_header = 1;
+	/* set rx hdr tlv len, default len is 128B */
+	max_custom_len = dp_lite_mon_get_max_custom_len(mgmt_len, ctrl_len,
+							data_len);
+	if (max_custom_len == CDP_LITE_MON_LEN_64B)
+		rx_tlv_filter->tlv_filter.rx_hdr_length =
+						RX_HDR_DMA_LENGTH_64B;
+	else if (max_custom_len == CDP_LITE_MON_LEN_128B)
+		rx_tlv_filter->tlv_filter.rx_hdr_length =
+						RX_HDR_DMA_LENGTH_128B;
+	else if (max_custom_len == CDP_LITE_MON_LEN_256B)
+		rx_tlv_filter->tlv_filter.rx_hdr_length =
+						RX_HDR_DMA_LENGTH_256B;
+
+	if ((config->rx_config.level == CDP_LITE_MON_LEVEL_MSDU) ||
+	    dp_lite_mon_is_full_len_configured(mgmt_len, ctrl_len, data_len)) {
+		rx_tlv_filter->tlv_filter.header_per_msdu = 1;
+		rx_tlv_filter->tlv_filter.msdu_end = 1;
+	}
+
+	rx_tlv_filter->tlv_filter.ppdu_start = 1;
+	rx_tlv_filter->tlv_filter.ppdu_end = 1;
+	rx_tlv_filter->tlv_filter.mpdu_start = 1;
+	rx_tlv_filter->tlv_filter.mpdu_end = 1;
+
+	rx_tlv_filter->tlv_filter.ppdu_end_user_stats = 1;
+	rx_tlv_filter->tlv_filter.ppdu_end_user_stats_ext = 1;
+	rx_tlv_filter->tlv_filter.ppdu_end_status_done = 1;
+
+	be_mon_pdev->mon_pdev.current_filter_mode = filter_mode;
+	be_mon_pdev->filter_be[filter_mode][srng_type] = filter;
+}
+#endif /* QCA_SUPPORT_LITE_MONITOR */

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

@@ -25,6 +25,21 @@
 #define DMA_LENGTH_128B 2
 #define DMA_LENGTH_256B 4
 
+/* rx hdr tlv dma lengths */
+enum dp_rx_hdr_dma_length {
+	/* default dma length(128B) */
+	DEFAULT_RX_HDR_DMA_LENGTH = 0,
+	/* dma length 64 bytes */
+	RX_HDR_DMA_LENGTH_64B = 1,
+	/* dma length 128 bytes */
+	RX_HDR_DMA_LENGTH_128B = 2,
+	/* dma length 256 bytes */
+	RX_HDR_DMA_LENGTH_256B = 3,
+};
+
+/* fwd declarations */
+struct dp_mon_pdev_be;
+
 /**
  * dp_rx_mon_enable_set() - Setup rx monitor feature
  * @msg_word: msg word
@@ -34,6 +49,15 @@ void
 dp_rx_mon_enable_set(uint32_t *msg_word,
 		     struct htt_rx_ring_tlv_filter *tlv_filter);
 
+/**
+ * dp_rx_mon_hdr_length_set() - Setup rx monitor hdr tlv length
+ * @msg_word: msg word
+ * @htt_tlv_filter: rx ring filter configuration
+ */
+void
+dp_rx_mon_hdr_length_set(uint32_t *msg_word,
+			 struct htt_rx_ring_tlv_filter *tlv_filter);
+
 /**
  * dp_rx_mon_packet_length_set() - Setup rx monitor per packet type length
  * @msg_word: msg word
@@ -331,4 +355,9 @@ void dp_mon_filter_dealloc_2_0(struct dp_pdev *pdev);
  */
 QDF_STATUS dp_mon_filter_alloc_2_0(struct dp_pdev *pdev);
 
+#ifdef QCA_SUPPORT_LITE_MONITOR
+void dp_mon_filter_reset_rx_lite_mon(struct dp_mon_pdev_be *be_mon_pdev);
+
+void dp_mon_filter_setup_rx_lite_mon(struct dp_mon_pdev_be *be_mon_pdev);
+#endif
 #endif /* _DP_MON_FILTER_2_0_H_ */

dp/wifi3.0/monitor/dp_mon.c

@@ -238,6 +238,10 @@ QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl,
 #if defined(ATH_SUPPORT_NAC)
 		dp_mon_filter_reset_smart_monitor(pdev);
 #endif /* ATH_SUPPORT_NAC */
+		/* for mon 2.0 we make use of lite mon to
+		 * set filters for smart monitor use case.
+		 */
+		dp_monitor_lite_mon_disable_rx(pdev);
 	} else if (mon_pdev->undecoded_metadata_capture) {
 #ifdef QCA_UNDECODED_METADATA_SUPPORT
 		dp_reset_undecoded_metadata_capture(pdev);
@@ -503,6 +507,12 @@ static QDF_STATUS dp_vdev_set_monitor_mode(struct cdp_soc_t *dp_soc,
 
 	mon_pdev->monitor_configured = true;
 
+	/* disable lite mon if configured, monitor vap takes
+	 * priority over lite mon when its created. Lite mon
+	 * can be configured later again.
+	 */
+	dp_monitor_lite_mon_disable_rx(pdev);
+
 	cdp_ops = dp_mon_cdp_ops_get(soc);
 	if (cdp_ops  && cdp_ops->soc_config_full_mon_mode)
 		cdp_ops->soc_config_full_mon_mode((struct cdp_pdev *)pdev,
@@ -5679,6 +5689,7 @@ void dp_mon_feature_ops_deregister(struct dp_soc *soc)
 #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
 	mon_ops->mon_pktlogmod_exit = NULL;
 #endif
+	mon_ops->rx_hdr_length_set = NULL;
 	mon_ops->rx_packet_length_set = NULL;
 	mon_ops->rx_wmask_subscribe = NULL;
 	mon_ops->rx_enable_mpdu_logging = NULL;

dp/wifi3.0/monitor/dp_mon.h

@@ -741,6 +741,8 @@ struct dp_mon_ops {
 	void (*tx_mon_desc_pool_free)(struct dp_pdev *pdev);
 	void (*rx_mon_enable)(uint32_t *msg_word,
 			      struct htt_rx_ring_tlv_filter *tlv_filter);
+	void (*rx_hdr_length_set)(uint32_t *msg_word,
+				  struct htt_rx_ring_tlv_filter *tlv_filter);
 	void (*rx_packet_length_set)(uint32_t *msg_word,
 				     struct htt_rx_ring_tlv_filter *tlv_filter);
 	void (*rx_wmask_subscribe)(uint32_t *msg_word,
@@ -776,6 +778,7 @@ struct dp_mon_ops {
 	void (*mon_lite_mon_dealloc)(struct dp_pdev *pdev);
 	void (*mon_lite_mon_vdev_delete)(struct dp_pdev *pdev,
 					 struct dp_vdev *vdev);
+	void (*mon_lite_mon_disable_rx)(struct dp_pdev *pdev);
 };
 
 struct dp_mon_soc {
@@ -3679,6 +3682,35 @@ dp_mon_rx_enable_mpdu_logging(struct dp_soc *soc, uint32_t *msg_word,
 	monitor_ops->rx_enable_mpdu_logging(msg_word, tlv_filter);
 }
 
+/*
+ * dp_mon_rx_hdr_length_set() - set rx hdr tlv length
+ * @soc: dp soc handle
+ * @msg_word: msg word
+ * @tlv_filter: rx fing filter config
+ *
+ * Return: void
+ */
+static inline void
+dp_mon_rx_hdr_length_set(struct dp_soc *soc, uint32_t *msg_word,
+			 struct htt_rx_ring_tlv_filter *tlv_filter)
+{
+	struct dp_mon_soc *mon_soc = soc->monitor_soc;
+	struct dp_mon_ops *monitor_ops;
+
+	if (!mon_soc) {
+		dp_mon_debug("mon soc is NULL");
+		return;
+	}
+
+	monitor_ops = mon_soc->mon_ops;
+	if (!monitor_ops || !monitor_ops->rx_hdr_length_set) {
+		dp_mon_debug("callback not registered");
+		return;
+	}
+
+	monitor_ops->rx_hdr_length_set(msg_word, tlv_filter);
+}
+
 static inline void
 dp_mon_rx_packet_length_set(struct dp_soc *soc, uint32_t *msg_word,
 			    struct htt_rx_ring_tlv_filter *tlv_filter)
@@ -3930,7 +3962,45 @@ QDF_STATUS dp_pdev_get_rx_mon_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
 void dp_enable_mon_reap_timer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
 			      bool enable);
 
+/*
+ * dp_monitor_lite_mon_disable_rx() - disables rx lite mon
+ * @pdev: dp pdev
+ *
+ * Return: void
+ */
+static inline void
+dp_monitor_lite_mon_disable_rx(struct dp_pdev *pdev)
+{
+	struct dp_mon_ops *monitor_ops;
+	struct dp_mon_soc *mon_soc = pdev->soc->monitor_soc;
+
+	if (!mon_soc) {
+		dp_mon_debug("monitor soc is NULL");
+		return;
+}
+
+	monitor_ops = mon_soc->mon_ops;
+	if (!monitor_ops ||
+	    !monitor_ops->mon_lite_mon_disable_rx) {
+		dp_mon_debug("callback not registered");
+		return;
+}
+
+	return monitor_ops->mon_lite_mon_disable_rx(pdev);
+}
+
 #ifndef QCA_SUPPORT_LITE_MONITOR
+static inline void
+dp_lite_mon_disable_rx(struct dp_pdev *pdev)
+{
+}
+
+static inline int
+dp_lite_mon_is_level_msdu(struct dp_mon_pdev *mon_pdev)
+{
+	return 0;
+}
+
 static inline int
 dp_lite_mon_is_rx_enabled(struct dp_mon_pdev *mon_pdev)
 {

dp/wifi3.0/monitor/dp_mon_filter.h

@@ -135,6 +135,9 @@ enum dp_mon_filter_mode {
 #ifdef QCA_UNDECODED_METADATA_SUPPORT
 	DP_MON_FILTER_UNDECODED_METADATA_CAPTURE_MODE,
 #endif
+#ifdef QCA_SUPPORT_LITE_MONITOR
+	DP_MON_FILTER_LITE_MON_MODE,
+#endif /*QCA_SUPPORT_LITE_MONITOR*/
 	DP_MON_FILTER_MAX_MODE
 };
 

qdf/inc/qdf_nbuf.h

@@ -522,6 +522,7 @@ struct mon_rx_status {
  * @ba_control: Block ack control
  * @ba_bitmap: 256 bit block ack bitmap
  * @tid: QoS traffic tid number
+ * @filter_category: mpdu filter category
  * @mpdu_q: user mpdu_queue used for monitor
  */
 struct mon_rx_user_status {
@@ -581,6 +582,7 @@ struct mon_rx_user_status {
 	uint32_t ba_bitmap[32];
 	uint32_t ba_bitmap_sz;
 	uint16_t aid;
+	uint8_t filter_category;
 	qdf_nbuf_queue_t mpdu_q;
 };