qcacld-3.0: Process Rx data packet for pkt capture mode

Subscribe for Tx data wdi event and process Rx data packets
and post into mon thread for packet capture mode

Change-Id: I1a2930110bebc152db32cb2c1f1bc1120fc29755
CRs-Fixed: 2845597

components/pkt_capture/core/inc/wlan_pkt_capture_data_txrx.h

@@ -74,6 +74,8 @@ void pkt_capture_datapkt_process(
 			uint8_t tid, uint8_t status, bool pktformat,
 			uint8_t *bssid, void *pdev,
 			uint8_t tx_retry_cnt);
+
+#ifndef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
 /**
  * pkt_capture_msdu_process_pkts() - process data rx pkts
  * @bssid: bssid
@@ -88,6 +90,13 @@ void pkt_capture_msdu_process_pkts(
 			qdf_nbuf_t head_msdu,
 			uint8_t vdev_id,
 			htt_pdev_handle pdev);
+#else
+void pkt_capture_msdu_process_pkts(
+			uint8_t *bssid,
+			qdf_nbuf_t head_msdu,
+			uint8_t vdev_id,
+			void *psoc);
+#endif
 
 /**
  * pkt_capture_rx_in_order_drop_offload_pkt() - drop offload packets

components/pkt_capture/core/src/wlan_pkt_capture_data_txrx.c

@@ -27,6 +27,10 @@
 #include <wlan_reg_services_api.h>
 #include <cds_ieee80211_common.h>
 #include <ol_txrx_htt_api.h>
+#ifdef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
+#include "dp_internal.h"
+#include "cds_utils.h"
+#endif
 
 #define RESERVE_BYTES (100)
 
@@ -265,6 +269,7 @@ pkt_capture_update_tx_status(
 }
 #endif
 
+#ifndef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
 /**
  * pkt_capture_rx_convert8023to80211() - convert 802.3 packet to 802.11
  * format from rx desc
@@ -375,6 +380,82 @@ pkt_capture_rx_convert8023to80211(uint8_t *bssid, qdf_nbuf_t msdu, void *desc)
 	qdf_nbuf_push_head(msdu, new_hdsize);
 	qdf_mem_copy(qdf_nbuf_data(msdu), localbuf, new_hdsize);
 }
+#else
+static void
+pkt_capture_rx_convert8023to80211(hal_soc_handle_t hal_soc_hdl,
+				  qdf_nbuf_t msdu, void *desc)
+{
+	struct ethernet_hdr_t *eth_hdr;
+	struct llc_snap_hdr_t *llc_hdr;
+	struct ieee80211_frame *wh;
+	uint8_t *pwh;
+	uint8_t hdsize, new_hdsize;
+	struct ieee80211_qoscntl *qos_cntl;
+	uint8_t localbuf[sizeof(struct ieee80211_qosframe_htc_addr4) +
+			sizeof(struct llc_snap_hdr_t)];
+	const uint8_t ethernet_II_llc_snap_header_prefix[] = {
+					0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
+	uint16_t ether_type;
+
+	uint32_t tid = 0;
+
+	eth_hdr = (struct ethernet_hdr_t *)qdf_nbuf_data(msdu);
+	hdsize = sizeof(struct ethernet_hdr_t);
+	pwh = HAL_RX_DESC_GET_80211_HDR(desc);
+
+	wh = (struct ieee80211_frame *)localbuf;
+
+	new_hdsize = sizeof(struct ieee80211_frame);
+
+	qdf_mem_copy(localbuf, pwh, new_hdsize);
+	wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
+
+	if (wh->i_fc[0] & QDF_IEEE80211_FC0_SUBTYPE_QOS) {
+		qos_cntl =
+		(struct ieee80211_qoscntl *)(localbuf + new_hdsize);
+		tid = hal_rx_mpdu_start_tid_get(hal_soc_hdl, desc);
+		qos_cntl->i_qos[0] = (tid & IEEE80211_QOS_TID);
+		wh->i_fc[0] |= QDF_IEEE80211_FC0_SUBTYPE_QOS;
+
+		qos_cntl->i_qos[1] = 0;
+		new_hdsize += sizeof(struct ieee80211_qoscntl);
+	}
+
+	/*
+	 * Prepare llc Header
+	 */
+
+	llc_hdr = (struct llc_snap_hdr_t *)(localbuf + new_hdsize);
+	ether_type = (eth_hdr->ethertype[0] << 8) |
+			(eth_hdr->ethertype[1]);
+	if (ether_type >= ETH_P_802_3_MIN) {
+		qdf_mem_copy(llc_hdr,
+			     ethernet_II_llc_snap_header_prefix,
+			     sizeof
+			     (ethernet_II_llc_snap_header_prefix));
+		if (ether_type == ETHERTYPE_AARP ||
+		    ether_type == ETHERTYPE_IPX) {
+			llc_hdr->org_code[2] =
+				BTEP_SNAP_ORGCODE_2;
+			/* 0xf8; bridge tunnel header */
+		}
+		llc_hdr->ethertype[0] = eth_hdr->ethertype[0];
+		llc_hdr->ethertype[1] = eth_hdr->ethertype[1];
+		new_hdsize += sizeof(struct llc_snap_hdr_t);
+	}
+
+	/*
+	 * Remove 802.3 Header by adjusting the head
+	 */
+	qdf_nbuf_pull_head(msdu, hdsize);
+
+	/*
+	 * Adjust the head and prepare 802.11 Header
+	 */
+	qdf_nbuf_push_head(msdu, new_hdsize);
+	qdf_mem_copy(qdf_nbuf_data(msdu), localbuf, new_hdsize);
+}
+#endif
 
 void pkt_capture_rx_in_order_drop_offload_pkt(qdf_nbuf_t head_msdu)
 {
@@ -397,6 +478,7 @@ bool pkt_capture_rx_in_order_offloaded_pkt(qdf_nbuf_t rx_ind_msg)
 					(*(msg_word + 1));
 }
 
+#ifndef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
 void pkt_capture_msdu_process_pkts(
 				uint8_t *bssid,
 				qdf_nbuf_t head_msdu,
@@ -435,7 +517,207 @@ void pkt_capture_msdu_process_pkts(
 			TXRX_PKTCAPTURE_PKT_FORMAT_8023,
 			bssid, pdev, 0);
 }
+#else
+void pkt_capture_msdu_process_pkts(
+				uint8_t *bssid,
+				qdf_nbuf_t head_msdu,
+				uint8_t vdev_id, void *psoc)
+{
+	qdf_nbuf_t loop_msdu, pktcapture_msdu;
+	qdf_nbuf_t msdu, prev = NULL;
+
+	pktcapture_msdu = NULL;
+	loop_msdu = head_msdu;
+	while (loop_msdu) {
+		msdu = qdf_nbuf_copy(loop_msdu);
+
+		if (msdu) {
+			qdf_nbuf_set_next(msdu, NULL);
+
+			if (!(pktcapture_msdu)) {
+				pktcapture_msdu = msdu;
+				prev = msdu;
+			} else {
+				qdf_nbuf_set_next(prev, msdu);
+				prev = msdu;
+			}
+		}
+		loop_msdu = qdf_nbuf_next(loop_msdu);
+	}
+
+	if (!pktcapture_msdu)
+		return;
+
+	pkt_capture_datapkt_process(
+			vdev_id, pktcapture_msdu,
+			TXRX_PROCESS_TYPE_DATA_RX, 0, 0,
+			TXRX_PKTCAPTURE_PKT_FORMAT_8023,
+			bssid, psoc, 0);
+}
+#endif
 
+#ifdef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
+/**
+ * pkt_capture_dp_rx_skip_tlvs() - Skip TLVs len + L2 hdr_offset, save in nbuf
+ * @nbuf: nbuf to be updated
+ * @l3_padding: l3_padding
+ *
+ * Return: None
+ */
+static void pkt_capture_dp_rx_skip_tlvs(qdf_nbuf_t nbuf, uint32_t l3_padding)
+{
+	QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding;
+	qdf_nbuf_pull_head(nbuf, l3_padding + RX_PKT_TLVS_LEN);
+}
+
+/**
+ * pkt_capture_rx_get_phy_info() - Get phy info
+ * @psoc: dp_soc handle
+ * @rx_tlv_hdr: Pointer to struct rx_pkt_tlvs
+ * @rx_status: Pointer to struct mon_rx_status
+ *
+ * Return: none
+ */
+static void pkt_capture_rx_get_phy_info(void *psoc,
+					uint8_t *rx_tlv_hdr,
+					struct mon_rx_status *rx_status)
+{
+	uint8_t preamble = 0;
+	uint8_t preamble_type;
+	uint8_t mcs = 0, nss = 0, sgi = 0, bw = 0;
+	uint8_t beamformed = 0;
+	uint16_t vht_flags = 0, ht_flags = 0, he_flags = 0;
+	bool is_stbc = 0, ldpc = 0;
+	struct dp_soc *soc = psoc;
+	hal_soc_handle_t hal_soc;
+
+	hal_soc = soc->hal_soc;
+	preamble_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr);
+	nss = hal_rx_msdu_start_nss_get(hal_soc, rx_tlv_hdr); /* NSS */
+	bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr);
+	mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr);
+	sgi = hal_rx_msdu_start_sgi_get(rx_tlv_hdr);
+
+	switch (preamble_type) {
+	case HAL_RX_PKT_TYPE_11A:
+	case HAL_RX_PKT_TYPE_11B:
+	/* legacy */
+		rx_status->rate = pkt_capture_get_tx_rate(
+						preamble_type,
+						mcs,
+						&preamble);
+
+		break;
+	case HAL_RX_PKT_TYPE_11N:
+		ht_flags = 1;
+		if (nss == 2)
+			mcs = 8 + mcs;
+		break;
+	case HAL_RX_PKT_TYPE_11AC:
+		vht_flags = 1;
+		break;
+	case HAL_RX_PKT_TYPE_11AX:
+		he_flags = 1;
+	default:
+		break;
+	}
+
+	if (preamble == 0)
+		rx_status->ofdm_flag = 1;
+	else if (preamble == 1)
+		rx_status->cck_flag = 1;
+
+	rx_status->mcs = mcs;
+	rx_status->bw = bw;
+	rx_status->nr_ant = nss;
+	/* is_stbc not available */
+	rx_status->is_stbc = is_stbc;
+	rx_status->sgi = sgi;
+	/* ldpc not available */
+	rx_status->ldpc = ldpc;
+	/* beamformed not available */
+	rx_status->beamformed = beamformed;
+	rx_status->vht_flag_values3[0] = mcs << 0x4 | (nss + 1);
+	rx_status->ht_flags = ht_flags;
+	rx_status->vht_flags = vht_flags;
+	rx_status->he_flags = he_flags;
+	rx_status->rtap_flags |= ((preamble == SHORT_PREAMBLE) ? BIT(1) : 0);
+	if (bw == 0)
+		rx_status->vht_flag_values2 = 0;
+	else if (bw == 1)
+		rx_status->vht_flag_values2 = 1;
+	else if (bw == 2)
+		rx_status->vht_flag_values2 = 4;
+
+	if (ht_flags)
+		rx_status->ht_mcs = mcs;
+}
+
+/**
+ * pkt_capture_get_rx_rtap_flags() - Get radiotap flags
+ * @ptr_rx_tlv_hdr: Pointer to struct rx_pkt_tlvs
+ *
+ * Return: Bitmapped radiotap flags.
+ */
+static uint8_t pkt_capture_get_rx_rtap_flags(void *ptr_rx_tlv_hdr)
+{
+	struct rx_pkt_tlvs *rx_tlv_hdr = (struct rx_pkt_tlvs *)ptr_rx_tlv_hdr;
+	struct rx_attention *rx_attn = &rx_tlv_hdr->attn_tlv.rx_attn;
+	struct rx_mpdu_start *mpdu_start =
+				&rx_tlv_hdr->mpdu_start_tlv.rx_mpdu_start;
+	struct rx_mpdu_end *mpdu_end = &rx_tlv_hdr->mpdu_end_tlv.rx_mpdu_end;
+	uint8_t rtap_flags = 0;
+
+	/* WEP40 || WEP104 || WEP128 */
+	if (mpdu_start->rx_mpdu_info_details.encrypt_type == 0 ||
+	    mpdu_start->rx_mpdu_info_details.encrypt_type == 1 ||
+	    mpdu_start->rx_mpdu_info_details.encrypt_type == 3)
+		rtap_flags |= BIT(2);
+
+	/* IEEE80211_RADIOTAP_F_FRAG */
+	if (rx_attn->fragment_flag)
+		rtap_flags |= BIT(3);
+
+	/* IEEE80211_RADIOTAP_F_FCS */
+	rtap_flags |= BIT(4);
+
+	/* IEEE80211_RADIOTAP_F_BADFCS */
+	if (mpdu_end->fcs_err)
+		rtap_flags |= BIT(6);
+
+	return rtap_flags;
+}
+
+#define CHANNEL_FREQ_5150 5150
+/**
+ * pkt_capture_rx_mon_get_rx_status() - Get rx status
+ * @psoc: dp_soc handle
+ * @desc: Pointer to struct rx_pkt_tlvs
+ * @rx_status: Pointer to struct mon_rx_status
+ *
+ * Return: none
+ */
+static void pkt_capture_rx_mon_get_rx_status(void *psoc, void *desc,
+					     struct mon_rx_status *rx_status)
+{
+	uint8_t *rx_tlv_hdr = desc;
+
+	rx_status->rtap_flags |= pkt_capture_get_rx_rtap_flags(rx_tlv_hdr);
+	rx_status->chan_freq = hal_rx_msdu_start_get_freq(rx_tlv_hdr) >> 16;
+	rx_status->chan_num = cds_freq_to_chan(rx_status->chan_freq);
+	rx_status->ant_signal_db = hal_rx_msdu_start_get_rssi(rx_tlv_hdr);
+	rx_status->rssi_comb = hal_rx_msdu_start_get_rssi(rx_tlv_hdr);
+
+	if (rx_status->chan_freq > CHANNEL_FREQ_5150)
+		rx_status->ofdm_flag = 1;
+	else
+		rx_status->cck_flag = 1;
+
+	pkt_capture_rx_get_phy_info(psoc, desc, rx_status);
+}
+#endif
+
+#ifndef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
 /**
  * pkt_capture_rx_data_cb(): callback to process data rx packets
  * for pkt capture mode. (normal rx + offloaded rx)
@@ -558,6 +840,112 @@ pkt_capture_rx_data_cb(
 free_buf:
 	drop_count = pkt_capture_drop_nbuf_list(buf_list);
 }
+#else
+/**
+ * pkt_capture_rx_data_cb(): callback to process data rx packets
+ * for pkt capture mode. (normal rx + offloaded rx)
+ * @context: objmgr vdev
+ * @psoc: dp_soc handle
+ * @nbuf_list: netbuf list
+ * @vdev_id: vdev id for which packet is captured
+ * @tid:  tid number
+ * @status: Tx status
+ * @pkt_format: Frame format
+ * @bssid: bssid
+ * @tx_retry_cnt: tx retry count
+ *
+ * Return: none
+ */
+static void
+pkt_capture_rx_data_cb(
+		void *context, void *psoc, void *nbuf_list,
+		uint8_t vdev_id, uint8_t tid,
+		uint16_t status, bool pkt_format,
+		uint8_t *bssid, uint8_t tx_retry_cnt)
+{
+	struct pkt_capture_vdev_priv *vdev_priv;
+	qdf_nbuf_t buf_list = (qdf_nbuf_t)nbuf_list;
+	struct wlan_objmgr_vdev *vdev = context;
+	struct pkt_capture_cb_context *cb_ctx;
+	qdf_nbuf_t msdu, next_buf;
+	uint8_t drop_count;
+	struct mon_rx_status rx_status = {0};
+	uint32_t headroom;
+	uint8_t *rx_tlv_hdr = NULL;
+	struct dp_soc *soc = psoc;
+	hal_soc_handle_t hal_soc;
+	struct hal_rx_msdu_metadata msdu_metadata;
+
+	vdev_priv = pkt_capture_vdev_get_priv(vdev);
+	if (qdf_unlikely(!vdev))
+		goto free_buf;
+
+	cb_ctx = vdev_priv->cb_ctx;
+	if (!cb_ctx || !cb_ctx->mon_cb || !cb_ctx->mon_ctx)
+		goto free_buf;
+
+	hal_soc = soc->hal_soc;
+	msdu = buf_list;
+	while (msdu) {
+		struct ethernet_hdr_t *eth_hdr;
+
+		/* push the tlvs to get rx_tlv_hdr pointer */
+		qdf_nbuf_push_head(msdu, RX_PKT_TLVS_LEN +
+				QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(msdu));
+
+		rx_tlv_hdr = qdf_nbuf_data(msdu);
+		hal_rx_msdu_metadata_get(hal_soc, rx_tlv_hdr, &msdu_metadata);
+		/* Pull rx_tlv_hdr */
+		pkt_capture_dp_rx_skip_tlvs(msdu, msdu_metadata.l3_hdr_pad);
+
+		next_buf = qdf_nbuf_queue_next(msdu);
+		qdf_nbuf_set_next(msdu, NULL);   /* Add NULL terminator */
+
+		/*
+		 * Get the channel info and update the rx status
+		 */
+
+		/* need to update this to fill rx_status*/
+		pkt_capture_rx_mon_get_rx_status(psoc, rx_tlv_hdr, &rx_status);
+		/* timestamp not available */
+		rx_status.tsft = qdf_nbuf_get_timestamp(msdu);
+		rx_status.chan_noise_floor = NORMALIZED_TO_NOISE_FLOOR;
+		rx_status.tx_status = status;
+		rx_status.tx_retry_cnt = tx_retry_cnt;
+		rx_status.add_rtap_ext = true;
+
+		/* clear IEEE80211_RADIOTAP_F_FCS flag*/
+		rx_status.rtap_flags &= ~(BIT(4));
+		rx_status.rtap_flags &= ~(BIT(2));
+
+		/*
+		 * convert 802.3 header format into 802.11 format
+		 */
+		if (vdev_id == HTT_INVALID_VDEV) {
+			eth_hdr = (struct ethernet_hdr_t *)qdf_nbuf_data(msdu);
+			qdf_mem_copy(bssid, eth_hdr->src_addr,
+				     QDF_MAC_ADDR_SIZE);
+		}
+
+		pkt_capture_rx_convert8023to80211(hal_soc, msdu, rx_tlv_hdr);
+
+		/*
+		 * Calculate the headroom and adjust head
+		 * to prepare radiotap header.
+		 */
+		headroom = qdf_nbuf_headroom(msdu);
+		qdf_nbuf_update_radiotap(&rx_status, msdu, headroom);
+		pkt_capture_mon(cb_ctx, msdu, vdev, 0);
+		msdu = next_buf;
+	}
+
+	return;
+
+free_buf:
+	drop_count = pkt_capture_drop_nbuf_list(buf_list);
+}
+
+#endif
 
 #ifndef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
 /**

components/pkt_capture/core/src/wlan_pkt_capture_main.c

@@ -36,6 +36,7 @@ static struct wlan_objmgr_vdev *gp_pkt_capture_vdev;
 
 #ifdef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
 wdi_event_subscribe PKT_CAPTURE_TX_SUBSCRIBER;
+wdi_event_subscribe PKT_CAPTURE_RX_SUBSCRIBER;
 
 /**
  * pkt_capture_wdi_event_subscribe() - Subscribe pkt capture callbacks
@@ -48,6 +49,7 @@ static void pkt_capture_wdi_event_subscribe(struct wlan_objmgr_psoc *psoc)
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	uint8_t pdev_id = WMI_PDEV_ID_SOC;
 
+	/* subscribing for tx data packets */
 	PKT_CAPTURE_TX_SUBSCRIBER.callback =
 				pkt_capture_callback;
 
@@ -55,6 +57,16 @@ static void pkt_capture_wdi_event_subscribe(struct wlan_objmgr_psoc *psoc)
 
 	cdp_wdi_event_sub(soc, pdev_id, &PKT_CAPTURE_TX_SUBSCRIBER,
 			  WDI_EVENT_PKT_CAPTURE_TX_DATA);
+
+	/* subscribing for rx data packets */
+	PKT_CAPTURE_RX_SUBSCRIBER.callback =
+				pkt_capture_callback;
+
+	PKT_CAPTURE_RX_SUBSCRIBER.context = wlan_psoc_get_dp_handle(psoc);
+
+	cdp_wdi_event_sub(soc, pdev_id, &PKT_CAPTURE_RX_SUBSCRIBER,
+			  WDI_EVENT_PKT_CAPTURE_RX_DATA);
+
 }
 
 /**
@@ -68,8 +80,13 @@ static void pkt_capture_wdi_event_unsubscribe(struct wlan_objmgr_psoc *psoc)
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	uint8_t pdev_id = WMI_PDEV_ID_SOC;
 
+	/* unsubscribing for tx data packets */
 	cdp_wdi_event_unsub(soc, pdev_id, &PKT_CAPTURE_TX_SUBSCRIBER,
 			    WDI_EVENT_PKT_CAPTURE_TX_DATA);
+
+	/* unsubscribing for rx data packets */
+	cdp_wdi_event_unsub(soc, pdev_id, &PKT_CAPTURE_RX_SUBSCRIBER,
+			    WDI_EVENT_PKT_CAPTURE_RX_DATA);
 }
 
 enum pkt_capture_mode
@@ -179,6 +196,16 @@ void pkt_capture_callback(void *soc, enum WDI_EVENT event, void *log_data,
 		break;
 	}
 
+	case WDI_EVENT_PKT_CAPTURE_RX_DATA:
+	{
+		if (!(pkt_capture_get_pktcap_mode_lithium() &
+					PKT_CAPTURE_MODE_DATA_ONLY))
+			return;
+
+		pkt_capture_msdu_process_pkts(bssid, log_data, vdev_id, soc);
+		break;
+	}
+
 	default:
 		break;
 	}