qcacmn: FR65980: Monitor filter setting for pktlog modes

Add monitor filter settings for various pktlog modes
for QCN9224

Change-Id: I8b236603277ba873f4f2cd9d4a96fb0e8f213996
CRs-Fixed: 3074184

dp/wifi3.0/dp_types.h

@@ -196,6 +196,9 @@ struct cdp_soc_rate_stats_ctx;
 struct dp_rx_fst;
 struct dp_mon_filter;
 struct dp_mon_mpdu;
+#ifdef QCA_WIFI_QCN9224
+struct dp_mon_filter_be;
+#endif
 
 /**
  * enum for DP peer state

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

@@ -28,7 +28,7 @@
 
 /**
  * dp_mon_filter_mode_type_to_str
- *	Monitor Filter mode to string
+ *  Monitor Filter mode to string
  */
 int8_t *dp_mon_filter_mode_type_to_str[DP_MON_FILTER_MAX_MODE] = {
 #ifdef QCA_ENHANCED_STATS_SUPPORT
@@ -41,12 +41,16 @@ int8_t *dp_mon_filter_mode_type_to_str[DP_MON_FILTER_MAX_MODE] = {
 	"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
+#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",
+	"DP MON FILTER PKT LOG LITE MODE",
+	"DP MON FILTER PKT LOG CBF MODE",
+#ifdef QCA_WIFI_QCN9224
+	"DP MON FILTER PKT LOG HYBRID MODE",
+#endif
 #endif /* WDI_EVENT_ENABLE */
 };
 

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

@@ -24,6 +24,18 @@
 #define DP_MON_RING_FILL_LEVEL_DEFAULT 2048
 #define DP_MON_DATA_BUFFER_SIZE     2048
 
+/**
+ * struct dp_mon_filter_be - Monitor TLV filter
+ * @rx_tlv_filter: Rx MON TLV filter
+ * @tx_tlv_filter: Tx MON TLV filter
+ * @tx_valid: enable/disable Tx Mon TLV filter
+ */
+struct dp_mon_filter_be {
+	struct dp_mon_filter rx_tlv_filter;
+	struct htt_tx_ring_tlv_filter tx_tlv_filter;
+	bool tx_valid;
+};
+
 /**
  * struct dp_mon_desc
  *
@@ -74,9 +86,11 @@ struct dp_mon_desc_pool {
 
 /**
  * struct dp_mon_pdev_be - BE specific monitor pdev object
+ * @filter_be: Monitor Filter pointer
  * @mon_pdev: monitor pdev structure
  */
 struct dp_mon_pdev_be {
+	struct dp_mon_filter_be **filter_be;
 	struct dp_mon_pdev mon_pdev;
 };
 
@@ -175,4 +189,13 @@ QDF_STATUS dp_mon_buffers_replenish(struct dp_soc *dp_soc,
 				union dp_mon_desc_list_elem_t **desc_list,
 				union dp_mon_desc_list_elem_t **tail);
 
+/**
+ * dp_mon_filter_show_filter_be() - Show the set filters
+ * @pdev: DP pdev handle
+ * @mode: The filter modes
+ * @tlv_filter: tlv filter
+ */
+void dp_mon_filter_show_filter_be(struct dp_mon_pdev *mon_pdev,
+				  enum dp_mon_filter_mode mode,
+				  struct dp_mon_filter_be *filter);
 #endif /* _DP_MON_2_0_H_ */

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

@@ -973,37 +973,348 @@ void dp_mon_filter_reset_mon_mode_2_0(struct dp_pdev *pdev)
 {
 }
 
+void dp_mon_filter_show_filter_be(struct dp_mon_pdev_be *mon_pdev,
+				  enum dp_mon_filter_mode mode,
+				  struct dp_mon_filter_be *filter)
+{
+	struct htt_rx_ring_tlv_filter *rx_tlv_filter =
+		&filter->rx_tlv_filter.tlv_filter;
+	struct htt_tx_ring_tlv_filter *tx_tlv_filter =
+		&filter->tx_tlv_filter;
+
+	DP_MON_FILTER_PRINT("RX MON RING TLV FILTER CONFIG:");
+	DP_MON_FILTER_PRINT("[Mode%d]: Valid: %d",
+			    mode, filter->rx_tlv_filter.valid);
+	DP_MON_FILTER_PRINT("mpdu_start: %d", rx_tlv_filter->mpdu_start);
+	DP_MON_FILTER_PRINT("msdu_start: %d", rx_tlv_filter->msdu_start);
+	DP_MON_FILTER_PRINT("packet: %d", rx_tlv_filter->packet);
+	DP_MON_FILTER_PRINT("msdu_end: %d", rx_tlv_filter->msdu_end);
+	DP_MON_FILTER_PRINT("mpdu_end: %d", rx_tlv_filter->mpdu_end);
+	DP_MON_FILTER_PRINT("packet_header: %d",
+			    rx_tlv_filter->packet_header);
+	DP_MON_FILTER_PRINT("attention: %d", rx_tlv_filter->attention);
+	DP_MON_FILTER_PRINT("ppdu_start: %d", rx_tlv_filter->ppdu_start);
+	DP_MON_FILTER_PRINT("ppdu_end: %d", rx_tlv_filter->ppdu_end);
+	DP_MON_FILTER_PRINT("ppdu_end_user_stats: %d",
+			    rx_tlv_filter->ppdu_end_user_stats);
+	DP_MON_FILTER_PRINT("ppdu_end_user_stats_ext: %d",
+			    rx_tlv_filter->ppdu_end_user_stats_ext);
+	DP_MON_FILTER_PRINT("ppdu_end_status_done: %d",
+			    rx_tlv_filter->ppdu_end_status_done);
+	DP_MON_FILTER_PRINT("header_per_msdu: %d",
+			    rx_tlv_filter->header_per_msdu);
+	DP_MON_FILTER_PRINT("enable_fp: %d", rx_tlv_filter->enable_fp);
+	DP_MON_FILTER_PRINT("enable_md: %d", rx_tlv_filter->enable_md);
+	DP_MON_FILTER_PRINT("enable_mo: %d", rx_tlv_filter->enable_mo);
+	DP_MON_FILTER_PRINT("fp_mgmt_filter: 0x%x",
+			    rx_tlv_filter->fp_mgmt_filter);
+	DP_MON_FILTER_PRINT("mo_mgmt_filter: 0x%x",
+			    rx_tlv_filter->mo_mgmt_filter);
+	DP_MON_FILTER_PRINT("fp_ctrl_filter: 0x%x",
+			    rx_tlv_filter->fp_ctrl_filter);
+	DP_MON_FILTER_PRINT("mo_ctrl_filter: 0x%x",
+			    rx_tlv_filter->mo_ctrl_filter);
+	DP_MON_FILTER_PRINT("fp_data_filter: 0x%x",
+			    rx_tlv_filter->fp_data_filter);
+	DP_MON_FILTER_PRINT("mo_data_filter: 0x%x",
+			    rx_tlv_filter->mo_data_filter);
+	DP_MON_FILTER_PRINT("md_data_filter: 0x%x",
+			    rx_tlv_filter->md_data_filter);
+	DP_MON_FILTER_PRINT("md_mgmt_filter: 0x%x",
+			    rx_tlv_filter->md_mgmt_filter);
+	DP_MON_FILTER_PRINT("md_ctrl_filter: 0x%x",
+			    rx_tlv_filter->md_ctrl_filter);
+	DP_MON_FILTER_PRINT("\nTX MON RING TLV FILTER CONFIG:");
+	DP_MON_FILTER_PRINT("[Mode%d]: Valid: %d", mode, filter->tx_valid);
+	DP_MON_FILTER_PRINT("tx_fes_status_start: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_start);
+	DP_MON_FILTER_PRINT("tx_fes_status_start_prot: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_start_prot);
+	DP_MON_FILTER_PRINT("tx_fes_status_prot: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_prot);
+	DP_MON_FILTER_PRINT("tx_fes_status_start_ppdu: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_start_ppdu);
+	DP_MON_FILTER_PRINT("tx_fes_status_user_ppdu: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_user_ppdu);
+	DP_MON_FILTER_PRINT("tx_fes_status_ack_or_ba: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_ack_or_ba);
+	DP_MON_FILTER_PRINT("tx_fes_status_1k_ba: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_1k_ba);
+	DP_MON_FILTER_PRINT("tx_fes_status_user_response: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_user_response);
+	DP_MON_FILTER_PRINT("tx_fes_status_end: %d",
+			    tx_tlv_filter->utlvs.tx_fes_status_end);
+	DP_MON_FILTER_PRINT("response_start_status: %d",
+			    tx_tlv_filter->utlvs.response_start_status);
+	DP_MON_FILTER_PRINT("response_end_status: %d",
+			    tx_tlv_filter->utlvs.response_end_status);
+	DP_MON_FILTER_PRINT("recevied_response_info: %d",
+			    tx_tlv_filter->utlvs.recevied_response_info);
+	DP_MON_FILTER_PRINT("recevied_response_info_p2: %d",
+			    tx_tlv_filter->utlvs.recevied_response_info_p2);
+}
+
 #ifdef WDI_EVENT_ENABLE
 void dp_mon_filter_setup_rx_pkt_log_full_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be 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_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+	struct htt_rx_ring_tlv_filter *rx_tlv_filter =
+		&filter.rx_tlv_filter.tlv_filter;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+	/* Enabled the filter */
+	filter.rx_tlv_filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev_be->mon_pdev,
+				     &filter.rx_tlv_filter);
+
+	/* Setup the filter */
+	rx_tlv_filter->packet_header = 1;
+	rx_tlv_filter->msdu_start = 1;
+	rx_tlv_filter->msdu_end = 1;
+	rx_tlv_filter->mpdu_end = 1;
+	rx_tlv_filter->attention = 1;
+
+	dp_mon_filter_show_filter_be(mon_pdev_be, mode, &filter);
+	mon_pdev_be->filter_be[mode][srng_type] = filter;
 }
 
 void dp_mon_filter_reset_rx_pkt_log_full_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be 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_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+
+	mon_pdev_be->filter_be[mode][srng_type] = filter;
 }
 
 void dp_mon_filter_setup_rx_pkt_log_lite_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be 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_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+	/* Enabled the filter */
+	filter.rx_tlv_filter.valid = true;
+	dp_mon_filter_set_status_cmn(mon_pdev_be->mon_pdev,
+				     &filter.rx_tlv_filter);
+
+	dp_mon_filter_show_filter_be(mon_pdev_be, mode, &filter);
+	mon_pdev_be->filter[mode][srng_type] = filter;
 }
 
 void dp_mon_filter_reset_rx_pkt_log_lite_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be 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_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+
+	mon_pdev_be->filter_be[mode][srng_type] = filter;
 }
 
+#ifdef QCA_MONITOR_PKT_SUPPORT
+static void
+dp_mon_filter_set_reset_rx_pkt_log_cbf_dest_2_0(struct dp_pdev_be *pdev_be,
+						struct dp_mon_filter_be *filter)
+{
+	struct dp_soc *soc = pdev_be->pdev->soc;
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_CBF_MODE;
+	enum dp_mon_filter_srng_type srng_type;
+	struct dp_mon_pdev_be *mon_pdev_be;
+	struct htt_rx_ring_tlv_filter *rx_tlv_filter =
+		&filter->rx_tlv_filter->tlv_filter;
+
+	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 (filter->rx_tlv_filter->valid) {
+		dp_mon_filter_set_cbf_cmn(pdev_be->pdev, filter->rx_tlv_filter);
+
+		dp_mon_filter_show_filter_be(mon_pdev_be, mode, filter);
+		mon_pdev_be->filter[mode][srng_type] = *filter;
+	} else /* reset the filter */
+		mon_pdev_be->filter[mode][srng_type] = *filter;
+}
+#else
+static void
+dp_mon_filter_set_reset_rx_pkt_log_cbf_dest_2_0(struct dp_pdev_be *pdev,
+						struct dp_mon_filter_be *filter)
+{
+}
+#endif
+
 void dp_mon_filter_setup_rx_pkt_log_cbf_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be filter = {0};
+	struct dp_soc *soc;
+	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_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+
+	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;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+	/* Enabled the filter */
+	filter.rx_tlv_filter.valid = true;
+
+	dp_mon_filter_set_status_cbf(pdev_be->pdev, &filter.rx_tlv_filter);
+	dp_mon_filter_show_filter_be(mon_pdev_be, mode, &filter);
+	mon_pdev_be->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_be));
+
+	filter.rx_tlv_filter.valid = true;
+	dp_mon_filter_set_reset_rx_pkt_log_cbf_dest_2_0(pdev_be, &filter);
 }
 
 void dp_mon_filter_reset_rx_pktlog_cbf_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be filter = {0};
+	struct dp_soc *soc;
+	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_be *mon_pdev_be;
+
+	if (!pdev) {
+		QDF_TRACE(QDF_MODULE_ID_MON_FILTER, QDF_TRACE_LEVEL_ERROR,
+			  FL("pdev Context is null"));
+		return;
+	}
+
+	soc = pdev->soc;
+	if (!soc) {
+		dp_mon_filter_err("Soc Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+	/* Enabled the filter */
+	filter.rx_tlv_filter.valid = true;
+
+	dp_mon_filter_set_reset_rx_pkt_log_cbf_dest_2_0(pdev_be, &filter);
+
+	srng_type = DP_MON_FILTER_SRNG_TYPE_RXDMA_MONITOR_STATUS;
+	mon_pdev_be->filter[mode][srng_type] = filter;
 }
 
 void dp_mon_filter_setup_pktlog_hybrid_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_HYBRID_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+		DP_MON_FILTER_SRNG_TYPE_TXMON_DEST;
+	struct dp_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+	struct htt_tx_ring_tlv_filter *tlv_filter = &filter.tx_tlv_filter;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+	/* Enabled the filter */
+	filter.tx_valid = true;
+
+	/* Setup the filter */
+	tlv_filter->utlvs.tx_fes_status_start = 1;
+	tlv_filter->utlvs.tx_fes_status_start_prot = 1;
+	tlv_filter->utlvs.tx_fes_status_prot = 1;
+	tlv_filter->utlvs.tx_fes_status_start_ppdu = 1;
+	tlv_filter->utlvs.tx_fes_status_user_ppdu = 1;
+	tlv_filter->utlvs.tx_fes_status_ack_or_ba = 1;
+	tlv_filter->utlvs.tx_fes_status_1k_ba = 1;
+	tlv_filter->utlvs.tx_fes_status_user_response = 1;
+	tlv_filter->utlvs.tx_fes_status_end = 1;
+	tlv_filter->utlvs.response_start_status = 1;
+	tlv_filter->utlvs.recevied_response_info = 1;
+	tlv_filter->utlvs.recevied_response_info_p2 = 1;
+	tlv_filter->utlvs.response_end_status = 1;
+
+	dp_mon_filter_show_filter_be(mon_pdev_be, mode, &filter);
+	mon_pdev_be->filter_be[mode][srng_type] = filter;
 }
 
 void dp_mon_filter_reset_pktlog_hybrid_2_0(struct dp_pdev *pdev)
 {
+	struct dp_mon_filter_be filter = {0};
+	enum dp_mon_filter_mode mode = DP_MON_FILTER_PKT_LOG_HYBRID_MODE;
+	enum dp_mon_filter_srng_type srng_type =
+		DP_MON_FILTER_SRNG_TYPE_TXMON_DEST;
+	struct dp_pdev_be *pdev_be;
+	struct dp_mon_pdev_be *mon_pdev_be;
+
+	if (!pdev) {
+		dp_mon_filter_err("pdev Context is null");
+		return;
+	}
+
+	pdev_be = (struct dp_pdev_be *)pdev;
+	mon_pdev_be = pdev_be->monitor_pdev_be;
+
+	mon_pdev_be->filter_be[mode][srng_type] = filter;
 }
 #endif /* WDI_EVENT_ENABLE */
 

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

@@ -19,18 +19,6 @@
 
 #include <dp_htt.h>
 
-/**
- * struct dp_mon_filter_be - Monitor TLV filter
- * @rx_tlv_filter: Rx MON TLV filter
- * @tx_tlv_filter: Tx MON TLV filter
- * @tx_valid: enable/disable Tx Mon TLV filter
- */
-struct dp_mon_filter_be {
-	struct dp_mon_filter rx_tlv_filter;
-	struct htt_tx_ring_tlv_filter tx_tlv_filter;
-	int tx_valid;
-};
-
 /**
  * dp_rx_mon_packet_length_set() - Setup rx monitor per packet type length
  * @msg_word: msg word

dp/wifi3.0/monitor/dp_mon_filter.h

@@ -60,6 +60,8 @@ struct dp_mon_filter {
  * @DP_MON_FILTER_RX_CAPTURE_MODE: Rx Capture mode
  * @DP_MON_FILTER_PKT_LOG_FULL_MODE: Packet log full mode
  * @DP_MON_FILTER_PKT_LOG_LITE_MODE: Packet log lite mode
+ * @DP_MON_FILTER_PKT_LOG_CBF_MODE: Packet log cbf mode
+ * @DP_MON_FILTER_PKT_LOG_HYBRID_MODE: Packet log hybrid mode
  */
 enum dp_mon_filter_mode {
 #ifdef QCA_ENHANCED_STATS_SUPPORT