android_kernel_samsung_sm8650-modules/dp/wifi3.0/dp_tx_capture.c

/*
 * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include <htt.h>
#include "qdf_trace.h"
#include "qdf_nbuf.h"
#include "dp_peer.h"
#include "dp_types.h"
#include "dp_internal.h"
#include "dp_rx_mon.h"
#include "htt_ppdu_stats.h"
#include "dp_htt.h"
#include "qdf_mem.h"   /* qdf_mem_malloc,free */
#include "cdp_txrx_cmn_struct.h"
#include <enet.h>

#include "dp_tx_capture.h"

#define MAX_MONITOR_HEADER (512)
#define MAX_DUMMY_FRM_BODY (128)

#ifdef WLAN_TX_PKT_CAPTURE_ENH
/**
 * dp_peer_or_pdev_tx_cap_enabled - Returns status of tx_cap_enabled
 * based on global per-pdev setting or per-peer setting
 * @pdev: Datapath pdev handle
 * @peer: Datapath peer
 *
 * Return: true if feature is enabled on a per-pdev basis or if
 * enabled for the given peer when per-peer mode is set, false otherwise
 */
inline bool
dp_peer_or_pdev_tx_cap_enabled(struct dp_pdev *pdev,
			       struct dp_peer *peer)
{
	if ((pdev->tx_capture_enabled ==
	     CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS) ||
	    ((pdev->tx_capture_enabled ==
	      CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) &&
	     peer->tx_cap_enabled))
		return true;
	return false;
}

/*
 * dp_peer_tid_queue_init() – Initialize ppdu stats queue per TID
 * @peer: Datapath peer
 *
 */
void dp_peer_tid_queue_init(struct dp_peer *peer)
{
	int tid;
	struct dp_tx_tid *tx_tid;

	for (tid = 0; tid < DP_MAX_TIDS; tid++) {
		tx_tid = &peer->tx_capture.tx_tid[tid];
		tx_tid->tid = tid;
		qdf_nbuf_queue_init(&tx_tid->msdu_comp_q);
		tx_tid->max_ppdu_id = 0;

		/* spinlock create */
		qdf_spinlock_create(&tx_tid->tid_lock);
	}
}

/*
 * dp_peer_tid_queue_cleanup() – remove ppdu stats queue per TID
 * @peer: Datapath peer
 *
 */
void dp_peer_tid_queue_cleanup(struct dp_peer *peer)
{
	int tid;
	struct dp_tx_tid *tx_tid;

	for (tid = 0; tid < DP_MAX_TIDS; tid++) {
		tx_tid = &peer->tx_capture.tx_tid[tid];

		qdf_spin_lock_bh(&tx_tid->tid_lock);
		qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
		qdf_spin_unlock_bh(&tx_tid->tid_lock);

		/* spinlock destroy */
		qdf_spinlock_destroy(&tx_tid->tid_lock);
		tx_tid->max_ppdu_id = 0;
	}
}

/*
 * dp_peer_update_80211_hdr: update 80211 hdr
 * @vdev: DP VDEV
 * @peer: DP PEER
 *
 * return: void
 */
void dp_peer_update_80211_hdr(struct dp_vdev *vdev, struct dp_peer *peer)
{
	struct ieee80211_frame *ptr_wh;

	ptr_wh = &peer->tx_capture.tx_wifi_hdr;

	/* i_addr1 - Receiver mac address */
	/* i_addr2 - Transmitter mac address */
	/* i_addr3 - Destination mac address */

	qdf_mem_copy(ptr_wh->i_addr1,
		     peer->mac_addr.raw,
		     QDF_MAC_ADDR_SIZE);
	qdf_mem_copy(ptr_wh->i_addr3,
		     peer->mac_addr.raw,
		     QDF_MAC_ADDR_SIZE);
	qdf_mem_copy(ptr_wh->i_addr2,
		     vdev->mac_addr.raw,
		     QDF_MAC_ADDR_SIZE);
}

/*
 * dp_deliver_mgmt_frm: Process
 * @pdev: DP PDEV handle
 * @nbuf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
 *
 * return: void
 */
void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
{
	uint32_t ppdu_id;

	if (pdev->tx_sniffer_enable || pdev->mcopy_mode) {
		dp_wdi_event_handler(WDI_EVENT_TX_MGMT_CTRL, pdev->soc,
				     nbuf, HTT_INVALID_PEER,
				     WDI_NO_VAL, pdev->pdev_id);
		return;
	}
	if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
	    pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
		/* invoke WDI event handler here send mgmt pkt here */
		struct ieee80211_frame *wh;
		uint8_t type, subtype;

		ppdu_id = *(uint32_t *)qdf_nbuf_data(nbuf);
		wh = (struct ieee80211_frame *)(qdf_nbuf_data(nbuf) +
			sizeof(uint32_t));
		type = (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) >>
			IEEE80211_FC0_TYPE_SHIFT;
		subtype = (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >>
			IEEE80211_FC0_SUBTYPE_SHIFT;
		qdf_spin_lock_bh(
			&pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
		qdf_nbuf_queue_add(&pdev->tx_capture.ctl_mgmt_q[type][subtype],
			nbuf);
		qdf_spin_unlock_bh(
			&pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
			"dlvr mgmt frm(0x%08x): fc 0x%x %x, dur 0x%x%x\n",
			ppdu_id, wh->i_fc[1], wh->i_fc[0],
			wh->i_dur[1], wh->i_dur[0]);
	}
}

/**
 * dp_tx_ppdu_stats_attach - Initialize Tx PPDU stats and enhanced capture
 * @pdev: DP PDEV
 *
 * Return: none
 */
void dp_tx_ppdu_stats_attach(struct dp_pdev *pdev)
{
	int i, j;
	/* Work queue setup for HTT stats and tx capture handling */
	qdf_create_work(0, &pdev->tx_capture.ppdu_stats_work,
			dp_tx_ppdu_stats_process,
			pdev);
	pdev->tx_capture.ppdu_stats_workqueue =
		qdf_alloc_unbound_workqueue("ppdu_stats_work_queue");
	STAILQ_INIT(&pdev->tx_capture.ppdu_stats_queue);
	STAILQ_INIT(&pdev->tx_capture.ppdu_stats_defer_queue);
	qdf_spinlock_create(&pdev->tx_capture.ppdu_stats_lock);
	pdev->tx_capture.ppdu_stats_queue_depth = 0;
	pdev->tx_capture.ppdu_stats_next_sched = 0;
	pdev->tx_capture.ppdu_stats_defer_queue_depth = 0;
	pdev->tx_capture.ppdu_dropped = 0;
	for (i = 0; i < TXCAP_MAX_TYPE; i++) {
		for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
			qdf_nbuf_queue_init(
				&pdev->tx_capture.ctl_mgmt_q[i][j]);
			qdf_spinlock_create(
				&pdev->tx_capture.ctl_mgmt_lock[i][j]);
		}
	}
}

/**
 * dp_tx_ppdu_stats_detach - Cleanup Tx PPDU stats and enhanced capture
 * @pdev: DP PDEV
 *
 * Return: none
 */
void dp_tx_ppdu_stats_detach(struct dp_pdev *pdev)
{
	struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
	int i, j;

	if (!pdev || !pdev->tx_capture.ppdu_stats_workqueue)
		return;

	qdf_flush_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
	qdf_destroy_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);

	qdf_spinlock_destroy(&pdev->tx_capture.ppdu_stats_lock);

	STAILQ_FOREACH_SAFE(ppdu_info,
			    &pdev->tx_capture.ppdu_stats_queue,
			    ppdu_info_queue_elem, tmp_ppdu_info) {
		STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_queue,
			      ppdu_info, ppdu_info, ppdu_info_queue_elem);
		qdf_nbuf_free(ppdu_info->nbuf);
		qdf_mem_free(ppdu_info);
	}

	STAILQ_FOREACH_SAFE(ppdu_info,
			    &pdev->tx_capture.ppdu_stats_defer_queue,
			    ppdu_info_queue_elem, tmp_ppdu_info) {
		STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_defer_queue,
			      ppdu_info, ppdu_info, ppdu_info_queue_elem);
		qdf_nbuf_free(ppdu_info->nbuf);
		qdf_mem_free(ppdu_info);
	}
	for (i = 0; i < TXCAP_MAX_TYPE; i++) {
		for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
			qdf_spin_lock_bh(
				&pdev->tx_capture.ctl_mgmt_lock[i][j]);
			qdf_nbuf_queue_free(
				&pdev->tx_capture.ctl_mgmt_q[i][j]);
			qdf_spin_unlock_bh(
				&pdev->tx_capture.ctl_mgmt_lock[i][j]);
			qdf_spinlock_destroy(
				&pdev->tx_capture.ctl_mgmt_lock[i][j]);
		}
	}
}

/**
 * dp_update_msdu_to_list(): Function to queue msdu from wbm
 * @pdev: dp_pdev
 * @peer: dp_peer
 * @ts: hal tx completion status
 * @netbuf: msdu
 *
 * return: status
 */
QDF_STATUS
dp_update_msdu_to_list(struct dp_soc *soc,
		       struct dp_pdev *pdev,
		       struct dp_peer *peer,
		       struct hal_tx_completion_status *ts,
		       qdf_nbuf_t netbuf)
{
	struct dp_tx_tid *tx_tid;
	struct msdu_completion_info *msdu_comp_info;

	if (!peer) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: %d peer NULL !", __func__, __LINE__);
		return QDF_STATUS_E_FAILURE;
	}

	if (ts->tid > DP_NON_QOS_TID) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: %d peer_id %d, tid %d > NON_QOS_TID!",
			  __func__, __LINE__, ts->peer_id, ts->tid);
		return QDF_STATUS_E_FAILURE;
	}

	tx_tid = &peer->tx_capture.tx_tid[ts->tid];

	if (!tx_tid) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: %d tid[%d] NULL !", __func__, __LINE__, ts->tid);
		return QDF_STATUS_E_FAILURE;
	}

	qdf_nbuf_unmap(soc->osdev, netbuf, QDF_DMA_TO_DEVICE);

	if (!qdf_nbuf_push_head(netbuf, sizeof(struct msdu_completion_info))) {
		QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
			  FL("No headroom"));
		return QDF_STATUS_E_NOMEM;
	}

	msdu_comp_info = (struct msdu_completion_info *)qdf_nbuf_data(netbuf);

	/* copy msdu_completion_info to control buffer */
	msdu_comp_info->ppdu_id = ts->ppdu_id;
	msdu_comp_info->peer_id = ts->peer_id;
	msdu_comp_info->tid = ts->tid;
	msdu_comp_info->first_msdu = ts->first_msdu;
	msdu_comp_info->last_msdu = ts->last_msdu;
	msdu_comp_info->msdu_part_of_amsdu = ts->msdu_part_of_amsdu;
	msdu_comp_info->transmit_cnt = ts->transmit_cnt;
	msdu_comp_info->tsf = ts->tsf;

	/* update max ppdu_id */
	tx_tid->max_ppdu_id = ts->ppdu_id;
	pdev->tx_capture.last_msdu_id = ts->ppdu_id;

	QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
		  "msdu_completion: ppdu_id[%d] peer_id[%d] tid[%d] rel_src[%d] status[%d] tsf[%u] A[%d] CNT[%d]",
		  ts->ppdu_id, ts->peer_id, ts->tid, ts->release_src,
		  ts->status, ts->tsf, ts->msdu_part_of_amsdu,
		  ts->transmit_cnt);

	/* lock here */
	qdf_spin_lock_bh(&tx_tid->tid_lock);

	/* add nbuf to tail queue per peer tid */
	qdf_nbuf_queue_add(&tx_tid->msdu_comp_q, netbuf);

	qdf_spin_unlock_bh(&tx_tid->tid_lock);

	return QDF_STATUS_SUCCESS;
}

/**
 * dp_tx_add_to_comp_queue() - add completion msdu to queue
 * @soc: DP Soc handle
 * @tx_desc: software Tx descriptor
 * @ts : Tx completion status from HAL/HTT descriptor
 * @peer: DP peer
 *
 * Return: none
 */
QDF_STATUS dp_tx_add_to_comp_queue(struct dp_soc *soc,
				   struct dp_tx_desc_s *desc,
				   struct hal_tx_completion_status *ts,
				   struct dp_peer *peer)
{
	int ret = QDF_STATUS_E_FAILURE;

	if (desc->pdev->tx_capture_enabled != CDP_TX_ENH_CAPTURE_DISABLED &&
	    ts->status == HAL_TX_TQM_RR_FRAME_ACKED) {
		ret = dp_update_msdu_to_list(soc, desc->pdev,
					     peer, ts, desc->nbuf);
	}
	return ret;
}

/**
 * dp_process_ppdu_stats_update_failed_bitmap(): update failed bitmap
 * @pdev: dp_pdev
 * @data: tx completion ppdu desc
 * @ppdu_id: ppdu id
 * @size: size of bitmap
 *
 * return: status
 */
void dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
						void *data,
						uint32_t ppdu_id,
						uint32_t size)
{
	struct cdp_tx_completion_ppdu_user *user;
	uint32_t mpdu_tried;
	uint32_t ba_seq_no;
	uint32_t start_seq;
	uint32_t num_mpdu;
	uint32_t diff;
	uint32_t carry = 0;
	uint32_t bitmask = 0;

	uint32_t i;
	uint32_t k;
	uint32_t ba_bitmap = 0;

	user = (struct cdp_tx_completion_ppdu_user *)data;

	/* get number of mpdu from ppdu_desc */
	mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;

	ba_seq_no = user->ba_seq_no;
	start_seq = user->start_seq;
	num_mpdu = user->num_mpdu;

	/* assumption: number of mpdu will be less than 32 */

	QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
		  "ppdu_id[%d] ba_seq_no[%d] start_seq_no[%d] mpdu_tried[%d]",
		  ppdu_id, ba_seq_no, start_seq, mpdu_tried);

	for (i = 0; i < size; i++) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
			  "ppdu_id[%d] ba_bitmap[%x] enqueue_bitmap[%x]",
			  ppdu_id, user->ba_bitmap[i], user->enq_bitmap[i]);
	}

	if (start_seq <= ba_seq_no) {
		diff = ba_seq_no - start_seq;
		bitmask = (1 << diff) - 1;
		for (i = 0; i < size; i++) {
			ba_bitmap = user->ba_bitmap[i];

			user->failed_bitmap[i] = (ba_bitmap << diff);
			user->failed_bitmap[i] |= (bitmask & carry);

			carry = ((ba_bitmap & (bitmask << (32 - diff))) >>
				(32 - diff));

			user->failed_bitmap[i] = user->enq_bitmap[i] &
						 user->failed_bitmap[i];
		}
	} else {
		diff = start_seq - ba_seq_no;
		/* array index */
		k = diff >> 5;
		diff = diff & 0x1F;

		bitmask = (1 << diff) - 1;
		for (i = 0; i < size; i++, k++) {
			ba_bitmap = user->ba_bitmap[k];
			user->failed_bitmap[i] = ba_bitmap >> diff;
			/* get next ba_bitmap */
			ba_bitmap = user->ba_bitmap[k + 1];
			carry = (ba_bitmap & bitmask);
			user->failed_bitmap[i] |=
				((carry & bitmask) << (32 - diff));

			user->failed_bitmap[i] = user->enq_bitmap[i] &
						 user->failed_bitmap[i];
		}
	}
}

/*
 * dp_soc_set_txrx_ring_map_single()
 * @dp_soc: DP handler for soc
 *
 * Return: Void
 */
static void dp_soc_set_txrx_ring_map_single(struct dp_soc *soc)
{
	uint32_t i;

	for (i = 0; i < WLAN_CFG_INT_NUM_CONTEXTS; i++) {
		soc->tx_ring_map[i] =
			dp_cpu_ring_map[DP_SINGLE_TX_RING_MAP][i];
	}
}

/*
 * dp_iterate_free_peer_msdu_q()- API to free msdu queue
 * @pdev_handle: DP_PDEV handle
 *
 * Return: void
 */
static void  dp_iterate_free_peer_msdu_q(void *pdev_hdl)
{
	struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
	struct dp_soc *soc = pdev->soc;
	struct dp_vdev *vdev = NULL;
	struct dp_peer *peer = NULL;

	qdf_spin_lock_bh(&soc->peer_ref_mutex);
	qdf_spin_lock_bh(&pdev->vdev_list_lock);
	DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
		DP_VDEV_ITERATE_PEER_LIST(vdev, peer) {
			int tid;
			struct dp_tx_tid *tx_tid;

			for (tid = 0; tid < DP_MAX_TIDS; tid++) {
				tx_tid = &peer->tx_capture.tx_tid[tid];

				/* spinlock hold */
				qdf_spin_lock_bh(&tx_tid->tid_lock);
				qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
				qdf_spin_unlock_bh(&tx_tid->tid_lock);
			}
		}
	}
	qdf_spin_unlock_bh(&pdev->vdev_list_lock);
	qdf_spin_unlock_bh(&soc->peer_ref_mutex);
}

/*
 * dp_config_enh_tx_capture()- API to enable/disable enhanced tx capture
 * @pdev_handle: DP_PDEV handle
 * @val: user provided value
 *
 * Return: QDF_STATUS
 */
QDF_STATUS
dp_config_enh_tx_capture(struct cdp_pdev *pdev_handle, uint8_t val)
{
	struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
	int i, j;

	pdev->tx_capture_enabled = val;

	if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
	    pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
		dp_soc_set_txrx_ring_map_single(pdev->soc);
		if (!pdev->pktlog_ppdu_stats)
			dp_h2t_cfg_stats_msg_send(pdev,
						  DP_PPDU_STATS_CFG_SNIFFER,
						  pdev->pdev_id);
	} else {
		dp_soc_set_txrx_ring_map(pdev->soc);
		dp_h2t_cfg_stats_msg_send(pdev,
					  DP_PPDU_STATS_CFG_ENH_STATS,
					  pdev->pdev_id);
		dp_iterate_free_peer_msdu_q(pdev);
		for (i = 0; i < TXCAP_MAX_TYPE; i++) {
			for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
				qdf_spin_lock_bh(
					&pdev->tx_capture.ctl_mgmt_lock[i][j]);
				qdf_nbuf_queue_free(
					&pdev->tx_capture.ctl_mgmt_q[i][j]);
				qdf_spin_unlock_bh(
					&pdev->tx_capture.ctl_mgmt_lock[i][j]);
			}
		}
	}

	return QDF_STATUS_SUCCESS;
}

/**
 * get_number_of_1s(): Function to get number of 1s
 * @value: value to find
 *
 * return: number of 1s
 */
static
inline uint32_t get_number_of_1s(uint32_t value)
{
	uint32_t shift[] = {1, 2, 4, 8, 16};
	uint32_t magic_number[] = { 0x55555555, 0x33333333, 0x0F0F0F0F,
				    0x00FF00FF, 0x0000FFFF};
	uint8_t k = 0;

	for (; k <= 4; k++) {
		value = (value & magic_number[k]) +
			((value >> shift[k]) & magic_number[k]);
	}

	return value;
}

/**
 * dp_tx_print_bitmap(): Function to print bitmap
 * @pdev: dp_pdev
 * @ppdu_desc: ppdu completion descriptor
 * @user_inder: user index
 * @ppdu_id: ppdu id
 *
 * return: status
 */
static
QDF_STATUS dp_tx_print_bitmap(struct dp_pdev *pdev,
			      struct cdp_tx_completion_ppdu *ppdu_desc,
			      uint32_t user_index,
			      uint32_t ppdu_id)
{
	struct cdp_tx_completion_ppdu_user *user;
	uint8_t i;
	uint32_t mpdu_tried;
	uint32_t ba_seq_no;
	uint32_t start_seq;
	uint32_t num_mpdu;
	uint32_t fail_num_mpdu = 0;

	user = &ppdu_desc->user[user_index];

	/* get number of mpdu from ppdu_desc */
	mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;

	ba_seq_no = user->ba_seq_no;
	start_seq = user->start_seq;
	num_mpdu = user->mpdu_success;

	if (user->tid > DP_NON_QOS_TID) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
			  __func__, ppdu_id, user->peer_id, user->tid);

		return QDF_STATUS_E_FAILURE;
	}

	if (mpdu_tried != num_mpdu) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
			  "%s: ppdu[%d] peer[%d] tid[%d] ba[%d] start[%d] mpdu_tri[%d] num_mpdu[%d] is_mcast[%d]",
			  __func__, ppdu_id, user->peer_id, user->tid,
			  ba_seq_no, start_seq, mpdu_tried,
			  num_mpdu, user->is_mcast);

		for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++) {
			QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
				  QDF_TRACE_LEVEL_ERROR,
				  "ppdu_id[%d] ba_bitmap[0x%x] enqueue_bitmap[0x%x] failed_bitmap[0x%x]",
				  ppdu_id, user->ba_bitmap[i],
				  user->enq_bitmap[i],
				  user->failed_bitmap[i]);

			fail_num_mpdu +=
				get_number_of_1s(user->failed_bitmap[i]);
		}
	}

	if (fail_num_mpdu == num_mpdu && num_mpdu)
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: %d ppdu_id[%d] num_mpdu[%d, %d]",
			  __func__, __LINE__, ppdu_id, num_mpdu, fail_num_mpdu);

	return QDF_STATUS_SUCCESS;
}

static uint32_t dp_tx_update_80211_hdr(struct dp_pdev *pdev,
				       struct dp_peer *peer,
				       void *data,
				       qdf_nbuf_t nbuf,
				       uint16_t ether_type,
				       uint8_t *src_addr)
{
	struct cdp_tx_completion_ppdu *ppdu_desc;
	struct ieee80211_frame *ptr_wh;
	struct ieee80211_qoscntl *ptr_qoscntl;
	uint32_t mpdu_buf_len;
	uint8_t *ptr_hdr;
	uint16_t eth_type = qdf_htons(ether_type);

	ppdu_desc = (struct cdp_tx_completion_ppdu *)data;
	ptr_wh = &peer->tx_capture.tx_wifi_hdr;
	ptr_qoscntl = &peer->tx_capture.tx_qoscntl;

	/*
	 * update framectrl only for first ppdu_id
	 * rest of mpdu will have same frame ctrl
	 * mac address and duration
	 */
	if (ppdu_desc->ppdu_id != peer->tx_capture.tx_wifi_ppdu_id) {
		ptr_wh->i_fc[1] = (ppdu_desc->frame_ctrl & 0xFF00) >> 8;
		ptr_wh->i_fc[0] = (ppdu_desc->frame_ctrl & 0xFF);

		ptr_wh->i_dur[1] = (ppdu_desc->tx_duration & 0xFF00) >> 8;
		ptr_wh->i_dur[0] = (ppdu_desc->tx_duration & 0xFF);

		ptr_qoscntl->i_qos[1] = (ppdu_desc->user[0].qos_ctrl &
					 0xFF00) >> 8;
		ptr_qoscntl->i_qos[0] = (ppdu_desc->user[0].qos_ctrl & 0xFF);
		/* Update Addr 3 (SA) with SA derived from ether packet */
		qdf_mem_copy(ptr_wh->i_addr3, src_addr, QDF_MAC_ADDR_SIZE);

		peer->tx_capture.tx_wifi_ppdu_id = ppdu_desc->ppdu_id;
	}

	mpdu_buf_len = sizeof(struct ieee80211_frame) + LLC_SNAP_HDR_LEN;
	mpdu_buf_len += sizeof(struct ieee80211_qoscntl);

	nbuf->protocol = qdf_htons(ETH_P_802_2);

	/* update ieee80211_frame header */
	if (!qdf_nbuf_push_head(nbuf, mpdu_buf_len)) {
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  FL("No headroom"));
		return QDF_STATUS_E_NOMEM;
	}

	ptr_hdr = (void *)qdf_nbuf_data(nbuf);
	qdf_mem_copy(ptr_hdr, ptr_wh, sizeof(struct ieee80211_frame));

	ptr_hdr = ptr_hdr + (sizeof(struct ieee80211_frame));

	/* update qoscntl header */
	qdf_mem_copy(ptr_hdr, ptr_qoscntl, sizeof(struct ieee80211_qoscntl));

	ptr_hdr = ptr_hdr + sizeof(struct ieee80211_qoscntl);

	/* update LLC */
	*ptr_hdr =  LLC_SNAP_LSAP;
	*(ptr_hdr + 1) = LLC_SNAP_LSAP;
	*(ptr_hdr + 2) = LLC_UI;
	*(ptr_hdr + 3) = 0x00;
	*(ptr_hdr + 4) = 0x00;
	*(ptr_hdr + 5) = 0x00;
	*(ptr_hdr + 6) = (eth_type & 0xFF00) >> 8;
	*(ptr_hdr + 7) = (eth_type & 0xFF);


	qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - mpdu_buf_len);
	return 0;
}

/**
 * dp_tx_mon_restitch_mpdu_from_msdus(): Function to restitch msdu to mpdu
 * @pdev: dp_pdev
 * @peer: dp_peer
 * @head_msdu: head msdu queue
 *
 * return: status
 */
static uint32_t
dp_tx_mon_restitch_mpdu_from_msdus(struct dp_pdev *pdev,
				   struct dp_peer *peer,
				   struct cdp_tx_completion_ppdu *ppdu_desc,
				   qdf_nbuf_queue_t *head_msdu)
{
	qdf_nbuf_t curr_nbuf = NULL;
	qdf_nbuf_t first_nbuf = NULL;
	qdf_nbuf_t prev_nbuf = NULL;
	qdf_nbuf_t mpdu_nbuf = NULL;

	qdf_nbuf_queue_t *mpdu = NULL;
	uint32_t num_mpdu = 0;

	struct msdu_completion_info *ptr_msdu_info = NULL;

	uint8_t first_msdu = 0;
	uint8_t last_msdu = 0;
	uint32_t frag_list_sum_len = 0;
	uint8_t first_msdu_not_seen = 1;
	uint16_t ether_type = 0;
	qdf_ether_header_t *eh = NULL;

	num_mpdu = ppdu_desc->num_mpdu;
	mpdu = &ppdu_desc->mpdu_q;

	curr_nbuf = qdf_nbuf_queue_remove(head_msdu);

	while (curr_nbuf) {
		ptr_msdu_info =
			(struct msdu_completion_info *)qdf_nbuf_data(curr_nbuf);

		first_msdu = ptr_msdu_info->first_msdu;
		last_msdu = ptr_msdu_info->last_msdu;

		eh = (qdf_ether_header_t *)(curr_nbuf->data +
					   sizeof(struct msdu_completion_info));
		ether_type = eh->ether_type;

		/* pull msdu_completion_info added in pre header */
		/* pull ethernet header from header */
		qdf_nbuf_pull_head(curr_nbuf,
				   sizeof(struct msdu_completion_info) +
				   sizeof(qdf_ether_header_t));

		if (first_msdu && first_msdu_not_seen) {
			first_nbuf = curr_nbuf;
			frag_list_sum_len = 0;
			first_msdu_not_seen = 0;

			mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
						   MAX_MONITOR_HEADER,
						   MAX_MONITOR_HEADER,
						   4, FALSE);

			if (!mpdu_nbuf) {
				QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
					  QDF_TRACE_LEVEL_FATAL,
					  "MPDU head allocation failed !!!");
				goto free_ppdu_desc_mpdu_q;
			}

			dp_tx_update_80211_hdr(pdev, peer,
					       ppdu_desc, mpdu_nbuf,
					       ether_type, eh->ether_shost);

			/* update first buffer to previous buffer */
			prev_nbuf = curr_nbuf;

		} else if (first_msdu && !first_msdu_not_seen) {
			QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
				  QDF_TRACE_LEVEL_FATAL,
				  "!!!!! NO LAST MSDU\n");
			/*
			 * no last msdu in a mpdu
			 * handle this case
			 */
			qdf_nbuf_free(curr_nbuf);
			/*
			 * No last msdu found because WBM comes out
			 * of order, free the pkt
			 */
			goto free_ppdu_desc_mpdu_q;
		} else if (!first_msdu && first_msdu_not_seen) {
			QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
				  QDF_TRACE_LEVEL_FATAL,
				  "!!!!! NO FIRST MSDU\n");
			/*
			 * no first msdu in a mpdu
			 * handle this case
			 */
			qdf_nbuf_free(curr_nbuf);
			/*
			 * no first msdu found beacuse WBM comes out
			 * of order, free the pkt
			 */
			goto free_ppdu_desc_mpdu_q;
		} else {
			/* update current buffer to previous buffer next */
			prev_nbuf->next = curr_nbuf;
			/* move the previous buffer to next buffer */
			prev_nbuf = prev_nbuf->next;
		}

		frag_list_sum_len += qdf_nbuf_len(curr_nbuf);

		if (last_msdu) {
			/*
			 * first nbuf will hold list of msdu
			 * stored in prev_nbuf
			 */
			qdf_nbuf_append_ext_list(mpdu_nbuf,
						 first_nbuf,
						 frag_list_sum_len);

			/* add mpdu to mpdu queue */
			qdf_nbuf_queue_add(mpdu, mpdu_nbuf);
			first_nbuf = NULL;
			mpdu_nbuf = NULL;

			/* next msdu will start with first msdu */
			first_msdu_not_seen = 1;
			goto check_for_next_msdu;
		}

		/* get next msdu from the head_msdu */
		curr_nbuf = qdf_nbuf_queue_remove(head_msdu);

		if (!curr_nbuf) {
			/* msdu missed in list */
			QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
				  QDF_TRACE_LEVEL_FATAL,
				  "!!!! WAITING for msdu but list empty !!!!");
		}

		continue;

check_for_next_msdu:
		if (qdf_nbuf_is_queue_empty(head_msdu))
			return 0;
		curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
	}

	return 0;

free_ppdu_desc_mpdu_q:
	/* free already chained msdu pkt */
	while (first_nbuf) {
		curr_nbuf = first_nbuf;
		first_nbuf = first_nbuf->next;
		qdf_nbuf_free(curr_nbuf);
	}

	/* free allocated mpdu hdr */
	if (mpdu_nbuf)
		qdf_nbuf_free(mpdu_nbuf);
	/* free queued remaining msdu pkt per ppdu */
	qdf_nbuf_queue_free(head_msdu);
	/* free queued mpdu per ppdu */
	qdf_nbuf_queue_free(mpdu);
	return 0;
}

/**
 * dp_tx_msdu_dequeue(): Function to dequeue msdu from peer based tid
 * @peer: dp_peer
 * @ppdu_id: ppdu_id
 * @tid: tid
 * @num_msdu: number of msdu
 * @head: head queue
 * @start_tsf: start tsf from ppdu_desc
 * @end_tsf: end tsf from ppdu_desc
 *
 * return: status
 */
static
uint32_t dp_tx_msdu_dequeue(struct dp_peer *peer, uint32_t ppdu_id,
			    uint16_t tid, uint32_t num_msdu,
			    qdf_nbuf_queue_t *head,
			    uint32_t start_tsf, uint32_t end_tsf)
{
	struct dp_tx_tid *tx_tid  = NULL;
	uint32_t msdu_ppdu_id;
	qdf_nbuf_t curr_msdu = NULL;
	qdf_nbuf_t prev_msdu = NULL;
	qdf_nbuf_t nbuf = NULL;
	struct msdu_completion_info *ptr_msdu_info = NULL;

	uint32_t wbm_tsf;

	uint32_t matched = 0;

	if (qdf_unlikely(!peer))
		return 0;

	tx_tid = &peer->tx_capture.tx_tid[tid];

	if (qdf_unlikely(!tx_tid))
		return 0;

	if (qdf_nbuf_is_queue_empty(&tx_tid->msdu_comp_q))
		return 0;

	/* lock here */
	qdf_spin_lock_bh(&tx_tid->tid_lock);

	curr_msdu = qdf_nbuf_queue_first(&tx_tid->msdu_comp_q);

	while (curr_msdu) {
		if (qdf_nbuf_queue_len(head) == num_msdu)
			break;

		ptr_msdu_info =
			(struct msdu_completion_info *)qdf_nbuf_data(curr_msdu);

		msdu_ppdu_id = ptr_msdu_info->ppdu_id;

		wbm_tsf = ptr_msdu_info->tsf;

		if (wbm_tsf < start_tsf) {
			/* remove the aged packet */
			nbuf = qdf_nbuf_queue_remove(
					&tx_tid->msdu_comp_q);

			qdf_nbuf_free(nbuf);

			curr_msdu = qdf_nbuf_queue_first(
					&tx_tid->msdu_comp_q);
			prev_msdu = NULL;
			continue;
		}
		if (msdu_ppdu_id == ppdu_id) {
			matched = 1;

			if (wbm_tsf > start_tsf && wbm_tsf < end_tsf) {
				/*packet found */
			} else if (wbm_tsf > end_tsf) {
				/*
				 * Do we need delta in above case.
				 * for searching ppdu out of ppdu tsf
				 */
				break;
			}

			if (qdf_likely(!prev_msdu)) {
				/* remove head */
				curr_msdu = qdf_nbuf_queue_remove(
						&tx_tid->msdu_comp_q);

				/* add msdu to head queue */
				qdf_nbuf_queue_add(head, curr_msdu);
				/* get next msdu from msdu_comp_q */
				curr_msdu = qdf_nbuf_queue_first(
						&tx_tid->msdu_comp_q);
				continue;
			} else {
				/* update prev_msdu next to current msdu next */
				prev_msdu->next = curr_msdu->next;
				/* set current msdu next as NULL */
				curr_msdu->next = NULL;
				/* decrement length */
				((qdf_nbuf_queue_t *)(
					&tx_tid->msdu_comp_q))->qlen--;

				/* add msdu to head queue */
				qdf_nbuf_queue_add(head, curr_msdu);
				/* set previous msdu to current msdu */
				curr_msdu = prev_msdu->next;
				continue;
			}
		}

		prev_msdu = curr_msdu;
		curr_msdu = prev_msdu->next;
	}

	if (qdf_nbuf_queue_len(head) != num_msdu)
		matched = 0;

	qdf_spin_unlock_bh(&tx_tid->tid_lock);

	return matched;
}

/**
 * get_mpdu_clone_from_next_ppdu(): Function to clone missing mpdu from
 * next ppdu
 * @nbuf_ppdu_desc_list: nbuf list
 * @ppdu_desc_cnt: ppdu_desc_cnt
 * @missed_seq_no:
 * @ppdu_id: ppdu_id
 * @mpdu_info: cdp_tx_indication_mpdu_info
 *
 * return: void
 */
static
qdf_nbuf_t get_mpdu_clone_from_next_ppdu(qdf_nbuf_t nbuf_ppdu_desc_list[],
					 uint32_t ppdu_desc_cnt,
					 uint32_t missed_seq_no,
					 uint32_t ppdu_id)
{
	uint32_t i = 0;
	uint32_t k = 0;
	uint32_t mpdu_tried = 0;
	uint32_t found = 0;
	uint32_t seq_no = 0;
	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
	qdf_nbuf_t mpdu = NULL;

	for (i = 1; i < ppdu_desc_cnt; i++) {
		ppdu_desc = (struct cdp_tx_completion_ppdu *)
				qdf_nbuf_data(nbuf_ppdu_desc_list[i]);

		mpdu_tried = ppdu_desc->user[0].mpdu_tried_ucast +
				ppdu_desc->user[0].mpdu_tried_mcast;

		/* check if seq number is between the range */
		if ((missed_seq_no >= ppdu_desc->user[0].start_seq) &&
		    (missed_seq_no <= ppdu_desc->user[0].start_seq +
		     mpdu_tried)) {
			seq_no = ppdu_desc->user[0].start_seq;

			if (ppdu_desc->user[0].failed_bitmap[k] &
			    (1 << (missed_seq_no - seq_no))) {
				found = 1;
				break;
			}
		}
	}

	if (found == 0) {
		/* mpdu not found in sched cmd id */
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: missed seq_no[%d] ppdu_id[%d] [%d] not found!!!",
			  __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
		return NULL;
	}

	QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
		  "%s: seq_no[%d] missed ppdu_id[%d] m[%d] found in ppdu_id[%d]!!",
		  __func__,
		  missed_seq_no, ppdu_id,
		  (missed_seq_no - seq_no), ppdu_desc->ppdu_id);

	mpdu = qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
	if (!mpdu) {
		/* bitmap shows it found  sequence number, but queue empty */
		/* do we need to allocate skb and send instead of NULL ? */
		QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
			  "%s: missed seq_no[%d] ppdu_id[%d] [%d] found but queue empty!!!",
			  __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
		return NULL;
	}

	for (i = 0; i < (missed_seq_no - seq_no); i++) {
		mpdu = mpdu->next;
		if (!mpdu) {
			/*
			 * bitmap shows it found  sequence number,
			 * but queue empty, do we need to allocate
			 * skb and send instead of NULL ?
			 * add counter here:
			 */
			return NULL;
		}
	}

	return skb_copy_expand(mpdu, MAX_MONITOR_HEADER, 0, GFP_ATOMIC);
}

/**
 * dp_tx_update_user_mpdu_info(): Function to update mpdu info
 * from ppdu_desc
 * @ppdu_id: ppdu_id
 * @mpdu_info: cdp_tx_indication_mpdu_info
 * @user: cdp_tx_completion_ppdu_user
 *
 * return: void
 */
static void
dp_tx_update_user_mpdu_info(uint32_t ppdu_id,
			    struct cdp_tx_indication_mpdu_info *mpdu_info,
			    struct cdp_tx_completion_ppdu_user *user)
{
	mpdu_info->ppdu_id = ppdu_id;

	mpdu_info->frame_ctrl = user->frame_ctrl;
	mpdu_info->qos_ctrl = user->qos_ctrl;
	mpdu_info->tid = user->tid;
	mpdu_info->ltf_size = user->ltf_size;
	mpdu_info->he_re = user->he_re;
	mpdu_info->txbf = user->txbf;
	mpdu_info->bw = user->bw;
	mpdu_info->nss = user->nss;
	mpdu_info->mcs = user->mcs;
	mpdu_info->preamble = user->preamble;
	mpdu_info->gi = user->gi;

	mpdu_info->ack_rssi = user->ack_rssi[0];
	mpdu_info->tx_rate = user->tx_rate;
	mpdu_info->ldpc = user->ldpc;
	mpdu_info->ppdu_cookie = user->ppdu_cookie;

	qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, 6);

	mpdu_info->ba_start_seq = user->ba_seq_no;

	qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
		     CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
}

static inline
void dp_tx_update_sequence_number(qdf_nbuf_t nbuf, uint32_t seq_no)
{
	struct ieee80211_frame *ptr_wh = NULL;
	uint16_t wh_seq = 0;

	if (!nbuf)
		return;

	/* update sequence number in frame header */
	ptr_wh = (struct ieee80211_frame *)qdf_nbuf_data(nbuf);

	wh_seq = (seq_no & 0xFFF) << 4;
	qdf_mem_copy(ptr_wh->i_seq, &wh_seq, sizeof(uint16_t));
}

/**
 * dp_send_mpdu_info_to_stack(): Function to deliver mpdu info to stack
 * to upper layer
 * @pdev: DP pdev handle
 * @nbuf_ppdu_desc_list: ppdu_desc_list per sched cmd id
 * @ppdu_desc_cnt: number of ppdu_desc_cnt
 *
 * return: status
 */
static
QDF_STATUS dp_send_mpdu_info_to_stack(struct dp_pdev *pdev,
				      qdf_nbuf_t nbuf_ppdu_desc_list[],
				      uint32_t ppdu_desc_cnt)
{
	uint32_t ppdu_id;
	uint32_t desc_cnt;
	qdf_nbuf_t tmp_nbuf;

	for (desc_cnt = 0; desc_cnt < ppdu_desc_cnt; desc_cnt++) {
		struct cdp_tx_completion_ppdu *ppdu_desc;
		uint32_t mpdu_tried;
		uint32_t num_mpdu;
		uint32_t k;
		uint32_t i;
		uint32_t seq_no = 0;
		uint32_t len;
		qdf_nbuf_t mpdu_nbuf;

		ppdu_desc = (struct cdp_tx_completion_ppdu *)
			qdf_nbuf_data(nbuf_ppdu_desc_list[desc_cnt]);

		if (!ppdu_desc)
			continue;

		ppdu_id = ppdu_desc->ppdu_id;

		if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_CTRL) {
			struct cdp_tx_indication_info tx_capture_info;
			struct cdp_tx_indication_mpdu_info *mpdu_info;
			qdf_nbuf_t mgmt_ctl_nbuf;
			uint8_t type, subtype;

			qdf_mem_set(&tx_capture_info,
				    sizeof(struct cdp_tx_indication_info),
				    0);
			mpdu_info = &tx_capture_info.mpdu_info;

			mpdu_info->channel = ppdu_desc->channel;
			mpdu_info->frame_type = ppdu_desc->frame_type;
			mpdu_info->ppdu_start_timestamp =
						ppdu_desc->ppdu_start_timestamp;
			mpdu_info->ppdu_end_timestamp =
						ppdu_desc->ppdu_end_timestamp;
			mpdu_info->tx_duration = ppdu_desc->tx_duration;
			mpdu_info->seq_no = seq_no;
			mpdu_info->num_msdu = ppdu_desc->num_msdu;

			/* update cdp_tx_indication_mpdu_info */
			dp_tx_update_user_mpdu_info(ppdu_id,
						    &tx_capture_info.mpdu_info,
						    &ppdu_desc->user[0]);

			tx_capture_info.mpdu_info.channel_num =
				pdev->operating_channel;

			type = (ppdu_desc->frame_ctrl &
				IEEE80211_FC0_TYPE_MASK) >>
				IEEE80211_FC0_TYPE_SHIFT;
			subtype = (ppdu_desc->frame_ctrl &
				IEEE80211_FC0_SUBTYPE_MASK) >>
				IEEE80211_FC0_SUBTYPE_SHIFT;
			qdf_spin_lock_bh(
				&pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
			mgmt_ctl_nbuf = qdf_nbuf_queue_remove(
				&pdev->tx_capture.ctl_mgmt_q[type][subtype]);
			qdf_spin_unlock_bh(
				&pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
			if (mgmt_ctl_nbuf) {
				struct ieee80211_frame *wh;
				uint16_t duration_le, seq_le;

				tx_capture_info.mpdu_nbuf =
					qdf_nbuf_alloc(pdev->soc->osdev,
					MAX_MONITOR_HEADER, MAX_MONITOR_HEADER,
					4, FALSE);
				if (!tx_capture_info.mpdu_nbuf) {
					qdf_nbuf_free(mgmt_ctl_nbuf);
					goto free_ppdu_desc;
				}
				/* pull ppdu_id from the packet */
				tx_capture_info.mpdu_info.ppdu_id =
					*(uint32_t *)qdf_nbuf_data(mgmt_ctl_nbuf);
				qdf_nbuf_pull_head(mgmt_ctl_nbuf, sizeof(uint32_t));
				wh = (struct ieee80211_frame *)qdf_nbuf_data(mgmt_ctl_nbuf);

				if (subtype != IEEE80211_FC0_SUBTYPE_BEACON) {
					duration_le = qdf_cpu_to_le16(
						ppdu_desc->tx_duration);
					wh->i_dur[1] =
						(duration_le & 0xFF00) >> 8;
					wh->i_dur[0] = duration_le & 0xFF;
					seq_le = qdf_cpu_to_le16(
						ppdu_desc->user[0].start_seq <<
						IEEE80211_SEQ_SEQ_SHIFT);
					wh->i_seq[1] = (seq_le & 0xFF00) >> 8;
					wh->i_seq[0] = seq_le & 0xFF;
				}
				qdf_nbuf_append_ext_list(
					tx_capture_info.mpdu_nbuf,
					mgmt_ctl_nbuf,
					qdf_nbuf_len(mgmt_ctl_nbuf));
				QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
					QDF_TRACE_LEVEL_DEBUG,
					"ctrl/mgmt frm(0x%08x): fc 0x%x 0x%x\n",
					tx_capture_info.mpdu_info.ppdu_id,
					wh->i_fc[1], wh->i_fc[0]);
				QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
					QDF_TRACE_LEVEL_DEBUG,
					"desc->ppdu_id 0x%08x\n", ppdu_id);
			} else if ((ppdu_desc->frame_ctrl &
				   IEEE80211_FC0_TYPE_MASK) ==
				   IEEE80211_FC0_TYPE_CTL) {
				struct ieee80211_frame_min_one *wh_min;
				uint16_t frame_ctrl_le, duration_le;

				tx_capture_info.mpdu_nbuf =
					qdf_nbuf_alloc(pdev->soc->osdev,
					MAX_MONITOR_HEADER + MAX_DUMMY_FRM_BODY,
					MAX_MONITOR_HEADER,
					4, FALSE);
				if (!tx_capture_info.mpdu_nbuf)
					goto free_ppdu_desc;
				wh_min = (struct ieee80211_frame_min_one *)
					qdf_nbuf_data(
					tx_capture_info.mpdu_nbuf);
				qdf_mem_zero(wh_min, MAX_DUMMY_FRM_BODY);
				frame_ctrl_le =
					qdf_cpu_to_le16(ppdu_desc->frame_ctrl);
				duration_le =
					qdf_cpu_to_le16(ppdu_desc->tx_duration);
				wh_min->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
				wh_min->i_fc[0] = (frame_ctrl_le & 0xFF);
				wh_min->i_dur[1] = (duration_le & 0xFF00) >> 8;
				wh_min->i_dur[0] = (duration_le & 0xFF);
				qdf_mem_copy(wh_min->i_addr1,
					mpdu_info->mac_address,
					QDF_MAC_ADDR_SIZE);
				qdf_nbuf_set_pktlen(tx_capture_info.mpdu_nbuf,
					sizeof(*wh_min));
				QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
					QDF_TRACE_LEVEL_DEBUG,
					"frm(0x%08x): fc %x %x, dur 0x%x%x\n",
					ppdu_id, wh_min->i_fc[1], wh_min->i_fc[0],
					wh_min->i_dur[1], wh_min->i_dur[0]);
			}
			/*
			 * send MPDU to osif layer
			 */
			dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
					     &tx_capture_info, HTT_INVALID_PEER,
					     WDI_NO_VAL, pdev->pdev_id);

			if (tx_capture_info.mpdu_nbuf)
				qdf_nbuf_free(tx_capture_info.mpdu_nbuf);

free_ppdu_desc:
			tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
			nbuf_ppdu_desc_list[desc_cnt] = NULL;
			qdf_nbuf_free(tmp_nbuf);
			continue;
		}

		if (qdf_nbuf_is_queue_empty(&ppdu_desc->mpdu_q)) {
			tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
			nbuf_ppdu_desc_list[desc_cnt] = NULL;
			qdf_nbuf_free(tmp_nbuf);
			continue;
		}

		/* find mpdu tried is same as success mpdu */

		mpdu_tried = ppdu_desc->user[0].mpdu_tried_ucast +
				ppdu_desc->user[0].mpdu_tried_mcast;
		num_mpdu = ppdu_desc->user[0].mpdu_success;

		/* get length */
		len = qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);

		/* find list of missing sequence */
		for (i = 0, k = 0; i < mpdu_tried; i++) {
			struct cdp_tx_indication_info tx_capture_info;
			struct cdp_tx_indication_mpdu_info *mpdu_info;

			qdf_mem_set(&tx_capture_info,
				    sizeof(struct cdp_tx_indication_info),
				    0);

			mpdu_info = &tx_capture_info.mpdu_info;

			/* missed seq number */
			seq_no = ppdu_desc->user[0].start_seq + i;

			if (!(ppdu_desc->user[0].failed_bitmap[k] & 1 << i)) {
				QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
					  QDF_TRACE_LEVEL_ERROR,
					  "%s: finding missing seq no: %d in other ppdu list cnt[%d]",
					  __func__, seq_no, ppdu_desc_cnt);

				/* send rest of ppdu_desc list */
				mpdu_nbuf = get_mpdu_clone_from_next_ppdu(
						nbuf_ppdu_desc_list + desc_cnt,
						ppdu_desc_cnt - desc_cnt,
						seq_no,
						ppdu_id);

				/* check mpdu_nbuf NULL */
				if (!mpdu_nbuf)
					continue;

				qdf_nbuf_queue_add(&ppdu_desc->mpdu_q,
						   mpdu_nbuf);

			} else {
				/* any error case we need to handle */
			}

			/* k need to be increase, if i increased more than 32 */

			tx_capture_info.mpdu_nbuf =
				qdf_nbuf_queue_remove(&ppdu_desc->mpdu_q);

			if (!tx_capture_info.mpdu_nbuf)
				continue;

			mpdu_info->channel = ppdu_desc->channel;
			mpdu_info->frame_type = ppdu_desc->frame_type;
			mpdu_info->ppdu_start_timestamp =
						ppdu_desc->ppdu_start_timestamp;
			mpdu_info->ppdu_end_timestamp =
						ppdu_desc->ppdu_end_timestamp;
			mpdu_info->tx_duration = ppdu_desc->tx_duration;
			mpdu_info->seq_no = seq_no;
			mpdu_info->num_msdu = ppdu_desc->num_msdu;

			/* update cdp_tx_indication_mpdu_info */
			dp_tx_update_user_mpdu_info(ppdu_id,
						    &tx_capture_info.mpdu_info,
						    &ppdu_desc->user[0]);

			tx_capture_info.mpdu_info.channel_num =
				pdev->operating_channel;

			dp_tx_update_sequence_number(tx_capture_info.mpdu_nbuf,
						     seq_no);
			/*
			 * send MPDU to osif layer
			 * do we need to update mpdu_info before tranmit
			 * get current mpdu_nbuf
			 */
			dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
					     &tx_capture_info,
					     HTT_INVALID_PEER,
					     WDI_NO_VAL, pdev->pdev_id);

			if (tx_capture_info.mpdu_nbuf)
				qdf_nbuf_free(tx_capture_info.mpdu_nbuf);

		}

		qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
		tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
		nbuf_ppdu_desc_list[desc_cnt] = NULL;
		qdf_nbuf_free(tmp_nbuf);
	}

	return QDF_STATUS_SUCCESS;
}

/**
 * dp_tx_ppdu_stats_process - Deferred PPDU stats handler
 * @context: Opaque work context (PDEV)
 *
 * Return: none
 */
void dp_tx_ppdu_stats_process(void *context)
{
	uint32_t curr_sched_cmdid;
	uint32_t last_ppdu_id;
	uint32_t ppdu_cnt;
	uint32_t ppdu_desc_cnt = 0;
	struct dp_pdev *pdev = (struct dp_pdev *)context;
	struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
	uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
	struct ppdu_info *sched_ppdu_info = NULL;

	STAILQ_HEAD(, ppdu_info) sched_ppdu_queue;

	struct ppdu_info *sched_ppdu_list_last_ptr;
	qdf_nbuf_t *nbuf_ppdu_desc_list;
	qdf_nbuf_t tmp_nbuf;
	struct dp_pdev_tx_capture *ptr_tx_cap = &pdev->tx_capture;

	STAILQ_INIT(&sched_ppdu_queue);
	/* Move the PPDU entries to defer list */
	qdf_spin_lock_bh(&ptr_tx_cap->ppdu_stats_lock);
	STAILQ_CONCAT(&ptr_tx_cap->ppdu_stats_defer_queue,
		      &ptr_tx_cap->ppdu_stats_queue);
	ptr_tx_cap->ppdu_stats_defer_queue_depth +=
		ptr_tx_cap->ppdu_stats_queue_depth;
	ptr_tx_cap->ppdu_stats_queue_depth = 0;
	qdf_spin_unlock_bh(&ptr_tx_cap->ppdu_stats_lock);

	while (!STAILQ_EMPTY(&ptr_tx_cap->ppdu_stats_defer_queue)) {
		ppdu_info =
			STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
		curr_sched_cmdid = ppdu_info->sched_cmdid;

		ppdu_cnt = 0;
		STAILQ_FOREACH_SAFE(ppdu_info,
				    &ptr_tx_cap->ppdu_stats_defer_queue,
				    ppdu_info_queue_elem, tmp_ppdu_info) {
			if (curr_sched_cmdid != ppdu_info->sched_cmdid)
				break;
			sched_ppdu_list_last_ptr = ppdu_info;
			ppdu_cnt++;
		}
		if (ppdu_info && (curr_sched_cmdid == ppdu_info->sched_cmdid) &&
		    ptr_tx_cap->ppdu_stats_next_sched < now_ms)
			break;

		last_ppdu_id = sched_ppdu_list_last_ptr->ppdu_id;

		STAILQ_FIRST(&sched_ppdu_queue) =
			STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
		STAILQ_REMOVE_HEAD_UNTIL(&ptr_tx_cap->ppdu_stats_defer_queue,
					 sched_ppdu_list_last_ptr,
					 ppdu_info_queue_elem);
		STAILQ_NEXT(sched_ppdu_list_last_ptr,
			    ppdu_info_queue_elem) = NULL;

		ptr_tx_cap->ppdu_stats_defer_queue_depth -= ppdu_cnt;

		nbuf_ppdu_desc_list =
			(qdf_nbuf_t *) qdf_mem_malloc(sizeof(qdf_nbuf_t) *
						      ppdu_cnt);
		/*
		 * if there is no memory allocated we need to free sched ppdu
		 * list, no ppdu stats will be updated.
		 */
		if (!nbuf_ppdu_desc_list) {
			STAILQ_FOREACH_SAFE(sched_ppdu_info,
					    &sched_ppdu_queue,
					    ppdu_info_queue_elem,
					    tmp_ppdu_info) {
				ppdu_info = sched_ppdu_info;
				tmp_nbuf = ppdu_info->nbuf;
				qdf_mem_free(ppdu_info);
				qdf_nbuf_free(tmp_nbuf);
			}
			continue;
		}

		ppdu_desc_cnt = 0;
		STAILQ_FOREACH_SAFE(sched_ppdu_info,
				    &sched_ppdu_queue,
				    ppdu_info_queue_elem, tmp_ppdu_info) {
			struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
			struct dp_peer *peer = NULL;
			qdf_nbuf_t nbuf;
			uint32_t retries = 0;
			uint32_t ret = 0;
			qdf_nbuf_queue_t head_msdu;
			uint32_t start_tsf = 0;
			uint32_t end_tsf = 0;
			uint16_t tid = 0;
			uint32_t num_msdu = 0;
			uint32_t qlen = 0;

			qdf_nbuf_queue_init(&head_msdu);

			ppdu_info = sched_ppdu_info;
			ppdu_desc = (struct cdp_tx_completion_ppdu *)
				qdf_nbuf_data(ppdu_info->nbuf);
			pdev->tx_ppdu_proc++;

			dp_ppdu_desc_user_stats_update(pdev, ppdu_info);
			/*
			 * While processing/corelating Tx buffers, we should
			 * hold the entire PPDU list for the give sched_cmdid
			 * instead of freeing below.
			 */
			nbuf = ppdu_info->nbuf;
			qdf_mem_free(ppdu_info);

			qdf_assert_always(nbuf);

			ppdu_desc = (struct cdp_tx_completion_ppdu *)
				qdf_nbuf_data(nbuf);

			/* send WDI event */
			if (pdev->tx_capture_enabled ==
			    CDP_TX_ENH_CAPTURE_DISABLED) {
				/**
				 * 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 (pdev->tx_sniffer_enable ||
				    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);
					}
				}

				continue;
			}

			peer = dp_peer_find_by_id(pdev->soc,
						  ppdu_desc->user[0].peer_id);
			/**
			 * peer can be NULL
			 */
			if (!peer) {
				qdf_nbuf_free(nbuf);
				continue;
			}

			if ((ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA) &&
			    (!ppdu_desc->user[0].completion_status)) {
				/**
				 * check whether it is bss peer,
				 * if bss_peer no need to process further
				 * check whether tx_capture feature is enabled
				 * for this peer or globally for all peers
				 */
				if (peer->bss_peer ||
				    !dp_peer_or_pdev_tx_cap_enabled(pdev,
				    peer)) {
					dp_peer_unref_del_find_by_id(peer);
					qdf_nbuf_free(nbuf);
					continue;
				}

				/* print the bit map */
				dp_tx_print_bitmap(pdev, ppdu_desc,
						   0, ppdu_desc->ppdu_id);
				if (ppdu_desc->user[0].tid > DP_NON_QOS_TID) {
					QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
						  QDF_TRACE_LEVEL_ERROR,
						  "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
						  __func__,
						  ppdu_desc->ppdu_id,
						  ppdu_desc->user[0].peer_id,
						  ppdu_desc->user[0].tid);

					dp_peer_unref_del_find_by_id(peer);
					qdf_nbuf_free(nbuf);
					continue;
				}
dequeue_msdu_again:

				tid = ppdu_desc->user[0].tid;
				num_msdu = ppdu_desc->user[0].num_msdu;
				start_tsf = ppdu_desc->ppdu_start_timestamp;
				end_tsf = ppdu_desc->ppdu_end_timestamp;
				/*
				 * retrieve msdu buffer based on ppdu_id & tid
				 * based msdu queue and store it in local queue
				 * sometimes, wbm comes later than per ppdu
				 * stats. Assumption: all packets are SU,
				 * and packets comes in order
				 */
				ret = dp_tx_msdu_dequeue(peer,
							 ppdu_desc->ppdu_id,
							 tid, num_msdu,
							 &head_msdu, start_tsf,
							 end_tsf);

				if (!ret && (++retries < 3)) {
					/* wait for wbm to complete */
					qdf_sleep(20);
					goto dequeue_msdu_again;
				}

				if (qdf_nbuf_is_queue_empty(&head_msdu)) {
					dp_peer_unref_del_find_by_id(peer);
					/*
					 * head msdu is NULL
					 * free nbuf as no processing required
					 */
					qdf_nbuf_free(nbuf);
					continue;
				}

				/*
				 * now head_msdu hold - msdu list for that
				 * particular ppdu_id, restitch mpdu from
				 * msdu and create a mpdu queue
				 */
				dp_tx_mon_restitch_mpdu_from_msdus(pdev,
								   peer,
								   ppdu_desc,
								   &head_msdu);

				/*
				 * sanity: free local head msdu queue
				 * do we need this ?
				 */
				qdf_nbuf_queue_free(&head_msdu);

				qlen = qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);

				if (!qlen) {
					qdf_nbuf_free(nbuf);
					dp_peer_unref_del_find_by_id(peer);
					continue;
				}
				nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;

				/* print ppdu_desc info for debugging purpose */
				QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
					  QDF_TRACE_LEVEL_INFO,
					  "%s: ppdu[%d], p_id[%d], tid[%d], n_mpdu[%d %d] n_msdu[%d] retr[%d] qlen[%d] s_tsf[%u] dur[%u] seq[%d] [%d %d]",
					  __func__, ppdu_desc->ppdu_id,
					  ppdu_desc->user[0].peer_id,
					  ppdu_desc->user[0].tid,
					  ppdu_desc->num_mpdu,
					  ppdu_desc->user[0].mpdu_success,
					  ppdu_desc->num_msdu, retries,
					  qlen,
					  ppdu_desc->ppdu_start_timestamp,
					  ppdu_desc->tx_duration,
					  ppdu_desc->user[0].start_seq,
					  ppdu_cnt,
					  ppdu_desc_cnt);

				nbuf->next =
				qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
			} else if (ppdu_desc->frame_type ==
				   CDP_PPDU_FTYPE_CTRL) {
				nbuf->next =
				qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
				nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
			} else {
				qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
				qdf_nbuf_free(nbuf);
			}

			dp_peer_unref_del_find_by_id(peer);
		}

		/*
		 * At this point we have mpdu queued per ppdu_desc
		 * based on packet capture flags send mpdu info to upper stack
		 */
		if (ppdu_desc_cnt) {
			dp_send_mpdu_info_to_stack(pdev,
						   nbuf_ppdu_desc_list,
						   ppdu_desc_cnt);
		}

		qdf_mem_free(nbuf_ppdu_desc_list);
	}
}

/**
 * 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
 */
void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
			  struct ppdu_info *ppdu_info)
{
	uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
	struct cdp_tx_completion_ppdu *ppdu_desc = NULL;

	TAILQ_REMOVE(&pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
	pdev->list_depth--;

	ppdu_desc = (struct cdp_tx_completion_ppdu *)
			qdf_nbuf_data(ppdu_info->nbuf);

	qdf_spin_lock_bh(&pdev->tx_capture.ppdu_stats_lock);

	if (qdf_unlikely(!pdev->tx_capture_enabled &&
	    (pdev->tx_capture.ppdu_stats_queue_depth +
	    pdev->tx_capture.ppdu_stats_defer_queue_depth) >
	    DP_TX_PPDU_PROC_MAX_DEPTH)) {
		qdf_nbuf_free(ppdu_info->nbuf);
		qdf_mem_free(ppdu_info);
		pdev->tx_capture.ppdu_dropped++;
	} else {
		STAILQ_INSERT_TAIL(&pdev->tx_capture.ppdu_stats_queue,
				   ppdu_info, ppdu_info_queue_elem);
		pdev->tx_capture.ppdu_stats_queue_depth++;
	}
	qdf_spin_unlock_bh(&pdev->tx_capture.ppdu_stats_lock);

	if ((pdev->tx_capture.ppdu_stats_queue_depth >
	    DP_TX_PPDU_PROC_THRESHOLD) ||
	    (pdev->tx_capture.ppdu_stats_next_sched <= now_ms)) {
		qdf_queue_work(0, pdev->tx_capture.ppdu_stats_workqueue,
			       &pdev->tx_capture.ppdu_stats_work);
		pdev->tx_capture.ppdu_stats_next_sched =
			now_ms + DP_TX_PPDU_PROC_TIMEOUT;
	}
}

#endif