// SPDX-License-Identifier: BSD-3-Clause-Clear
/*
 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
 */

#include <linux/vmalloc.h>
#include "core.h"
#include "dp_tx.h"
#include "dp_rx.h"
#include "debug.h"
#include "debugfs_htt_stats.h"

#define HTT_DBG_OUT(buf, len, fmt, ...) \
			scnprintf(buf, len, fmt, ##__VA_ARGS__)

#define HTT_MAX_PRINT_CHAR_PER_ELEM 15

#define HTT_TLV_HDR_LEN 4

#define ARRAY_TO_BUF(out, buflen, arr, len)                                    \
        do {                                                                   \
                int index = 0; u8 i;                                           \
                for (i = 0; i < len; i++) {                                    \
                        index += scnprintf((out + buflen) + index,             \
                                (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,  \
                                          " %u:%u,", i, arr[i]);               \
                }                                                              \
                buflen += index;                                               \
        } while (0)

#define ARRAY_TO_BUF_EXT(out, buflen, arr, len, ext_len)                       \
	do {                                                                   \
		int index = 0; u8 i;                                           \
		for (i = 0; i < len; i++) {                                    \
			index += scnprintf((out + buflen) + index,             \
				(ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,  \
					  " %u:%u,", i + ext_len, arr[i]);     \
		}                                                              \
		buflen += index;                                               \
	} while (0)

#define CHAIN_ARRAY_TO_BUF(out, buflen, arr, len)			       	       \
	do {								       \
		int index = 0; u8 i;					       \
		for (i = 0; i < len; i++) {				       \
			index += scnprintf((out + buflen) + index, 	       \
				(ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,  \
					  " %u:%d,", i, arr[i]);	       \
		}							       \
		buflen += index;					       \
	} while (0)

static inline void htt_print_stats_string_tlv(const void *tag_buf,
					      u16 tag_len,
					      struct debug_htt_stats_req *stats_req)
{
	const struct htt_stats_string_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8  i;

	tag_len = tag_len >> 2;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "data = ");

	for (i = 0; i < tag_len; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "%.*s", 4,
				   (char *)&(htt_stats_buf->data[i]));
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_pdev_stats_cmn_tlv(const void *tag_buf,
						   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "comp_delivered = %u\n",
			   htt_stats_buf->comp_delivered);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "self_triggers = %u\n",
			   htt_stats_buf->self_triggers);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_queued = %u\n",
			   htt_stats_buf->hw_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_reaped = %u\n",
			   htt_stats_buf->hw_reaped);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "underrun = %u\n",
			   htt_stats_buf->underrun);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_paused = %u\n",
			   htt_stats_buf->hw_paused);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_flush = %u\n",
			   htt_stats_buf->hw_flush);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_filt = %u\n",
			   htt_stats_buf->hw_filt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_abort = %u\n",
			   htt_stats_buf->tx_abort);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ppdu_ok = %u\n",
			   htt_stats_buf->ppdu_ok);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_requeued = %u\n",
			   htt_stats_buf->mpdu_requed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_xretry = %u\n",
			   htt_stats_buf->tx_xretry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "data_rc = %u\n",
			   htt_stats_buf->data_rc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n",
			   htt_stats_buf->mpdu_dropped_xretry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n",
			   htt_stats_buf->illgl_rate_phy_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cont_xretry = %u\n",
			   htt_stats_buf->cont_xretry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_timeout = %u\n",
			   htt_stats_buf->tx_timeout);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_time_dur_data = %u\n",
			   htt_stats_buf->tx_time_dur_data);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pdev_resets = %u\n",
			   htt_stats_buf->pdev_resets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_underrun = %u\n",
			   htt_stats_buf->phy_underrun);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "txop_ovf = %u\n",
			   htt_stats_buf->txop_ovf);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_posted = %u\n",
			   htt_stats_buf->seq_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_failed_queueing = %u\n",
			   htt_stats_buf->seq_failed_queueing);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_completed = %u\n",
			   htt_stats_buf->seq_completed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_restarted = %u\n",
			   htt_stats_buf->seq_restarted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_txop_repost_stop = %u\n",
			   htt_stats_buf->seq_txop_repost_stop);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "next_seq_cancel = %u\n",
			   htt_stats_buf->next_seq_cancel);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dl_mu_mimo_seq_posted = %u\n",
			   htt_stats_buf->mu_seq_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dl_mu_ofdma_seq_posted = %u\n",
			   htt_stats_buf->mu_ofdma_seq_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ul_mu_mimo_seq_posted = %u\n",
			   htt_stats_buf->ul_mumimo_seq_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ul_mu_ofdma_seq_posted = %u\n",
			   htt_stats_buf->ul_ofdma_seq_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_peer_blacklisted = %u\n",
			   htt_stats_buf->num_mu_peer_blacklisted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_qdepth_repost_stop = %u\n",
			   htt_stats_buf->seq_qdepth_repost_stop);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_min_msdu_repost_stop = %u\n",
			   htt_stats_buf->seq_min_msdu_repost_stop);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_seq_min_msdu_repost_stop = %u\n",
			   htt_stats_buf->mu_seq_min_msdu_repost_stop);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n",
			   htt_stats_buf->seq_switch_hw_paused);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n",
			   htt_stats_buf->next_seq_posted_dsr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_posted_isr = %u\n",
			   htt_stats_buf->seq_posted_isr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "seq_ctrl_cached = %u\n",
			   htt_stats_buf->seq_ctrl_cached);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_count_tqm = %u\n",
			   htt_stats_buf->mpdu_count_tqm);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "msdu_count_tqm = %u\n",
			   htt_stats_buf->msdu_count_tqm);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n",
			   htt_stats_buf->mpdu_removed_tqm);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "msdu_removed_tqm = %u\n",
			   htt_stats_buf->msdu_removed_tqm);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_mpdus_max_retries = %u\n",
			   htt_stats_buf->remove_mpdus_max_retries);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_sw_flush = %u\n",
			   htt_stats_buf->mpdus_sw_flush);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
			   htt_stats_buf->mpdus_hw_filter);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_truncated = %u\n",
			   htt_stats_buf->mpdus_truncated);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_ack_failed = %u\n",
			   htt_stats_buf->mpdus_ack_failed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_expired = %u\n",
			   htt_stats_buf->mpdus_expired);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n",
			   htt_stats_buf->mpdus_seq_hw_retry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
			   htt_stats_buf->ack_tlv_proc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n",
			   htt_stats_buf->coex_abort_mpdu_cnt_valid);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n",
			   htt_stats_buf->coex_abort_mpdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n",
			   htt_stats_buf->num_total_ppdus_tried_ota);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n",
			   htt_stats_buf->num_data_ppdus_tried_ota);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n",
			   htt_stats_buf->local_ctrl_mgmt_enqued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n",
			   htt_stats_buf->local_ctrl_mgmt_freed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_data_enqued = %u\n",
			   htt_stats_buf->local_data_enqued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_data_freed = %u\n",
			   htt_stats_buf->local_data_freed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_tried = %u\n",
			   htt_stats_buf->mpdu_tried);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n",
			   htt_stats_buf->isr_wait_seq_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n",
			   htt_stats_buf->tx_active_dur_us_low);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n",
			   htt_stats_buf->tx_active_dur_us_high);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fes_offsets_err_cnt = %u\n",
			   htt_stats_buf->fes_offsets_err_cnt);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_urrn_tlv_v(const void *tag_buf,
				   u16 tag_len,
				   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_urrn_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_URRN_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_URRN_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "urrn_stats = ");

	ARRAY_TO_BUF(buf, len, htt_stats_buf->urrn_stats, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_flush_tlv_v(const void *tag_buf,
				    u16 tag_len,
				    struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_flush_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_FLUSH_REASON_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_FLUSH_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "flush_errs = ");

	ARRAY_TO_BUF(buf, len, htt_stats_buf->flush_errs, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_sifs_tlv_v(const void *tag_buf,
				   u16 tag_len,
				   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_sifs_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_SIFS_BURST_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_SIFS_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sifs_status = ");

	ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_status, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_phy_err_tlv_v(const void *tag_buf,
				      u16 tag_len,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_phy_err_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_PHY_ERR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_PHY_ERR_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_errs = ");

	ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_errs, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_sifs_hist_tlv_v(const void *tag_buf,
					u16 tag_len,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_sifs_hist_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_SIFS_BURST_HIST_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_PDEV_STATS_SIFS_HIST_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sifs_hist_status = ");

	ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_hist_status, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_tx_ppdu_stats_tlv_v(const void *tag_buf,
					    struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_tx_ppdu_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_PDEV_STATS_TX_PPDU_STATS_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_data_ppdus_legacy_su = %u\n",
			   htt_stats_buf->num_data_ppdus_legacy_su);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_data_ppdus_ac_su = %u\n",
			   htt_stats_buf->num_data_ppdus_ac_su);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_data_ppdus_ax_su = %u\n",
			   htt_stats_buf->num_data_ppdus_ax_su);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_data_ppdus_ac_su_txbf = %u\n",
			   htt_stats_buf->num_data_ppdus_ac_su_txbf);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_data_ppdus_ax_su_txbf = %u\n",
			   htt_stats_buf->num_data_ppdus_ax_su_txbf);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v(const void *tag_buf,
						  u16 tag_len,
						  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u32  num_elements = ((tag_len - sizeof(htt_stats_buf->hist_bin_size)) >> 2);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_PDEV_STATS_TRIED_MPDU_CNT_HIST_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n",
			   htt_stats_buf->hist_bin_size);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "tried_mpdu_cnt_hist = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_hw_stats_intr_misc_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_hw_stats_intr_misc_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	char hw_intr_name[HTT_STATS_MAX_HW_INTR_NAME_LEN + 1] = {0};

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_HW_STATS_INTR_MISC_TLV:\n");
	memcpy(hw_intr_name, &(htt_stats_buf->hw_intr_name[0]),
	       HTT_STATS_MAX_HW_INTR_NAME_LEN);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_intr_name = %s \n", hw_intr_name);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mask = %u\n",
			   htt_stats_buf->mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "count = %u\n",
			   htt_stats_buf->count);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_hw_stats_wd_timeout_tlv(const void *tag_buf,
				  struct debug_htt_stats_req *stats_req)
{
	const struct htt_hw_stats_wd_timeout_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	char hw_module_name[HTT_STATS_MAX_HW_MODULE_NAME_LEN + 1] = {0};

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_HW_STATS_WD_TIMEOUT_TLV:\n");
	memcpy(hw_module_name, &(htt_stats_buf->hw_module_name[0]),
	       HTT_STATS_MAX_HW_MODULE_NAME_LEN);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_module_name = %s \n",
			   hw_module_name);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "count = %u\n",
			   htt_stats_buf->count);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_hw_stats_pdev_errs_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_hw_stats_pdev_errs_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_abort = %u\n",
			   htt_stats_buf->tx_abort);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_abort_fail_count = %u\n",
			   htt_stats_buf->tx_abort_fail_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_abort = %u\n",
			   htt_stats_buf->rx_abort);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_abort_fail_count = %u\n",
			   htt_stats_buf->rx_abort_fail_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_flush_cnt = %u\n",
			   htt_stats_buf->rx_flush_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "warm_reset = %u\n",
			   htt_stats_buf->warm_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cold_reset = %u\n",
			   htt_stats_buf->cold_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_cold_reset_restore_cal = %u\n",
			   htt_stats_buf->mac_cold_reset_restore_cal);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_cold_reset = %u\n",
			   htt_stats_buf->mac_cold_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_warm_reset = %u\n",
			   htt_stats_buf->mac_warm_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_only_reset = %u\n",
			   htt_stats_buf->mac_only_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_warm_reset = %u\n",
			   htt_stats_buf->phy_warm_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_warm_reset_ucode_trig = %u\n",
			   htt_stats_buf->phy_warm_reset_ucode_trig);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_warm_reset_restore_cal = %u\n",
			   htt_stats_buf->mac_warm_reset_restore_cal);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_sfm_reset = %u\n",
			   htt_stats_buf->mac_sfm_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_warm_reset_m3_ssr = %u\n",
			   htt_stats_buf->phy_warm_reset_m3_ssr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_rx_rings_reset = %u\n",
			   htt_stats_buf->fw_rx_rings_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_flush = %u\n",
			   htt_stats_buf->tx_flush);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_glb_reset = %u\n",
			   htt_stats_buf->tx_glb_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_txq_reset = %u\n",
			   htt_stats_buf->tx_txq_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n",
			   htt_stats_buf->rx_timeout_reset);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "PDEV_PHY_WARM_RESET_REASONS:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_warm_reset_reason_phy_m3 = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_phy_m3);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_tx_hw_stuck = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_tx_hw_stuck);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_num_cca_rx_frame_stuck = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_num_cca_rx_frame_stuck);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_wal_rx_recovery_rst_rx_busy = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_wal_rx_recovery_rst_rx_busy);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_wal_rx_recovery_rst_mac_hang = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_wal_rx_recovery_rst_mac_hang);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_mac_reset_converted_phy_reset = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_mac_reset_converted_phy_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_tx_lifetime_expiry_cca_stuck = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_tx_lifetime_expiry_cca_stuck);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_tx_consecutive_flush9_war = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_tx_consecutive_flush9_war);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_tx_hwsch_reset_war = %u\n",
			   htt_stats_buf->phy_warm_reset_reason_tx_hwsch_reset_war);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "phy_warm_reset_reason_hwsch_wdog_or_cca_wdog_war = %u\n\n",
			   htt_stats_buf->phy_warm_reset_reason_hwsch_wdog_or_cca_wdog_war);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "WAL_RX_RECOVERY_STATS:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "wal_rx_recovery_rst_mac_hang_count = %u\n",
			   htt_stats_buf->wal_rx_recovery_rst_mac_hang_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "wal_rx_recovery_rst_known_sig_count = %u\n",
			   htt_stats_buf->wal_rx_recovery_rst_known_sig_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "wal_rx_recovery_rst_no_rx_count = %u\n",
			   htt_stats_buf->wal_rx_recovery_rst_no_rx_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "wal_rx_recovery_rst_no_rx_consecutive_count = %u\n",
			   htt_stats_buf->wal_rx_recovery_rst_no_rx_consecutive_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "wal_rx_recovery_rst_rx_busy_count = %u\n",
			   htt_stats_buf->wal_rx_recovery_rst_rx_busy_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "wal_rx_recovery_rst_phy_mac_hang_count = %u\n",
			   htt_stats_buf->wal_rx_recovery_rst_phy_mac_hang_count);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_msdu_flow_stats_tlv(const void *tag_buf,
						 struct debug_htt_stats_req *stats_req)
{
	const struct htt_msdu_flow_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_MSDU_FLOW_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_update_timestamp = %u\n",
			   htt_stats_buf->last_update_timestamp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_add_timestamp = %u\n",
			   htt_stats_buf->last_add_timestamp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_remove_timestamp = %u\n",
			   htt_stats_buf->last_remove_timestamp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "total_processed_msdu_count = %u\n",
			   htt_stats_buf->total_processed_msdu_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cur_msdu_count_in_flowq = %u\n",
			   htt_stats_buf->cur_msdu_count_in_flowq);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sw_peer_id = %u\n",
			   htt_stats_buf->sw_peer_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_flow_no = %u\n",
			   htt_stats_buf->tx_flow_no__tid_num__drop_rule & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_num = %u\n",
			   (htt_stats_buf->tx_flow_no__tid_num__drop_rule & 0xF0000) >>
			   16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "drop_rule = %u\n",
			   (htt_stats_buf->tx_flow_no__tid_num__drop_rule & 0x100000) >>
			   20);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_cycle_enqueue_count = %u\n",
			   htt_stats_buf->last_cycle_enqueue_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_cycle_dequeue_count = %u\n",
			   htt_stats_buf->last_cycle_dequeue_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_cycle_drop_count = %u\n",
			   htt_stats_buf->last_cycle_drop_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "current_drop_th = %u\n",
			   htt_stats_buf->current_drop_th);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_tid_stats_tlv(const void *tag_buf,
					      struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tid_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	char tid_name[MAX_HTT_TID_NAME + 1] = {0};

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TID_STATS_TLV:\n");
	memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_name = %s \n", tid_name);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sw_peer_id = %u\n",
			   htt_stats_buf->sw_peer_id__tid_num & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_num = %u\n",
			   (htt_stats_buf->sw_peer_id__tid_num & 0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_sched_pending = %u\n",
			   htt_stats_buf->num_sched_pending__num_ppdu_in_hwq & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_ppdu_in_hwq = %u\n",
			   (htt_stats_buf->num_sched_pending__num_ppdu_in_hwq &
			   0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_flags = 0x%x\n",
			   htt_stats_buf->tid_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_queued = %u\n",
			   htt_stats_buf->hw_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_reaped = %u\n",
			   htt_stats_buf->hw_reaped);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
			   htt_stats_buf->mpdus_hw_filter);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qdepth_bytes = %u\n",
			   htt_stats_buf->qdepth_bytes);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qdepth_num_msdu = %u\n",
			   htt_stats_buf->qdepth_num_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n",
			   htt_stats_buf->qdepth_num_mpdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n",
			   htt_stats_buf->last_scheduled_tsmp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pause_module_id = %u\n",
			   htt_stats_buf->pause_module_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "block_module_id = %u\n",
			   htt_stats_buf->block_module_id);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_tid_stats_v1_tlv(const void *tag_buf,
						 struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tid_stats_v1_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	char tid_name[MAX_HTT_TID_NAME + 1] = {0};

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TID_STATS_V1_TLV:\n");
	memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_name = %s \n", tid_name);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sw_peer_id = %u\n",
			   htt_stats_buf->sw_peer_id__tid_num & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_num = %u\n",
			   (htt_stats_buf->sw_peer_id__tid_num & 0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_sched_pending = %u\n",
			   htt_stats_buf->num_sched_pending__num_ppdu_in_hwq & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_ppdu_in_hwq = %u\n",
			   (htt_stats_buf->num_sched_pending__num_ppdu_in_hwq &
			   0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_flags = 0x%x\n",
			   htt_stats_buf->tid_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "max_qdepth_bytes = %u\n",
			   htt_stats_buf->max_qdepth_bytes);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "max_qdepth_n_msdus = %u\n",
			   htt_stats_buf->max_qdepth_n_msdus);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rsvd = %u\n",
			   htt_stats_buf->rsvd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qdepth_bytes = %u\n",
			   htt_stats_buf->qdepth_bytes);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qdepth_num_msdu = %u\n",
			   htt_stats_buf->qdepth_num_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n",
			   htt_stats_buf->qdepth_num_mpdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n",
			   htt_stats_buf->last_scheduled_tsmp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pause_module_id = %u\n",
			   htt_stats_buf->pause_module_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "block_module_id = %u\n",
			   htt_stats_buf->block_module_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "allow_n_flags = 0x%x\n",
			   htt_stats_buf->allow_n_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sendn_frms_allowed = %u\n",
			   htt_stats_buf->sendn_frms_allowed);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_rx_tid_stats_tlv(const void *tag_buf,
					      struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_tid_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	char tid_name[MAX_HTT_TID_NAME + 1] = {0};

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_TID_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sw_peer_id = %u\n",
			   htt_stats_buf->sw_peer_id__tid_num & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_num = %u\n",
			   (htt_stats_buf->sw_peer_id__tid_num & 0xFFFF0000) >> 16);
	memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tid_name = %s \n", tid_name);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dup_in_reorder = %u\n",
			   htt_stats_buf->dup_in_reorder);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dup_past_outside_window = %u\n",
			   htt_stats_buf->dup_past_outside_window);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dup_past_within_window = %u\n",
			   htt_stats_buf->dup_past_within_window);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rxdesc_err_decrypt = %u\n",
			   htt_stats_buf->rxdesc_err_decrypt);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_counter_tlv(const void *tag_buf,
					 struct debug_htt_stats_req *stats_req)
{
	const struct htt_counter_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_COUNTER_TLV:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "counter_name = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->counter_name, HTT_MAX_COUNTER_NAME);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ncount = %u\n",
			   htt_stats_buf->count);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_peer_stats_cmn_tlv(const void *tag_buf,
						struct debug_htt_stats_req *stats_req)
{
	const struct htt_peer_stats_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PEER_STATS_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ppdu_cnt = %u\n",
			   htt_stats_buf->ppdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_cnt = %u\n",
			   htt_stats_buf->mpdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "msdu_cnt = %u\n",
			   htt_stats_buf->msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pause_bitmap = %u\n",
			   htt_stats_buf->pause_bitmap);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "block_bitmap = %u\n",
			   htt_stats_buf->block_bitmap);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_rssi = %d\n",
			   htt_stats_buf->rssi);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "enqueued_count = %llu\n",
			   htt_stats_buf->peer_enqueued_count_low |
			   ((u64)htt_stats_buf->peer_enqueued_count_high << 32));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dequeued_count = %llu\n",
			   htt_stats_buf->peer_dequeued_count_low |
			   ((u64)htt_stats_buf->peer_dequeued_count_high << 32));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dropped_count = %llu\n",
			   htt_stats_buf->peer_dropped_count_low |
			   ((u64)htt_stats_buf->peer_dropped_count_high << 32));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "transmitted_ppdu_bytes = %llu\n",
			   htt_stats_buf->ppdu_transmitted_bytes_low |
			   ((u64)htt_stats_buf->ppdu_transmitted_bytes_high << 32));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_mpdus_max_retries = %u\n",
			   htt_stats_buf->remove_mpdus_max_retries);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ttl_removed_count = %u\n",
			   htt_stats_buf->peer_ttl_removed_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "inactive_time = %u\n",
			   htt_stats_buf->inactive_time);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_peer_details_tlv(const void *tag_buf,
					      struct debug_htt_stats_req *stats_req)
{
	const struct htt_peer_details_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PEER_DETAILS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_type = %u\n",
			   htt_stats_buf->peer_type);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sw_peer_id = %u\n",
			   htt_stats_buf->sw_peer_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "vdev_id = %u\n",
			   htt_stats_buf->vdev_pdev_ast_idx & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pdev_id = %u\n",
			   (htt_stats_buf->vdev_pdev_ast_idx & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ast_idx = %u\n",
			   (htt_stats_buf->vdev_pdev_ast_idx & 0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "mac_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
			   htt_stats_buf->mac_addr.mac_addr_l32 & 0xFF,
			   (htt_stats_buf->mac_addr.mac_addr_l32 & 0xFF00) >> 8,
			   (htt_stats_buf->mac_addr.mac_addr_l32 & 0xFF0000) >> 16,
			   (htt_stats_buf->mac_addr.mac_addr_l32 & 0xFF000000) >> 24,
			   (htt_stats_buf->mac_addr.mac_addr_h16 & 0xFF),
			   (htt_stats_buf->mac_addr.mac_addr_h16 & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_flags = 0x%x\n",
			   htt_stats_buf->peer_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qpeer_flags = 0x%x\n",
			   htt_stats_buf->qpeer_flags);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_peer_rate_stats_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_peer_rate_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PEER_RATE_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_ldpc = %u\n",
			   htt_stats_buf->tx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts_cnt = %u\n",
			   htt_stats_buf->rts_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ack_rssi = %u\n",
			   htt_stats_buf->ack_rssi);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_su_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_su_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_mu_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mu_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss,
		     HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw,
		     HTT_TX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_stbc = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_pream = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream,
		     HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES);

	for (j = 0; j < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_gi[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_gi[j],
		             HTT_TX_PEER_STATS_NUM_MCS_COUNTERS);
	}
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_dcm = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm,
		     HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_rx_peer_rate_stats_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_peer_rate_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_PEER_RATE_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "nsts = %u\n",
			   htt_stats_buf->nsts);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ldpc = %u\n",
			   htt_stats_buf->rx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts_cnt = %u\n",
			   htt_stats_buf->rts_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_mgmt = %u\n",
			   htt_stats_buf->rssi_mgmt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_data = %u\n",
			   htt_stats_buf->rssi_data);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_comb = %u\n",
			   htt_stats_buf->rssi_comb);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss,
		     HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_dcm = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm,
		     HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_stbc = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw,
		     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);

	for (j = 0; j < HTT_RX_PEER_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrssi_chain[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain[j],
			     HTT_RX_PEER_STATS_NUM_BW_COUNTERS);
	}

	for (j = 0; j < HTT_RX_PEER_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrssi_chain_ext[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain_ext[j],
			     HTT_RX_PEER_STATS_NUM_BW_EXT_COUNTERS);
	}


	for (j = 0; j < HTT_RX_PEER_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_gi[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi[j],
		             HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_pream = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream,
		     HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_non_data_ppdu = %u\n",
			   htt_stats_buf->rx_ulofdma_non_data_ppdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulofdma_data_ppdu = %u\n",
			   htt_stats_buf->rx_ulofdma_data_ppdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulofdma_mpdu_ok = %u\n",
			   htt_stats_buf->rx_ulofdma_mpdu_ok);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulofdma_mpdu_fail = %u\n",
			   htt_stats_buf->rx_ulofdma_mpdu_fail);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulmumimo_non_data_ppdu = %u\n",
			   htt_stats_buf->rx_ulmumimo_non_data_ppdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulmumimo_data_ppdu = %u\n",
			   htt_stats_buf->rx_ulmumimo_data_ppdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulmumimo_mpdu_ok = %u\n",
			   htt_stats_buf->rx_ulmumimo_mpdu_ok);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ulmumimo_mpdu_fail = %u\n",
			   htt_stats_buf->rx_ulmumimo_mpdu_fail);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ul_fd_rssi = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ul_fd_rssi,
		     HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nper_chain_rssi_pkt_type = %#x",
			   htt_stats_buf->per_chain_rssi_pkt_type);

	for (j = 0; j < HTT_RX_PEER_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_per_chain_rssi_in_dbm[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_per_chain_rssi_in_dbm[j],
			     HTT_RX_PEER_STATS_NUM_BW_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_mu_mimo_sch_stats_tlv(const void *tag_buf,
				       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_SCH_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
			   htt_stats_buf->mu_mimo_sch_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
			   htt_stats_buf->mu_mimo_sch_failed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n",
			   htt_stats_buf->mu_mimo_ppdu_posted);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_mu_mimo_mpdu_stats_tlv(const void *tag_buf,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_mu_mimo_mpdu_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_HWQ_MU_MIMO_MPDU_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_mpdus_queued_usr = %u\n",
			   htt_stats_buf->mu_mimo_mpdus_queued_usr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_mpdus_tried_usr = %u\n",
			   htt_stats_buf->mu_mimo_mpdus_tried_usr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_mpdus_failed_usr = %u\n",
			   htt_stats_buf->mu_mimo_mpdus_failed_usr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_mpdus_requeued_usr = %u\n",
			   htt_stats_buf->mu_mimo_mpdus_requeued_usr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_err_no_ba_usr = %u\n",
			   htt_stats_buf->mu_mimo_err_no_ba_usr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_mpdu_underrun_usr = %u\n",
			   htt_stats_buf->mu_mimo_mpdu_underrun_usr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_ampdu_underrun_usr = %u\n",
			   htt_stats_buf->mu_mimo_ampdu_underrun_usr);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_mu_mimo_cmn_stats_tlv(const void *tag_buf,
				       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_mu_mimo_cmn_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_CMN_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__hwq_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwq_id = %u\n",
			   (htt_stats_buf->mac_id__hwq_id__word & 0xFF00) >> 8);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_stats_cmn_tlv(const void *tag_buf, struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_stats_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	/* TODO: HKDBG */
	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_HWQ_STATS_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__hwq_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwq_id = %u\n",
			   (htt_stats_buf->mac_id__hwq_id__word & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "xretry = %u\n",
			   htt_stats_buf->xretry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "underrun_cnt = %u\n",
			   htt_stats_buf->underrun_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "flush_cnt = %u\n",
			   htt_stats_buf->flush_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "filt_cnt = %u\n",
			   htt_stats_buf->filt_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "null_mpdu_bmap = %u\n",
			   htt_stats_buf->null_mpdu_bmap);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "user_ack_failure = %u\n",
			   htt_stats_buf->user_ack_failure);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
			   htt_stats_buf->ack_tlv_proc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_id_proc = %u\n",
			   htt_stats_buf->sched_id_proc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "null_mpdu_tx_count = %u\n",
			   htt_stats_buf->null_mpdu_tx_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_bmap_not_recvd = %u\n",
			   htt_stats_buf->mpdu_bmap_not_recvd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_bar = %u\n",
			   htt_stats_buf->num_bar);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts = %u\n",
			   htt_stats_buf->rts);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cts2self = %u\n",
			   htt_stats_buf->cts2self);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qos_null = %u\n",
			   htt_stats_buf->qos_null);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_tried_cnt = %u\n",
			   htt_stats_buf->mpdu_tried_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_queued_cnt = %u\n",
			   htt_stats_buf->mpdu_queued_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_ack_fail_cnt = %u\n",
			   htt_stats_buf->mpdu_ack_fail_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_filt_cnt = %u\n",
			   htt_stats_buf->mpdu_filt_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "false_mpdu_ack_count = %u\n",
			   htt_stats_buf->false_mpdu_ack_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "txq_timeout = %u\n",
			   htt_stats_buf->txq_timeout);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_difs_latency_stats_tlv_v(const void *tag_buf,
					  u16 tag_len,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_difs_latency_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 data_len = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_DIFS_LATENCY_BINS);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_HWQ_DIFS_LATENCY_STATS_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hist_intvl = %u\n",
			htt_stats_buf->hist_intvl);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "difs_latency_hist = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->difs_latency_hist, data_len);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_cmd_result_stats_tlv_v(const void *tag_buf,
					u16 tag_len,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_cmd_result_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 data_len;

	data_len = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_CMD_RESULT_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_HWQ_CMD_RESULT_STATS_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "cmd_result = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_result, data_len);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_cmd_stall_stats_tlv_v(const void *tag_buf,
				       u16 tag_len,
				       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_cmd_stall_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems;

	num_elems = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_CMD_STALL_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_HWQ_CMD_STALL_STATS_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "cmd_stall_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_stall_status, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_fes_result_stats_tlv_v(const void *tag_buf,
					u16 tag_len,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_fes_result_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems;

	num_elems = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_FES_RESULT_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_HWQ_FES_RESULT_STATS_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "fes_result = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fes_result, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_tried_mpdu_cnt_hist_tlv_v(const void *tag_buf,
					   u16 tag_len,
					   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_tried_mpdu_cnt_hist_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u32  num_elements = ((tag_len -
			    sizeof(htt_stats_buf->hist_bin_size)) >> 2);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_HWQ_TRIED_MPDU_CNT_HIST_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n",
			   htt_stats_buf->hist_bin_size);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "tried_mpdu_cnt_hist = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_hwq_txop_used_cnt_hist_tlv_v(const void *tag_buf,
					  u16 tag_len,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_hwq_txop_used_cnt_hist_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u32 num_elements = tag_len >> 2;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_HWQ_TXOP_USED_CNT_HIST_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "txop_used_cnt_hist = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->txop_used_cnt_hist, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_sounding_stats_tlv(const void *tag_buf,
						   struct debug_htt_stats_req *stats_req)
{
	s32 i;
	const struct htt_tx_sounding_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	const u32 *cbf_20 = htt_stats_buf->cbf_20;
	const u32 *cbf_40 = htt_stats_buf->cbf_40;
	const u32 *cbf_80 = htt_stats_buf->cbf_80;
	const u32 *cbf_160 = htt_stats_buf->cbf_160;

	if (htt_stats_buf->tx_sounding_mode == HTT_TX_AC_SOUNDING_MODE) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nHTT_TX_AC_SOUNDING_STATS_TLV:\n");
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ac_cbf_20 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_20[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ac_cbf_40 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_40[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ac_cbf_80 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_80[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ac_cbf_160 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_160[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);

		for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++) {
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "Sounding User %u = 20MHz: %u, 40MHz : %u, 80MHz: %u, 160MHz: %u\n",
					   i,
					   htt_stats_buf->sounding[0],
					   htt_stats_buf->sounding[1],
					   htt_stats_buf->sounding[2],
					   htt_stats_buf->sounding[3]);
		}
	} else if (htt_stats_buf->tx_sounding_mode == HTT_TX_AX_SOUNDING_MODE) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nHTT_TX_AX_SOUNDING_STATS_TLV:\n");
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_cbf_20 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_20[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_20[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_cbf_40 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_40[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_40[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_cbf_80 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_80[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_80[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_cbf_160 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
				   cbf_160[HTT_IMPLICIT_TXBF_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
				   cbf_160[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);

		for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++) {
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "Sounding User %u = 20MHz: %u, 40MHz : %u, 80MHz: %u, 160MHz: %u\n",
					   i,
					   htt_stats_buf->sounding[0],
					   htt_stats_buf->sounding[1],
					   htt_stats_buf->sounding[2],
					   htt_stats_buf->sounding[3]);
		}
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_cmn_stats_tlv(const void *tag_buf,
				   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_cmn_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_bar = %u\n",
			   htt_stats_buf->su_bar);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts = %u\n",
			   htt_stats_buf->rts);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cts2self = %u\n",
			   htt_stats_buf->cts2self);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qos_null = %u\n",
			   htt_stats_buf->qos_null);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_1 = %u\n",
			   htt_stats_buf->delayed_bar_1);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_2 = %u\n",
			   htt_stats_buf->delayed_bar_2);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_3 = %u\n",
			   htt_stats_buf->delayed_bar_3);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_4 = %u\n",
			   htt_stats_buf->delayed_bar_4);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_5 = %u\n",
			   htt_stats_buf->delayed_bar_5);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_6 = %u\n",
			   htt_stats_buf->delayed_bar_6);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "delayed_bar_7 = %u\n",
			   htt_stats_buf->delayed_bar_7);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "bar_with_tqm_head_seq_num = %u\n",
			   htt_stats_buf->bar_with_tqm_head_seq_num);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "bar_with_tid_seq_num = %u\n",
			   htt_stats_buf->bar_with_tid_seq_num);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_sw_rts_queued = %u\n",
			   htt_stats_buf->su_sw_rts_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_sw_rts_tried = %u\n",
			   htt_stats_buf->su_sw_rts_tried);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_sw_rts_err = %u\n",
			   htt_stats_buf->su_sw_rts_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_sw_rts_flushed = %u\n",
			   htt_stats_buf->su_sw_rts_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_sw_rts_rcvd_cts_diff_bw = %u\n",
			   htt_stats_buf->su_sw_rts_rcvd_cts_diff_bw);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_ac_stats_tlv(const void *tag_buf,
				  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_ac_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndpa_queued = %u\n",
			   htt_stats_buf->ac_su_ndpa_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndpa_tried = %u\n",
			   htt_stats_buf->ac_su_ndpa);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndp_queued = %u\n",
			   htt_stats_buf->ac_su_ndp_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndp_tried = %u\n",
			   htt_stats_buf->ac_su_ndp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndpa_queued = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndpa_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndpa_tried = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndpa);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndp_queued = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndp_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndp_tried = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brpoll_1_queued = %u\n",
			   htt_stats_buf->ac_mu_mimo_brpoll_1_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brpoll_1_tried = %u\n",
			   htt_stats_buf->ac_mu_mimo_brpoll_1);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brpoll_2_queued = %u\n",
			   htt_stats_buf->ac_mu_mimo_brpoll_2_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brpoll_2_tried = %u\n",
			   htt_stats_buf->ac_mu_mimo_brpoll_2);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brpoll_3_queued = %u\n",
			   htt_stats_buf->ac_mu_mimo_brpoll_3_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brpoll_3_tried = %u\n",
			   htt_stats_buf->ac_mu_mimo_brpoll_3);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_ax_stats_tlv(const void *tag_buf,
				  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_ax_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndpa_queued = %u\n",
			   htt_stats_buf->ax_su_ndpa_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndpa_tried = %u\n",
			   htt_stats_buf->ax_su_ndpa);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndp_queued = %u\n",
			   htt_stats_buf->ax_su_ndp_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndp_tried = %u\n",
			   htt_stats_buf->ax_su_ndp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndpa_queued = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndpa_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndpa_tried = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndpa);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndp_queued = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndp_queued);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndp_tried = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_brpollX_queued = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_brpoll_queued,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS - 1);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_brpollX_tried = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_brpoll,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS - 1);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_ul_mumimo_trigger = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_ul_mumimo_trigger,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_basic_trigger = %u\n",
			   htt_stats_buf->ax_basic_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_ulmumimo_trigger = %u\n",
			   htt_stats_buf->ax_ulmumimo_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_bsr_trigger = %u\n",
			   htt_stats_buf->ax_bsr_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n",
			   htt_stats_buf->ax_mu_bar_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n",
			   htt_stats_buf->ax_mu_rts_trigger);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_ac_err_stats_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_ac_err_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndp_err = %u\n",
			   htt_stats_buf->ac_su_ndp_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndp_flushed = %u\n",
			   htt_stats_buf->ac_su_ndp_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n",
			   htt_stats_buf->ac_su_ndpa_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndpa_flushed = %u\n",
			   htt_stats_buf->ac_su_ndpa_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndpa_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndpa_flushed = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndpa_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndp_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_ndp_flushed = %u\n",
			   htt_stats_buf->ac_mu_mimo_ndp_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n",
			   htt_stats_buf->ac_mu_mimo_brp1_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n",
			   htt_stats_buf->ac_mu_mimo_brp2_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n",
			   htt_stats_buf->ac_mu_mimo_brp3_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brp1_flushed = %u\n",
			   htt_stats_buf->ac_mu_mimo_brp1_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brp2_flushed = %u\n",
			   htt_stats_buf->ac_mu_mimo_brp2_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_brp3_flushed = %u\n",
			   htt_stats_buf->ac_mu_mimo_brp3_flushed);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_ax_err_stats_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_ax_err_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndp_err = %u\n",
			   htt_stats_buf->ax_su_ndp_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndp_flushed = %u\n",
			   htt_stats_buf->ax_su_ndp_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n",
			   htt_stats_buf->ax_su_ndpa_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndpa_flushed = %u\n",
			   htt_stats_buf->ax_su_ndpa_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndpa_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndpa_flushed = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndpa_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndp_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_ndp_flushed = %u\n",
			   htt_stats_buf->ax_mu_mimo_ndp_flushed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_brpX_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_brp_err,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS - 1);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_brpollX_flushed = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_brpoll_flushed,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS - 1);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			  "\nax_mu_mimo_num_cbf_rcvd_on_brp_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_brp_err_num_cbf_received,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_ul_mumimo_trigger_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_ul_mumimo_trigger_err,
		     HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_basic_trigger_err = %u\n",
			   htt_stats_buf->ax_basic_trigger_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_ulmumimo_trigger_err = %u\n",
			   htt_stats_buf->ax_ulmumimo_trigger_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n",
			   htt_stats_buf->ax_bsr_trigger_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n",
			   htt_stats_buf->ax_mu_bar_trigger_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n",
			   htt_stats_buf->ax_mu_rts_trigger_err);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_mu_mimo_sch_stats_tlv(const void *tag_buf,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 i;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
			   htt_stats_buf->mu_mimo_sch_posted);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
			   htt_stats_buf->mu_mimo_sch_failed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n",
			   htt_stats_buf->mu_mimo_ppdu_posted);

	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ac_mu_mimo_sch_posted_per_group_index %u = %u\n",
				   i, htt_stats_buf->ac_mu_mimo_sch_posted_per_grp_sz[i]);

	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_mu_mimo_sch_posted_per_group_index %u = %u\n",
				   i, htt_stats_buf->ax_mu_mimo_sch_posted_per_grp_sz[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "11ac MU_MIMO SCH STATS:\n");

	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ac_mu_mimo_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ac_mu_mimo_sch_nusers[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n11ax MU_MIMO SCH STATS:\n");

	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_mu_mimo_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_mu_mimo_sch_nusers[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n11ax OFDMA SCH STATS:\n");

	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ofdma_sch_nusers[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ul_ofdma_basic_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ul_ofdma_basic_sch_nusers[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ul_ofdma_bsr_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ul_ofdma_bsr_sch_nusers[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ul_ofdma_sch_bar_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ul_ofdma_bar_sch_nusers[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ul_ofdma_brp_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ul_ofdma_brp_sch_nusers[i]);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n11ax UL MUMIO SCH STATS:\n");

	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_UL_MUMIMO_USER_STATS; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ul_mumimo_basic_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ul_mumimo_basic_sch_nusers[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ul_mumimo_brp_sch_nusers_%u = %u\n",
				   i, htt_stats_buf->ax_ul_mumimo_brp_sch_nusers[i]);
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(const void *tag_buf,
					 struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_mpdu_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_MIMO_AC) {
		if (!htt_stats_buf->user_index)
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "HTT_TX_PDEV_MU_MIMO_AC_MPDU_STATS:\n");

		if (htt_stats_buf->user_index <
		    HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS) {
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_mpdus_queued_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_queued_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_mpdus_tried_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_tried_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_mpdus_failed_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_failed_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_mpdus_requeued_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_requeued_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_err_no_ba_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->err_no_ba_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_mpdu_underrun_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdu_underrun_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ac_mu_mimo_ampdu_underrun_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->ampdu_underrun_usr);
		}
	}

	if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_MIMO_AX) {
		if (!htt_stats_buf->user_index)
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "HTT_TX_PDEV_MU_MIMO_AX_MPDU_STATS:\n");

		if (htt_stats_buf->user_index <
		    HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS) {
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_mpdus_queued_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_queued_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_mpdus_tried_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_tried_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_mpdus_failed_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_failed_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_mpdus_requeued_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_requeued_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_err_no_ba_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->err_no_ba_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_mpdu_underrun_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdu_underrun_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->ampdu_underrun_usr);
		}
	}

	if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_OFDMA_AX) {
		if (!htt_stats_buf->user_index)
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "HTT_TX_PDEV_AX_MU_OFDMA_MPDU_STATS:\n");

		if (htt_stats_buf->user_index < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS) {
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_mpdus_queued_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_queued_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_mpdus_tried_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_tried_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_mpdus_failed_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_failed_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_mpdus_requeued_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdus_requeued_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_err_no_ba_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->err_no_ba_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_mpdu_underrun_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->mpdu_underrun_usr);
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n",
					   htt_stats_buf->user_index,
					   htt_stats_buf->ampdu_underrun_usr);
		}
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_sched_txq_cmd_posted_tlv_v(const void *tag_buf,
				     u16 tag_len,
				     struct debug_htt_stats_req *stats_req)
{
	const struct htt_sched_txq_cmd_posted_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elements = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_SCHED_TX_MODE_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_cmd_posted = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_cmd_posted, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_sched_txq_cmd_reaped_tlv_v(const void *tag_buf,
				     u16 tag_len,
				     struct debug_htt_stats_req *stats_req)
{
	const struct htt_sched_txq_cmd_reaped_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elements = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_SCHED_TX_MODE_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_REAPED_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_cmd_reaped = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_cmd_reaped, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_sched_txq_sched_order_su_tlv_v(const void *tag_buf,
					 u16 tag_len,
					 struct debug_htt_stats_req *stats_req)
{
	const struct htt_sched_txq_sched_order_su_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	/* each entry is u32, i.e. 4 bytes */
	u32 sched_order_su_num_entries =
		min_t(u32, (tag_len >> 2), HTT_TX_PDEV_NUM_SCHED_ORDER_LOG);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_SCHED_TXQ_SCHED_ORDER_SU_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_order_su = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_order_su, sched_order_su_num_entries);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_sched_txq_sched_ineligibility_tlv_v(const void *tag_buf,
					      u16 tag_len,
					      struct debug_htt_stats_req *stats_req)
{
	const struct htt_sched_txq_sched_ineligibility_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	/* each entry is u32, i.e. 4 bytes */
	u32 sched_ineligibility_num_entries = tag_len >> 2;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_SCHED_TXQ_SCHED_INELIGIBILITY_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_ineligibility = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_ineligibility,
		     sched_ineligibility_num_entries);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_pdev_stats_sched_per_txq_tlv(const void *tag_buf,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_stats_sched_per_txq_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__txq_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "txq_id = %u\n",
			   (htt_stats_buf->mac_id__txq_id__word & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_policy = %u\n",
			   htt_stats_buf->sched_policy);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "last_sched_cmd_posted_timestamp = %u\n",
			   htt_stats_buf->last_sched_cmd_posted_timestamp);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "last_sched_cmd_compl_timestamp = %u\n",
			   htt_stats_buf->last_sched_cmd_compl_timestamp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_2_tac_lwm_count = %u\n",
			   htt_stats_buf->sched_2_tac_lwm_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_2_tac_ring_full = %u\n",
			   htt_stats_buf->sched_2_tac_ring_full);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_cmd_post_failure = %u\n",
			   htt_stats_buf->sched_cmd_post_failure);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_active_tids = %u\n",
			   htt_stats_buf->num_active_tids);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_ps_schedules = %u\n",
			   htt_stats_buf->num_ps_schedules);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_cmds_pending = %u\n",
			   htt_stats_buf->sched_cmds_pending);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_tid_register = %u\n",
			   htt_stats_buf->num_tid_register);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_tid_unregister = %u\n",
			   htt_stats_buf->num_tid_unregister);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_qstats_queried = %u\n",
			   htt_stats_buf->num_qstats_queried);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qstats_update_pending = %u\n",
			   htt_stats_buf->qstats_update_pending);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_qstats_query_timestamp = %u\n",
			   htt_stats_buf->last_qstats_query_timestamp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_tqm_cmdq_full = %u\n",
			   htt_stats_buf->num_tqm_cmdq_full);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_de_sched_algo_trigger = %u\n",
			   htt_stats_buf->num_de_sched_algo_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_rt_sched_algo_trigger = %u\n",
			   htt_stats_buf->num_rt_sched_algo_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_tqm_sched_algo_trigger = %u\n",
			   htt_stats_buf->num_tqm_sched_algo_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "notify_sched = %u\n",
			   htt_stats_buf->notify_sched);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dur_based_sendn_term = %u\n",
			   htt_stats_buf->dur_based_sendn_term);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_notify2_sched = %u\n",
			   htt_stats_buf->su_notify2_sched);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_optimal_queued_msdus_sched = %u\n",
			   htt_stats_buf->su_optimal_queued_msdus_sched);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_delay_timeout_sched = %u\n",
			   htt_stats_buf->su_delay_timeout_sched);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_min_txtime_sched_delay = %u\n",
			   htt_stats_buf->su_min_txtime_sched_delay);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "su_no_delay = %u\n",
			   htt_stats_buf->su_no_delay);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_supercycles = %u\n",
			   htt_stats_buf->num_supercycles);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_subcycles_with_sort = %u\n",
			   htt_stats_buf->num_subcycles_with_sort);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_subcycles_no_sort = %u\n",
			   htt_stats_buf->num_subcycles_no_sort);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_stats_tx_sched_cmn_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_stats_tx_sched_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_STATS_TX_SCHED_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "current_timestamp = %u\n",
			   htt_stats_buf->current_timestamp);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_tqm_gen_mpdu_stats_tlv_v(const void *tag_buf,
				      u16 tag_len,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_gen_mpdu_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elements = min_t(u16, (tag_len >> 2),
				 HTT_TX_TQM_MAX_LIST_MPDU_END_REASON);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TQM_GEN_MPDU_STATS_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "gen_mpdu_end_reason = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->gen_mpdu_end_reason, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_tqm_list_mpdu_stats_tlv_v(const void *tag_buf,
				       u16 tag_len,
				       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_list_mpdu_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_TQM_MAX_LIST_MPDU_END_REASON);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_TQM_LIST_MPDU_STATS_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "list_mpdu_end_reason = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->list_mpdu_end_reason, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_tqm_list_mpdu_cnt_tlv_v(const void *tag_buf,
				     u16 tag_len,
				     struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_list_mpdu_cnt_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2),
			      HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "list_mpdu_cnt_hist = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->list_mpdu_cnt_hist, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_tqm_pdev_stats_tlv_v(const void *tag_buf,
				  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_pdev_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TQM_PDEV_STATS_TLV_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "msdu_count = %u\n",
			   htt_stats_buf->msdu_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_count = %u\n",
			   htt_stats_buf->mpdu_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_msdu = %u\n",
			   htt_stats_buf->remove_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_mpdu = %u\n",
			   htt_stats_buf->remove_mpdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_msdu_ttl = %u\n",
			   htt_stats_buf->remove_msdu_ttl);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "send_bar = %u\n",
			   htt_stats_buf->send_bar);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "bar_sync = %u\n",
			   htt_stats_buf->bar_sync);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "notify_mpdu = %u\n",
			   htt_stats_buf->notify_mpdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sync_cmd = %u\n",
			   htt_stats_buf->sync_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "write_cmd = %u\n",
			   htt_stats_buf->write_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_trigger = %u\n",
			   htt_stats_buf->hwsch_trigger);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
			   htt_stats_buf->ack_tlv_proc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n",
			   htt_stats_buf->gen_mpdu_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "gen_list_cmd = %u\n",
			   htt_stats_buf->gen_list_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n",
			   htt_stats_buf->remove_mpdu_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_mpdu_tried_cmd = %u\n",
			   htt_stats_buf->remove_mpdu_tried_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n",
			   htt_stats_buf->mpdu_queue_stats_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n",
			   htt_stats_buf->mpdu_head_info_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n",
			   htt_stats_buf->msdu_flow_stats_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_msdu_cmd = %u\n",
			   htt_stats_buf->remove_msdu_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_msdu_ttl_cmd = %u\n",
			   htt_stats_buf->remove_msdu_ttl_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "flush_cache_cmd = %u\n",
			   htt_stats_buf->flush_cache_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "update_mpduq_cmd = %u\n",
			   htt_stats_buf->update_mpduq_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "enqueue = %u\n",
			   htt_stats_buf->enqueue);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "enqueue_notify = %u\n",
			   htt_stats_buf->enqueue_notify);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "notify_mpdu_at_head = %u\n",
			   htt_stats_buf->notify_mpdu_at_head);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "notify_mpdu_state_valid = %u\n",
			   htt_stats_buf->notify_mpdu_state_valid);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_udp_notify1 = %u\n",
			   htt_stats_buf->sched_udp_notify1);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_udp_notify2 = %u\n",
			   htt_stats_buf->sched_udp_notify2);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_nonudp_notify1 = %u\n",
			   htt_stats_buf->sched_nonudp_notify1);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sched_nonudp_notify2 = %u\n",
			   htt_stats_buf->sched_nonudp_notify2);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_tqm_cmn_stats_tlv(const void *tag_buf, u16 tag_len,
			       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_cmn_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TQM_CMN_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "max_cmdq_id = %u\n",
			   htt_stats_buf->max_cmdq_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "list_mpdu_cnt_hist_intvl = %u\n",
			   htt_stats_buf->list_mpdu_cnt_hist_intvl);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "add_msdu = %u\n",
			   htt_stats_buf->add_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "q_empty = %u\n",
			   htt_stats_buf->q_empty);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "q_not_empty = %u\n",
			   htt_stats_buf->q_not_empty);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "drop_notification = %u\n",
			   htt_stats_buf->drop_notification);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "desc_threshold = %u\n",
			   htt_stats_buf->desc_threshold);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_tqm_invalid_status = %u\n",
			   htt_stats_buf->hwsch_tqm_invalid_status);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "missed_tqm_gen_mpdus = %u\n",
			   htt_stats_buf->missed_tqm_gen_mpdus);

	if (tag_len > (offsetof(struct htt_tx_tqm_cmn_stats_tlv, tqm_active_tids) -
		       offsetof(struct htt_tx_tqm_cmn_stats_tlv, mac_id__word))) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "active_tqm_tids = %u\n",
				   htt_stats_buf->tqm_active_tids);
		len += HTT_DBG_OUT(buf + len, buf_len - len, "inactive_tqm_tids = %u\n",
				   htt_stats_buf->tqm_inactive_tids);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "tqm_active_msduq_flows = %u\n",
				   htt_stats_buf->tqm_active_msduq_flows);
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_tqm_error_stats_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_error_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TQM_ERROR_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "q_empty_failure = %u\n",
			   htt_stats_buf->q_empty_failure);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "q_not_empty_failure = %u\n",
			   htt_stats_buf->q_not_empty_failure);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "add_msdu_failure = %u\n\n",
			   htt_stats_buf->add_msdu_failure);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "TQM_ERROR_RESET_STATS:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_cache_ctl_err = %u\n",
			   htt_stats_buf->tqm_cache_ctl_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_soft_reset = %u\n",
			   htt_stats_buf->tqm_soft_reset);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_total_num_in_use_link_descs = %u\n",
			   htt_stats_buf->tqm_reset_total_num_in_use_link_descs);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_worst_case_num_lost_link_descs = %u\n",
			   htt_stats_buf->tqm_reset_worst_case_num_lost_link_descs);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_worst_case_num_lost_host_tx_bufs_count = %u\n",
			   htt_stats_buf->tqm_reset_worst_case_num_lost_host_tx_bufs_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_num_in_use_link_descs_internal_tqm = %u\n",
			   htt_stats_buf->tqm_reset_num_in_use_link_descs_internal_tqm);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_num_in_use_link_descs_wbm_idle_link_ring = %u\n",
			   htt_stats_buf->tqm_reset_num_in_use_link_descs_wbm_idle_link_ring);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_time_to_tqm_hang_delta_ms = %u\n",
			   htt_stats_buf->tqm_reset_time_to_tqm_hang_delta_ms);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_reset_recovery_time_ms = %u\n",
			   htt_stats_buf->tqm_reset_recovery_time_ms);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_reset_num_peers_hdl = %u\n",
			   htt_stats_buf->tqm_reset_num_peers_hdl);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_cumm_dirty_hw_mpduq_proc_cnt = %u\n",
			   htt_stats_buf->tqm_reset_cumm_dirty_hw_mpduq_proc_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_cumm_dirty_hw_msduq_proc = %u\n",
			   htt_stats_buf->tqm_reset_cumm_dirty_hw_msduq_proc);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_flush_cache_cmd_su_cnt = %u\n",
			   htt_stats_buf->tqm_reset_flush_cache_cmd_su_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_flush_cache_cmd_other_cnt = %u\n",
			   htt_stats_buf->tqm_reset_flush_cache_cmd_other_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_flush_cache_cmd_trig_type = %u\n",
			   htt_stats_buf->tqm_reset_flush_cache_cmd_trig_type);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_flush_cache_cmd_trig_cfg = %u\n",
			   htt_stats_buf->tqm_reset_flush_cache_cmd_trig_cfg);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tqm_reset_flush_cache_cmd_skip_cmd_status_null = %u\n",
			   htt_stats_buf->tqm_reset_flush_cache_cmd_skip_cmd_status_null);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_tqm_cmdq_status_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_tqm_cmdq_status_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_TQM_CMDQ_STATUS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__cmdq_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cmdq_id = %u\n",
			   (htt_stats_buf->mac_id__cmdq_id__word & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sync_cmd = %u\n",
			   htt_stats_buf->sync_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "write_cmd = %u\n",
			   htt_stats_buf->write_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n",
			   htt_stats_buf->gen_mpdu_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n",
			   htt_stats_buf->mpdu_queue_stats_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n",
			   htt_stats_buf->mpdu_head_info_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n",
			   htt_stats_buf->msdu_flow_stats_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n",
			   htt_stats_buf->remove_mpdu_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "remove_msdu_cmd = %u\n",
			   htt_stats_buf->remove_msdu_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "flush_cache_cmd = %u\n",
			   htt_stats_buf->flush_cache_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "update_mpduq_cmd = %u\n",
			   htt_stats_buf->update_mpduq_cmd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "update_msduq_cmd = %u\n",
			   htt_stats_buf->update_msduq_cmd);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_eapol_packets_stats_tlv(const void *tag_buf,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_eapol_packets_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "m1_packets = %u\n",
			   htt_stats_buf->m1_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "m2_packets = %u\n",
			   htt_stats_buf->m2_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "m3_packets = %u\n",
			   htt_stats_buf->m3_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "m4_packets = %u\n",
			   htt_stats_buf->m4_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "g1_packets = %u\n",
			   htt_stats_buf->g1_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "g2_packets = %u\n",
			   htt_stats_buf->g2_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rc4_packets = %u\n",
			   htt_stats_buf->rc4_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eap_packets = %u\n",
			   htt_stats_buf->eap_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eapol_start_packets = %u\n",
			   htt_stats_buf->eapol_start_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eapol_logoff_packets = %u\n",
			   htt_stats_buf->eapol_logoff_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eapol_encap_asf_packets = %u\n",
			   htt_stats_buf->eapol_encap_asf_packets);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_classify_failed_stats_tlv(const void *tag_buf,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_classify_failed_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ap_bss_peer_not_found = %u\n",
			   htt_stats_buf->ap_bss_peer_not_found);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ap_bcast_mcast_no_peer = %u\n",
			   htt_stats_buf->ap_bcast_mcast_no_peer);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sta_delete_in_progress = %u\n",
			   htt_stats_buf->sta_delete_in_progress);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ibss_no_bss_peer = %u\n",
			   htt_stats_buf->ibss_no_bss_peer);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "invalid_vdev_type = %u\n",
			   htt_stats_buf->invalid_vdev_type);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "invalid_ast_peer_entry = %u\n",
			   htt_stats_buf->invalid_ast_peer_entry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_entry_invalid = %u\n",
			   htt_stats_buf->peer_entry_invalid);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ethertype_not_ip = %u\n",
			   htt_stats_buf->ethertype_not_ip);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eapol_lookup_failed = %u\n",
			   htt_stats_buf->eapol_lookup_failed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qpeer_not_allow_data = %u\n",
			   htt_stats_buf->qpeer_not_allow_data);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_tid_override = %u\n",
			   htt_stats_buf->fse_tid_override);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ipv6_jumbogram_zero_length = %u\n",
			   htt_stats_buf->ipv6_jumbogram_zero_length);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "qos_to_non_qos_in_prog = %u\n",
			   htt_stats_buf->qos_to_non_qos_in_prog);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ap_bcast_mcast_eapol = %u\n",
			   htt_stats_buf->ap_bcast_mcast_eapol);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "unicast_on_ap_bss_peer = %u\n",
			   htt_stats_buf->unicast_on_ap_bss_peer);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ap_vdev_invalid = %u\n",
			   htt_stats_buf->ap_vdev_invalid);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "incomplete_llc = %u\n",
			   htt_stats_buf->incomplete_llc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eapol_duplicate_m3 = %u\n",
			   htt_stats_buf->eapol_duplicate_m3);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eapol_duplicate_m4 = %u\n",
			   htt_stats_buf->eapol_duplicate_m4);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_classify_stats_tlv(const void *tag_buf,
				   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_classify_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_DE_CLASSIFY_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "arp_packets = %u\n",
			   htt_stats_buf->arp_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "igmp_packets = %u\n",
			   htt_stats_buf->igmp_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dhcp_packets = %u\n",
			   htt_stats_buf->dhcp_packets);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "host_inspected = %u\n",
			   htt_stats_buf->host_inspected);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_included = %u\n",
			   htt_stats_buf->htt_included);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_mcs = %u\n",
			   htt_stats_buf->htt_valid_mcs);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_nss = %u\n",
			   htt_stats_buf->htt_valid_nss);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_preamble_type = %u\n",
			   htt_stats_buf->htt_valid_preamble_type);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_chainmask = %u\n",
			   htt_stats_buf->htt_valid_chainmask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_guard_interval = %u\n",
			   htt_stats_buf->htt_valid_guard_interval);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_retries = %u\n",
			   htt_stats_buf->htt_valid_retries);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_bw_info = %u\n",
			   htt_stats_buf->htt_valid_bw_info);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_power = %u\n",
			   htt_stats_buf->htt_valid_power);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_key_flags = 0x%x\n",
			   htt_stats_buf->htt_valid_key_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_valid_no_encryption = %u\n",
			   htt_stats_buf->htt_valid_no_encryption);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_entry_count = %u\n",
			   htt_stats_buf->fse_entry_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_priority_be = %u\n",
			   htt_stats_buf->fse_priority_be);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_priority_high = %u\n",
			   htt_stats_buf->fse_priority_high);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_priority_low = %u\n",
			   htt_stats_buf->fse_priority_low);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_traffic_ptrn_be = %u\n",
			   htt_stats_buf->fse_traffic_ptrn_be);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_traffic_ptrn_over_sub = %u\n",
			   htt_stats_buf->fse_traffic_ptrn_over_sub);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_traffic_ptrn_bursty = %u\n",
			   htt_stats_buf->fse_traffic_ptrn_bursty);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_traffic_ptrn_interactive = %u\n",
			   htt_stats_buf->fse_traffic_ptrn_interactive);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_traffic_ptrn_periodic = %u\n",
			   htt_stats_buf->fse_traffic_ptrn_periodic);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_hwqueue_alloc = %u\n",
			   htt_stats_buf->fse_hwqueue_alloc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_hwqueue_created = %u\n",
			   htt_stats_buf->fse_hwqueue_created);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_hwqueue_send_to_host = %u\n",
			   htt_stats_buf->fse_hwqueue_send_to_host);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mcast_entry = %u\n",
			   htt_stats_buf->mcast_entry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "bcast_entry = %u\n",
			   htt_stats_buf->bcast_entry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_update_peer_cache = %u\n",
			   htt_stats_buf->htt_update_peer_cache);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "htt_learning_frame = %u\n",
			   htt_stats_buf->htt_learning_frame);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fse_invalid_peer = %u\n",
			   htt_stats_buf->fse_invalid_peer);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mec_notify = %u\n",
			   htt_stats_buf->mec_notify);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_classify_status_stats_tlv(const void *tag_buf,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_classify_status_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "eok = %u\n",
			   htt_stats_buf->eok);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "classify_done = %u\n",
			   htt_stats_buf->classify_done);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "lookup_failed = %u\n",
			   htt_stats_buf->lookup_failed);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "send_host_dhcp = %u\n",
			   htt_stats_buf->send_host_dhcp);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "send_host_mcast = %u\n",
			   htt_stats_buf->send_host_mcast);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "send_host_unknown_dest = %u\n",
			   htt_stats_buf->send_host_unknown_dest);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "send_host = %u\n",
			   htt_stats_buf->send_host);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "status_invalid = %u\n",
			   htt_stats_buf->status_invalid);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_enqueue_packets_stats_tlv(const void *tag_buf,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_enqueue_packets_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "enqueued_pkts = %u\n",
			htt_stats_buf->enqueued_pkts);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "to_tqm = %u\n",
			htt_stats_buf->to_tqm);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "to_tqm_bypass = %u\n",
			htt_stats_buf->to_tqm_bypass);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_enqueue_discard_stats_tlv(const void *tag_buf,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_enqueue_discard_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "discarded_pkts = %u\n",
			   htt_stats_buf->discarded_pkts);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_frames = %u\n",
			   htt_stats_buf->local_frames);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "is_ext_msdu = %u\n",
			   htt_stats_buf->is_ext_msdu);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_de_compl_stats_tlv(const void *tag_buf,
						   struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_compl_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_DE_COMPL_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tcl_dummy_frame = %u\n",
			   htt_stats_buf->tcl_dummy_frame);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_dummy_frame = %u\n",
			   htt_stats_buf->tqm_dummy_frame);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_notify_frame = %u\n",
			   htt_stats_buf->tqm_notify_frame);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw2wbm_enq = %u\n",
			   htt_stats_buf->fw2wbm_enq);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tqm_bypass_frame = %u\n",
			   htt_stats_buf->tqm_bypass_frame);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_fw2wbm_ring_full_hist_tlv(const void *tag_buf,
					  u16 tag_len,
					  struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_fw2wbm_ring_full_hist_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16  num_elements = tag_len >> 2;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_DE_FW2WBM_RING_FULL_HIST_TLV:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "fw2wbm_ring_full_hist = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fw2wbm_ring_full_hist, num_elements);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_de_cmn_stats_tlv(const void *tag_buf, struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_de_cmn_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_DE_CMN_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tcl2fw_entry_count = %u\n",
			   htt_stats_buf->tcl2fw_entry_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "not_to_fw = %u\n",
			   htt_stats_buf->not_to_fw);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "invalid_pdev_vdev_peer = %u\n",
			   htt_stats_buf->invalid_pdev_vdev_peer);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tcl_res_invalid_addrx = %u\n",
			   htt_stats_buf->tcl_res_invalid_addrx);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "wbm2fw_entry_count = %u\n",
			   htt_stats_buf->wbm2fw_entry_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "invalid_pdev = %u\n",
			   htt_stats_buf->invalid_pdev);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tcl_res_addrx_timeout = %u\n",
			   htt_stats_buf->tcl_res_addrx_timeout);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "invalid_vdev = %u\n",
			   htt_stats_buf->invalid_vdev);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "invalid_tcl_exp_frame_desc = %u\n",
			   htt_stats_buf->invalid_tcl_exp_frame_desc);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_ring_if_stats_tlv(const void *tag_buf,
					       struct debug_htt_stats_req *stats_req)
{
	const struct htt_ring_if_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RING_IF_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "base_addr = %u\n",
			   htt_stats_buf->base_addr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "elem_size = %u\n",
			   htt_stats_buf->elem_size);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_elems = %u\n",
			   htt_stats_buf->num_elems__prefetch_tail_idx & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "prefetch_tail_idx = %u\n",
			   (htt_stats_buf->num_elems__prefetch_tail_idx &
			   0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "head_idx = %u\n",
			   htt_stats_buf->head_idx__tail_idx & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tail_idx = %u\n",
			   (htt_stats_buf->head_idx__tail_idx & 0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "shadow_head_idx = %u\n",
			   htt_stats_buf->shadow_head_idx__shadow_tail_idx & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "shadow_tail_idx = %u\n",
			   (htt_stats_buf->shadow_head_idx__shadow_tail_idx &
			   0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_tail_incr = %u\n",
			   htt_stats_buf->num_tail_incr);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "lwm_thresh = %u\n",
			   htt_stats_buf->lwm_thresh__hwm_thresh & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwm_thresh = %u\n",
			   (htt_stats_buf->lwm_thresh__hwm_thresh & 0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "overrun_hit_count = %u\n",
			   htt_stats_buf->overrun_hit_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "underrun_hit_count = %u\n",
			   htt_stats_buf->underrun_hit_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "prod_blockwait_count = %u\n",
			   htt_stats_buf->prod_blockwait_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "cons_blockwait_count = %u\n",
			   htt_stats_buf->cons_blockwait_count);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "low_wm_hit_count = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->low_wm_hit_count, HTT_STATS_LOW_WM_BINS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nhigh_wm_hit_count = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->high_wm_hit_count, HTT_STATS_HIGH_WM_BINS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_ring_if_cmn_tlv(const void *tag_buf,
					     struct debug_htt_stats_req *stats_req)
{
	const struct htt_ring_if_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RING_IF_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_records = %u\n",
			   htt_stats_buf->num_records);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_sfm_client_user_tlv_v(const void *tag_buf,
						   u16 tag_len,
						   struct debug_htt_stats_req *stats_req)
{
	const struct htt_sfm_client_user_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = tag_len >> 2;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SFM_CLIENT_USER_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "dwords_used_by_user_n = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->dwords_used_by_user_n, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_sfm_client_tlv(const void *tag_buf,
					    struct debug_htt_stats_req *stats_req)
{
	const struct htt_sfm_client_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SFM_CLIENT_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "client_id = %u\n",
			   htt_stats_buf->client_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "buf_min = %u\n",
			   htt_stats_buf->buf_min);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "buf_max = %u\n",
			   htt_stats_buf->buf_max);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "buf_busy = %u\n",
			   htt_stats_buf->buf_busy);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "buf_alloc = %u\n",
			   htt_stats_buf->buf_alloc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "buf_avail = %u\n",
			   htt_stats_buf->buf_avail);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_users = %u\n",
			   htt_stats_buf->num_users);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_sfm_cmn_tlv(const void *tag_buf,
					 struct debug_htt_stats_req *stats_req)
{
	const struct htt_sfm_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SFM_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "buf_total = %u\n",
			   htt_stats_buf->buf_total);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mem_empty = %u\n",
			   htt_stats_buf->mem_empty);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "deallocate_bufs = %u\n",
			   htt_stats_buf->deallocate_bufs);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_records = %u\n",
			   htt_stats_buf->num_records);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_sring_stats_tlv(const void *tag_buf,
					     struct debug_htt_stats_req *stats_req)
{
	const struct htt_sring_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SRING_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__ring_id__arena__ep & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ring_id = %u\n",
			   (htt_stats_buf->mac_id__ring_id__arena__ep & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "arena = %u\n",
			   (htt_stats_buf->mac_id__ring_id__arena__ep & 0xFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ep = %u\n",
			   (htt_stats_buf->mac_id__ring_id__arena__ep & 0x1000000) >> 24);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "base_addr_lsb = 0x%x\n",
			   htt_stats_buf->base_addr_lsb);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "base_addr_msb = 0x%x\n",
			   htt_stats_buf->base_addr_msb);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ring_size = %u\n",
			   htt_stats_buf->ring_size);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "elem_size = %u\n",
			   htt_stats_buf->elem_size);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_avail_words = %u\n",
			   htt_stats_buf->num_avail_words__num_valid_words & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_valid_words = %u\n",
			   (htt_stats_buf->num_avail_words__num_valid_words &
			   0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "head_ptr = %u\n",
			   htt_stats_buf->head_ptr__tail_ptr & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tail_ptr = %u\n",
			   (htt_stats_buf->head_ptr__tail_ptr & 0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "consumer_empty = %u\n",
			   htt_stats_buf->consumer_empty__producer_full & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "producer_full = %u\n",
			   (htt_stats_buf->consumer_empty__producer_full &
			   0xFFFF0000) >> 16);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "prefetch_count = %u\n",
			   htt_stats_buf->prefetch_count__internal_tail_ptr & 0xFFFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "internal_tail_ptr = %u\n",
			   (htt_stats_buf->prefetch_count__internal_tail_ptr &
			   0xFFFF0000) >> 16);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_sring_cmn_tlv(const void *tag_buf,
					   struct debug_htt_stats_req *stats_req)
{
	const struct htt_sring_cmn_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_SRING_CMN_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_records = %u\n",
			   htt_stats_buf->num_records);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_tx_pdev_rate_stats_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TX_PDEV_RATE_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_ldpc = %u\n",
			   htt_stats_buf->tx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_mu_mimo_tx_ldpc = %u\n",
			   htt_stats_buf->ac_mu_mimo_tx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_mu_mimo_tx_ldpc = %u\n",
			   htt_stats_buf->ax_mu_mimo_tx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ofdma_tx_ldpc = %u\n",
			   htt_stats_buf->ofdma_tx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts_cnt = %u\n",
			   htt_stats_buf->rts_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts_success = %u\n",
			   htt_stats_buf->rts_success);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ack_rssi = %u\n",
			   htt_stats_buf->ack_rssi);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_11ax_su_ext = %u\n",
			   htt_stats_buf->tx_11ax_su_ext);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Legacy CCK Rates: 1 Mbps: %u, 2 Mbps: %u, 5.5 Mbps: %u, 11 Mbps: %u\n",
			   htt_stats_buf->tx_legacy_cck_rate[0],
			   htt_stats_buf->tx_legacy_cck_rate[1],
			   htt_stats_buf->tx_legacy_cck_rate[2],
			   htt_stats_buf->tx_legacy_cck_rate[3]);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Legacy OFDM Rates: 6 Mbps: %u, 9 Mbps: %u, 12 Mbps: %u, 18 Mbps: %u\n"
			   "                   24 Mbps: %u, 36 Mbps: %u, 48 Mbps: %u, 54 Mbps: %u\n",
			   htt_stats_buf->tx_legacy_ofdm_rate[0],
			   htt_stats_buf->tx_legacy_ofdm_rate[1],
			   htt_stats_buf->tx_legacy_ofdm_rate[2],
			   htt_stats_buf->tx_legacy_ofdm_rate[3],
			   htt_stats_buf->tx_legacy_ofdm_rate[4],
			   htt_stats_buf->tx_legacy_ofdm_rate[5],
			   htt_stats_buf->tx_legacy_ofdm_rate[6],
			   htt_stats_buf->tx_legacy_ofdm_rate[7]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
	ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->tx_mcs_ext,
		     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_tx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
	ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->ax_mu_mimo_tx_mcs_ext,
		     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_tx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
	ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->ax_mu_mimo_tx_mcs_ext,
		     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nofdma_tx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_mcs,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
	ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->ofdma_tx_mcs_ext,
		     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss,
		     HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_tx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_nss,
		     HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_tx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_nss,
		     HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nofdma_tx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_nss,
		     HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw,
		     HTT_TX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_tx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_bw,
		     HTT_TX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_tx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_bw,
		     HTT_TX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nofdma_tx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_bw,
		     HTT_TX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_stbc = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
	ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->tx_stbc_ext,
		     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
		     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_pream = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream,
		     HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nHE LTF: 1x: %u, 2x: %u, 4x: %u",
			   htt_stats_buf->tx_he_ltf[1],
			   htt_stats_buf->tx_he_ltf[2],
			   htt_stats_buf->tx_he_ltf[3]);

	/* SU GI Stats */
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_gi[%u] = ", j);
		len += HTT_DBG_OUT(buf + len, buf_len - len, " -2:%u,-1:%u,",
				  htt_stats_buf->tx_gi_ext_2[j][0],
				  htt_stats_buf->tx_gi_ext_2[j][1]);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_gi[j],
			     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
		len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
		ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->tx_gi_ext[j],
			     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
			     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	/* AC MU-MIMO GI Stats */
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nac_mu_mimo_tx_gi[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_gi[j],
			     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	/* AX MU-MIMO GI Stats */
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nax_mu_mimo_tx_gi[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_gi[j],
		 	     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
		len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
		ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->ax_mu_mimo_tx_gi_ext[j],
			     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
			     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	/* DL OFDMA GI Stats */
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nofdma_tx_gi[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_gi[j],
			     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
		len += HTT_DBG_OUT(buf + len, buf_len - len, " ");
		ARRAY_TO_BUF_EXT(buf, len, htt_stats_buf->ofdma_tx_gi_ext[j],
			     HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
			     HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_dcm = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm, HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n11ax_trigger_type = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->trigger_type_11ax,
		     HTT_TX_PDEV_STATS_NUM_11AX_TRIGGER_TYPES);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_rx_pdev_rate_stats_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "nsts = %u\n",
			   htt_stats_buf->nsts);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ldpc = %u\n",
			   htt_stats_buf->rx_ldpc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rts_cnt = %u\n",
			   htt_stats_buf->rts_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_mgmt = %u\n",
			   htt_stats_buf->rssi_mgmt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_data = %u\n",
			   htt_stats_buf->rssi_data);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_comb = %u\n",
			   htt_stats_buf->rssi_comb);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_in_dbm = %d\n",
			   htt_stats_buf->rssi_in_dbm);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs, HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss, HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_dcm = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm, HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_stbc = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc, HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw, HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_evm_nss_count = %u",
			htt_stats_buf->nss_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_evm_pilot_count = %u",
			htt_stats_buf->pilot_count);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\npilot_evm_dB[%u] = ",j);
		CHAIN_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pilot_evm_db[j],
			     HTT_RX_PDEV_STATS_RXEVM_MAX_PILOTS_PER_NSS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\npilot_evm_dB_mean = ");
	CHAIN_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pilot_evm_db_mean,
		     HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrssi_chain[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain[j],
			     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);
	}

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_gi[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi[j],
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_pream = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream, HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_su_ext = %u",
			   htt_stats_buf->rx_11ax_su_ext);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ac_mumimo = %u",
			   htt_stats_buf->rx_11ac_mumimo);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_mumimo = %u",
			   htt_stats_buf->rx_11ax_mumimo);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_ofdma = %u",
			   htt_stats_buf->rx_11ax_ofdma);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntxbf = %u",
			   htt_stats_buf->txbf);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_su_ndpa = %u",
			   htt_stats_buf->rx_su_ndpa);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_su_txbf_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_su_txbf_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_mu_ndpa = %u",
			   htt_stats_buf->rx_mu_ndpa);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_mu_txbf_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_mu_txbf_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_br_poll = %u",
			   htt_stats_buf->rx_br_poll);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_legacy_cck_rate = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_legacy_cck_rate,
                     HTT_RX_PDEV_STATS_NUM_LEGACY_CCK_STATS);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_legacy_ofdm_rate = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_legacy_ofdm_rate,
                     HTT_RX_PDEV_STATS_NUM_LEGACY_OFDM_STATS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_active_dur_us_low = %u",
			   htt_stats_buf->rx_active_dur_us_low);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_active_dur_us_high = %u",
			htt_stats_buf->rx_active_dur_us_high);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_ul_ofdma = %u",
			htt_stats_buf->rx_11ax_ul_ofdma);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_gi[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_gi[j],
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_nss,
		     HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_bw =  ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_bw,
		     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_stbc = %u",
		           htt_stats_buf->ul_ofdma_rx_stbc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_ldpc = %u",
		 	   htt_stats_buf->ul_ofdma_rx_ldpc);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_non_data_ppdu = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_non_data_ppdu,
                     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_data_ppdu = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_data_ppdu,
                     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_mpdu_ok = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_mpdu_ok,
                     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_mpdu_fail = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_mpdu_fail,
                     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulmumimo_non_data_ppdu = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_non_data_ppdu,
		     HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulmumimo_data_ppdu = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_data_ppdu,
		     HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulmumimo_mpdu_ok = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_mpdu_ok,
		     HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulmumimo_mpdu_fail = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_mpdu_fail,
		     HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_ul_fd_rssi: nss[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ul_fd_rssi[j],
			     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nper_chain_rssi_pkt_type = %#x",
			   htt_stats_buf->per_chain_rssi_pkt_type);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_per_chain_rssi_in_dbm[%u] = ", j);
		CHAIN_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_per_chain_rssi_in_dbm[j],
			     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_dl_ofdma_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_dl_ofdma_ru = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_ru,
		     HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_non_data_nusers = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_non_data_nusers,
		     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_ulofdma_data_nusers = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_data_nusers,
		     HTT_RX_PDEV_MAX_OFDMA_NUM_USER);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_rx_soc_fw_stats_tlv(const void *tag_buf,
						 struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_soc_fw_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_SOC_FW_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_reo_ring_data_msdu = %u\n",
			   htt_stats_buf->fw_reo_ring_data_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_to_host_data_msdu_bcmc = %u\n",
			   htt_stats_buf->fw_to_host_data_msdu_bcmc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_to_host_data_msdu_uc = %u\n",
			   htt_stats_buf->fw_to_host_data_msdu_uc);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "ofld_remote_data_buf_recycle_cnt = %u\n",
			   htt_stats_buf->ofld_remote_data_buf_recycle_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "ofld_remote_free_buf_indication_cnt = %u\n",
			   htt_stats_buf->ofld_remote_free_buf_indication_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "ofld_buf_to_host_data_msdu_uc = %u\n",
			   htt_stats_buf->ofld_buf_to_host_data_msdu_uc);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "reo_fw_ring_to_host_data_msdu_uc = %u\n",
			   htt_stats_buf->reo_fw_ring_to_host_data_msdu_uc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "wbm_sw_ring_reap = %u\n",
			   htt_stats_buf->wbm_sw_ring_reap);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "wbm_forward_to_host_cnt = %u\n",
			   htt_stats_buf->wbm_forward_to_host_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "wbm_target_recycle_cnt = %u\n",
			   htt_stats_buf->wbm_target_recycle_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "target_refill_ring_recycle_cnt = %u\n",
			   htt_stats_buf->target_refill_ring_recycle_cnt);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_soc_fw_refill_ring_empty_tlv_v(const void *tag_buf,
					    u16 tag_len,
					    struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_soc_fw_refill_ring_empty_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_REFILL_MAX_RING);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_SOC_FW_REFILL_RING_EMPTY_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "refill_ring_empty_cnt = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->refill_ring_empty_cnt, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v(const void *tag_buf,
						    u16 tag_len,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v *htt_stats_buf =
		tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_RXDMA_MAX_ERR_CODE);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_SOC_FW_REFILL_RING_NUM_RXDMA_ERR_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "rxdma_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->rxdma_err, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_soc_fw_refill_ring_num_reo_err_tlv_v(const void *tag_buf,
						  u16 tag_len,
						  struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_soc_fw_refill_ring_num_reo_err_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_REO_MAX_ERR_CODE);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_SOC_FW_REFILL_RING_NUM_REO_ERR_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "reo_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->reo_err, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_reo_debug_stats_tlv_v(const void *tag_buf,
				   struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_reo_resource_stats_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_REO_RESOURCE_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sample_id = %u\n",
			   htt_stats_buf->sample_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "total_max = %u\n",
			   htt_stats_buf->total_max);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "total_avg = %u\n",
			   htt_stats_buf->total_avg);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "total_sample = %u\n",
			   htt_stats_buf->total_sample);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "non_zeros_avg = %u\n",
			   htt_stats_buf->non_zeros_avg);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "non_zeros_sample = %u\n",
			   htt_stats_buf->non_zeros_sample);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_non_zeros_max = %u\n",
			   htt_stats_buf->last_non_zeros_max);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_non_zeros_min %u\n",
			   htt_stats_buf->last_non_zeros_min);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_non_zeros_avg %u\n",
			   htt_stats_buf->last_non_zeros_avg);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_non_zeros_sample %u\n",
			   htt_stats_buf->last_non_zeros_sample);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_soc_fw_refill_ring_num_refill_tlv_v(const void *tag_buf,
						 u16 tag_len,
						 struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_soc_fw_refill_ring_num_refill_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_REFILL_MAX_RING);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_SOC_FW_REFILL_RING_NUM_REFILL_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "refill_ring_num_refill = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->refill_ring_num_refill, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_rx_pdev_fw_stats_tlv(const void *tag_buf,
						  struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_pdev_fw_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ppdu_recvd = %u\n",
			   htt_stats_buf->ppdu_recvd);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_cnt_fcs_ok = %u\n",
			   htt_stats_buf->mpdu_cnt_fcs_ok);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mpdu_cnt_fcs_err = %u\n",
			   htt_stats_buf->mpdu_cnt_fcs_err);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tcp_msdu_cnt = %u\n",
			   htt_stats_buf->tcp_msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tcp_ack_msdu_cnt = %u\n",
			   htt_stats_buf->tcp_ack_msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "udp_msdu_cnt = %u\n",
			   htt_stats_buf->udp_msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "other_msdu_cnt = %u\n",
			   htt_stats_buf->other_msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_mpdu_ind = %u\n",
			   htt_stats_buf->fw_ring_mpdu_ind);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_mgmt_subtype = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_mgmt_subtype,
		     HTT_STATS_SUBTYPE_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_ctrl_subtype = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_ctrl_subtype,
		     HTT_STATS_SUBTYPE_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_mcast_data_msdu = %u\n",
			   htt_stats_buf->fw_ring_mcast_data_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_bcast_data_msdu = %u\n",
			   htt_stats_buf->fw_ring_bcast_data_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_ucast_data_msdu = %u\n",
			   htt_stats_buf->fw_ring_ucast_data_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_null_data_msdu = %u\n",
			   htt_stats_buf->fw_ring_null_data_msdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_mpdu_drop = %u\n",
			   htt_stats_buf->fw_ring_mpdu_drop);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ofld_local_data_ind_cnt = %u\n",
			   htt_stats_buf->ofld_local_data_ind_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "ofld_local_data_buf_recycle_cnt = %u\n",
			   htt_stats_buf->ofld_local_data_buf_recycle_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "drx_local_data_ind_cnt = %u\n",
			   htt_stats_buf->drx_local_data_ind_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "drx_local_data_buf_recycle_cnt = %u\n",
			   htt_stats_buf->drx_local_data_buf_recycle_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_nondata_ind_cnt = %u\n",
			   htt_stats_buf->local_nondata_ind_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "local_nondata_buf_recycle_cnt = %u\n",
			   htt_stats_buf->local_nondata_buf_recycle_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_status_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->fw_status_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_status_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->fw_status_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_pkt_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->fw_pkt_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_pkt_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->fw_pkt_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_link_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->fw_link_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_link_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->fw_link_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "host_pkt_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->host_pkt_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "host_pkt_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->host_pkt_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_pkt_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->mon_pkt_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_pkt_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->mon_pkt_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "mon_status_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->mon_status_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_status_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->mon_status_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_desc_buf_ring_refill_cnt = %u\n",
			   htt_stats_buf->mon_desc_buf_ring_refill_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_desc_buf_ring_empty_cnt = %u\n",
			   htt_stats_buf->mon_desc_buf_ring_empty_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_dest_ring_update_cnt = %u\n",
			   htt_stats_buf->mon_dest_ring_update_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mon_dest_ring_full_cnt = %u\n",
			   htt_stats_buf->mon_dest_ring_full_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_suspend_cnt = %u\n",
			   htt_stats_buf->rx_suspend_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_suspend_fail_cnt = %u\n",
			   htt_stats_buf->rx_suspend_fail_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_resume_cnt = %u\n",
			   htt_stats_buf->rx_resume_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_resume_fail_cnt = %u\n",
			   htt_stats_buf->rx_resume_fail_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ring_switch_cnt = %u\n",
			   htt_stats_buf->rx_ring_switch_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ring_restore_cnt = %u\n",
			   htt_stats_buf->rx_ring_restore_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_flush_cnt = %u\n",
			   htt_stats_buf->rx_flush_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_recovery_reset_cnt = %u\n",
			   htt_stats_buf->rx_recovery_reset_cnt);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_pdev_fw_ring_mpdu_err_tlv_v(const void *tag_buf,
					 struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_pdev_fw_ring_mpdu_err_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_PDEV_FW_RING_MPDU_ERR_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_ring_mpdu_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_mpdu_err,
		     HTT_RX_STATS_RXDMA_MAX_ERR);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_pdev_fw_mpdu_drop_tlv_v(const void *tag_buf,
				     u16 tag_len,
				     struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_pdev_fw_mpdu_drop_tlv_v *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_FW_DROP_REASON_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_PDEV_FW_MPDU_DROP_TLV_V:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_mpdu_drop = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_mpdu_drop, num_elems);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_rx_pdev_fw_stats_phy_err_tlv(const void *tag_buf,
				       struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_pdev_fw_stats_phy_err_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_PHY_ERR_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id__word = %u\n",
			   htt_stats_buf->mac_id__word);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "total_phy_err_nct = %u\n",
			   htt_stats_buf->total_phy_err_cnt);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "phy_errs = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_err, HTT_STATS_PHY_ERR_MAX);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_pdev_cca_stats_hist_tlv(const void *tag_buf,
				  struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_cca_stats_hist_v1_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PDEV_CCA_STATS_HIST_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "chan_num = %u\n",
			   htt_stats_buf->chan_num);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_records = %u\n",
			   htt_stats_buf->num_records);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "valid_cca_counters_bitmap = 0x%x\n",
			   htt_stats_buf->valid_cca_counters_bitmap);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "collection_interval = %u\n",
			   htt_stats_buf->collection_interval);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_PDEV_STATS_CCA_COUNTERS_TLV:(in usec)\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "|  tx_frame|   rx_frame|   rx_clear| my_rx_frame|        cnt| med_rx_idle| med_tx_idle_global|   cca_obss|\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_pdev_stats_cca_counters_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_stats_cca_counters_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "|%10u| %10u| %10u| %11u| %10u| %11u| %18u| %10u|\n",
			   htt_stats_buf->tx_frame_usec,
			   htt_stats_buf->rx_frame_usec,
			   htt_stats_buf->rx_clear_usec,
			   htt_stats_buf->my_rx_frame_usec,
			   htt_stats_buf->usec_cnt,
			   htt_stats_buf->med_rx_idle_usec,
			   htt_stats_buf->med_tx_idle_global_usec,
			   htt_stats_buf->cca_obss_usec);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_hw_stats_whal_tx_tlv(const void *tag_buf,
						  struct debug_htt_stats_req *stats_req)
{
	const struct htt_hw_stats_whal_tx_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_HW_STATS_WHAL_TX_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_unpause_ppdu_id = %u\n",
			   htt_stats_buf->last_unpause_ppdu_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_unpause_wait_tqm_write = %u\n",
			   htt_stats_buf->hwsch_unpause_wait_tqm_write);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_dummy_tlv_skipped = %u\n",
			   htt_stats_buf->hwsch_dummy_tlv_skipped);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "hwsch_misaligned_offset_received = %u\n",
			   htt_stats_buf->hwsch_misaligned_offset_received);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_reset_count = %u\n",
			   htt_stats_buf->hwsch_reset_count);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_dev_reset_war = %u\n",
			   htt_stats_buf->hwsch_dev_reset_war);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_delayed_pause = %u\n",
			   htt_stats_buf->hwsch_delayed_pause);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "hwsch_long_delayed_pause = %u\n",
			   htt_stats_buf->hwsch_long_delayed_pause);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sch_rx_ppdu_no_response = %u\n",
			   htt_stats_buf->sch_rx_ppdu_no_response);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sch_selfgen_response = %u\n",
			   htt_stats_buf->sch_selfgen_response);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sch_rx_sifs_resp_trigger= %u\n",
			   htt_stats_buf->sch_rx_sifs_resp_trigger);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_pdev_stats_twt_sessions_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_stats_twt_sessions_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PDEV_STATS_TWT_SESSIONS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pdev_id = %u\n",
			   htt_stats_buf->pdev_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_sessions = %u\n",
			   htt_stats_buf->num_sessions);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_pdev_stats_twt_session_tlv(const void *tag_buf,
				     struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_stats_twt_session_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PDEV_STATS_TWT_SESSION_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "vdev_id = %u\n",
			   htt_stats_buf->vdev_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "peer_mac = %02x:%02x:%02x:%02x:%02x:%02x\n",
			   htt_stats_buf->peer_mac.mac_addr_l32 & 0xFF,
			   (htt_stats_buf->peer_mac.mac_addr_l32 & 0xFF00) >> 8,
			   (htt_stats_buf->peer_mac.mac_addr_l32 & 0xFF0000) >> 16,
			   (htt_stats_buf->peer_mac.mac_addr_l32 & 0xFF000000) >> 24,
			   (htt_stats_buf->peer_mac.mac_addr_h16 & 0xFF),
			   (htt_stats_buf->peer_mac.mac_addr_h16 & 0xFF00) >> 8);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "flow_id_flags = %u\n",
			   htt_stats_buf->flow_id_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "dialog_id = %u\n",
			   htt_stats_buf->dialog_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "wake_dura_us = %u\n",
			   htt_stats_buf->wake_dura_us);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "wake_intvl_us = %u\n",
			   htt_stats_buf->wake_intvl_us);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "sp_offset_us = %u\n",
			   htt_stats_buf->sp_offset_us);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_pdev_obss_pd_stats_tlv_v(const void *tag_buf,
				   struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_obss_pd_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_STATS_TLV:\n");
	/*
	 * Successful/Failure OBSS Transmission stats are omitted out as they
	 * are not supported in the current chipsets.
	*/
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_spatial_reuse_tx = %u\n",
			   htt_stats_buf->num_sr_tx_transmissions);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_spatial_reuse_opportunities = %u\n",
			   htt_stats_buf->num_spatial_reuse_opportunities);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_non_srg_opportunities = %u\n",
			   htt_stats_buf->num_non_srg_opportunities);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_non_srg_ppdu_tried = %u\n",
			   htt_stats_buf->num_non_srg_ppdu_tried);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_non_srg_ppdu_success = %u\n",
			   htt_stats_buf->num_non_srg_ppdu_success);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_psr_opportunities = %u\n",
			   htt_stats_buf->num_psr_opportunities);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_psr_ppdu_tried = %u\n",
			   htt_stats_buf->num_psr_ppdu_tried);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_psr_ppdu_success = %u\n",
			   htt_stats_buf->num_psr_ppdu_success);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_backpressure_stats_tlv_v(const u32 *tag_buf,
						      u8 *data)
{
	struct debug_htt_stats_req *stats_req =
			(struct debug_htt_stats_req *)data;
	struct htt_ring_backpressure_stats_tlv *htt_stats_buf =
			(struct htt_ring_backpressure_stats_tlv *)tag_buf;

	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "pdev_id = %u\n",
			   htt_stats_buf->pdev_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Head index = %u\n",
			   htt_stats_buf->current_head_idx);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Tail index = %u\n",
			   htt_stats_buf->current_tail_idx);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Num Backpressure Msgs Sent = %u\n",
			   htt_stats_buf->num_htt_msgs_sent);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Current Backpressure Time in Milliseconds = %u\n",
			   htt_stats_buf->backpressure_time_ms);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "Ring Backpressure Histogram\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "100ms to 200ms = %u, 200ms to 300ms = %u, 300ms to 400ms = %u\n",
			   htt_stats_buf->backpressure_hist[0],
			   htt_stats_buf->backpressure_hist[1],
			   htt_stats_buf->backpressure_hist[2]);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "400ms to 500 ms = %u, Above 500ms = %u\n",
			   htt_stats_buf->backpressure_hist[3],
			   htt_stats_buf->backpressure_hist[4]);

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	} else {
		buf[len] = 0;
		stats_req->buf_len = len;
	}
}

static inline void htt_print_latency_prof_stats_tlv_v(const u32 *tag_buf, u8 *data)
{
	struct debug_htt_stats_req *stats_req =
			(struct debug_htt_stats_req *)data;
	struct htt_latency_prof_stats_tlv *htt_stats_buf =
		(struct htt_latency_prof_stats_tlv *) tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	if (htt_stats_buf->print_header == 1) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "HTT_STATS_LATENCY_PROF_TLV:\n");
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "|  prof_name\t| cnt\t| min\t| max\t| last\t| tot\t|"
				   " avg \t| hist_intvl\t| hist\t|\n");
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "|%s| %8u| %8u| %8u| %8u| %8u| %8u| %8u| %4u:%4u:%4u|\n",
			   htt_stats_buf->latency_prof_name, htt_stats_buf->cnt,
			   htt_stats_buf->min, htt_stats_buf->max, htt_stats_buf->last,
			   htt_stats_buf->tot, htt_stats_buf->avg,
			   htt_stats_buf->hist_intvl, htt_stats_buf->hist[0],
			   htt_stats_buf->hist[1], htt_stats_buf->hist[2]);
	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_latency_prof_ctx_tlv(const u32 *tag_buf,
						 struct debug_htt_stats_req *stats_req)
{
	struct htt_latency_prof_ctx_tlv *htt_stats_buf =
		(struct htt_latency_prof_ctx_tlv *) tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_STATS_LATENCY_CTX_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,"duration= %u\n",
			   htt_stats_buf->duration);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tx_msdu_cnt = %u\n", htt_stats_buf->tx_msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "tx_mpdu_cnt = %u\n", htt_stats_buf->tx_mpdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_msdu_cnt = %u\n", htt_stats_buf->rx_msdu_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_mpdu_cnt = %u\n", htt_stats_buf->rx_mpdu_cnt);

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_latency_prof_cnt(const u32 *tag_buf,
					      struct debug_htt_stats_req *stats_req)
{
	struct htt_latency_prof_cnt_tlv *htt_stats_buf =
		(struct htt_latency_prof_cnt_tlv *)tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "prof_enable_cnt = %u\n",
			   htt_stats_buf->prof_enable_cnt);

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_ul_mumimo_trig_stats(const u32 *tag_buf,
						  struct debug_htt_stats_req *stats_req)
{
	struct htt_rx_pdev_ul_mumimo_trig_stats_tlv *htt_ul_mumimo_trig_stats_buf =
	(struct htt_rx_pdev_ul_mumimo_trig_stats_tlv *)tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_PDEV_UL_MUMIMO_TRIG_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_ul_mumimo_trig_stats_buf->mac_id__word & 0xFF);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_11ax_ul_mumimo = %u\n",
			   htt_ul_mumimo_trig_stats_buf->rx_11ax_ul_mumimo);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "ul_mumimo_rx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
	len += HTT_DBG_OUT(buf + len, buf_len - len, ", ");
	ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_mcs_ext,
		     HTT_RX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_mumimo_rx_gi[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_gi[j],
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
		len += HTT_DBG_OUT(buf + len, buf_len - len, ", ");
		ARRAY_TO_BUF_EXT(buf, len, htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_gi_ext[j],
			     HTT_RX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS,
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_mumimo_rx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_nss,
		     HTT_RX_PDEV_STATS_ULMUMIMO_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_mumimo_rx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_bw,
		     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_mumimo_rx_stbc = %u",
			   htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_stbc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_mumimo_rx_ldpc = %u",
			   htt_ul_mumimo_trig_stats_buf->ul_mumimo_rx_ldpc);

	for (j = 0; j < HTT_RX_PDEV_STATS_ULMUMIMO_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_ul_mumimo_rssi_in_dbm: chain[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->rx_ul_mumimo_chain_rssi_in_dbm[j],
			     HTT_RX_PDEV_STATS_TOTAL_BW_COUNTERS);
	}

	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_UL_MUMIMO_USER_STATS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_ul_mumimo_target_rssi: user[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->rx_ul_mumimo_target_rssi[j],
			     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);
	}

	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_UL_MUMIMO_USER_STATS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_ul_mumimo_fd_rssi: user[%u] =  ", j);
		ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->rx_ul_mumimo_fd_rssi[j],
			     HTT_RX_PDEV_STATS_ULMUMIMO_NUM_SPATIAL_STREAMS);
	}

	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_UL_MUMIMO_USER_STATS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "\nrx_ulmumimo_pilot_evm_dB_mean: user [%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_ul_mumimo_trig_stats_buf->rx_ulmumimo_pilot_evm_dB_mean[j],
			     HTT_RX_PDEV_STATS_ULMUMIMO_NUM_SPATIAL_STREAMS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_ul_mimo_user_stats(const u32 *tag_buf,
						struct debug_htt_stats_req *stats_req)
{
	struct htt_rx_pdev_ul_mimo_user_stats_tlv *htt_ul_user_stats_buf =
		(struct htt_rx_pdev_ul_mimo_user_stats_tlv *)tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	if (htt_ul_user_stats_buf->user_index > HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER) {
		if (htt_ul_user_stats_buf->user_index == 0) {
			len += HTT_DBG_OUT(buf + len, buf_len - len,
					   "HTT_STATS_RX_PDEV_UL_MIMO_USER_STATS_TLV:\n");
		}

		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "rx_ulmumimo_non_data_ppdu_%u = %u\n",
				   htt_ul_user_stats_buf->user_index,
				   htt_ul_user_stats_buf->rx_ulmumimo_non_data_ppdu);

		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "rx_ulmumimo_data_ppdu_%u = %u\n",
				   htt_ul_user_stats_buf->user_index,
				   htt_ul_user_stats_buf->rx_ulmumimo_data_ppdu);

		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "rx_ulmumimo_mpdu_ok_%u = %u\n",
				   htt_ul_user_stats_buf->user_index,
				   htt_ul_user_stats_buf->rx_ulmumimo_mpdu_ok);

		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "rx_ulmumimo_mpdu_fail_%u = %u\n",
				   htt_ul_user_stats_buf->user_index,
				   htt_ul_user_stats_buf->rx_ulmumimo_mpdu_fail);
	}

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_ul_ofdma_user_stats(const u32 *tag_buf,
						 struct debug_htt_stats_req *stats_req)
{
	struct htt_rx_pdev_ul_ofdma_user_stats_tlv *htt_ul_user_stats_buf =
		(struct htt_rx_pdev_ul_ofdma_user_stats_tlv *)tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	if (htt_ul_user_stats_buf->user_index == 0) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "HTT_RX_PDEV_UL_OFDMA_USER_STAS_TLV:\n");
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_ulofdma_non_data_ppdu_%u = %u\n",
			   htt_ul_user_stats_buf->user_index,
			   htt_ul_user_stats_buf->rx_ulofdma_non_data_ppdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_ulofdma_data_ppdu_%u = %u\n",
			   htt_ul_user_stats_buf->user_index,
			   htt_ul_user_stats_buf->rx_ulofdma_data_ppdu);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_ulofdma_mpdu_ok_%u = %u\n",
			   htt_ul_user_stats_buf->user_index,
			   htt_ul_user_stats_buf->rx_ulofdma_mpdu_ok);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_ulofdma_mpdu_fail_%u = %u\n",
			   htt_ul_user_stats_buf->user_index,
			   htt_ul_user_stats_buf->rx_ulofdma_mpdu_fail);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_ulofdma_non_data_nusers_%u = %u\n",
			   htt_ul_user_stats_buf->user_index,
			   htt_ul_user_stats_buf->rx_ulofdma_non_data_nusers);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "rx_ulofdma_data_nusers_%u = %u\n",
			   htt_ul_user_stats_buf->user_index,
			   htt_ul_user_stats_buf->rx_ulofdma_data_nusers);

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

/*
 * htt_print_rx_pdev_ul_ofdma_stats_tlv: display htt_rx_pdev_ul_ofdma_stats_tlv
 * @tag_buf: buffer containing the tlv htt_rx_pdev_ul_ofdma_stats_tlv
 *
 * return:void
 */
static inline void htt_print_ul_ofdma_trigger_stats(const u32 *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{

	struct htt_rx_pdev_ul_trigger_stats_tlv *htt_trigger_stats_buf =
		(struct htt_rx_pdev_ul_trigger_stats_tlv *)tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_RX_PDEV_UL_TRIGGER_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			   htt_trigger_stats_buf->mac_id__word & 0xFF);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_11ax_ul_ofdma =%u\n",
			   htt_trigger_stats_buf->rx_11ax_ul_ofdma);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "ul_ofdma_rx_mcs = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->ul_ofdma_rx_mcs,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_gi[%u] = ", j);
		ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->ul_ofdma_rx_gi[j],
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_nss = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->ul_ofdma_rx_nss,
		     HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_bw = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->ul_ofdma_rx_bw,
		     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_REDUCED_CHAN_TYPES; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, j == 0 ?
				   "\nhalf_ul_ofdma_rx_bw = " : "\nquarter_ul_ofdma_rx_bw = ");
		ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->reduced_ul_ofdma_rx_bw[j],
			     HTT_RX_PDEV_STATS_NUM_BW_COUNTERS);
	}
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_stbc = %u",
			   htt_trigger_stats_buf->ul_ofdma_rx_stbc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_ldpc = %u",
			   htt_trigger_stats_buf->ul_ofdma_rx_ldpc);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "\nrx_ulofdma_non_data_ru_size_ppdu = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->rx_ulofdma_data_ru_size_ppdu,
		     HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "\nrx_ulofdma_data_ru_size_ppdu = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->rx_ulofdma_non_data_ru_size_ppdu,
		     HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_rssi_track_sta_aid = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->uplink_sta_aid,
		     HTT_RX_UL_MAX_UPLINK_RSSI_TRACK);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_sta_target_rssi = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->uplink_sta_target_rssi,
		     HTT_RX_UL_MAX_UPLINK_RSSI_TRACK);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_sta_fd_rssi = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->uplink_sta_fd_rssi,
		     HTT_RX_UL_MAX_UPLINK_RSSI_TRACK);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_sta_power_headroom = ");
	ARRAY_TO_BUF(buf, len, htt_trigger_stats_buf->uplink_sta_power_headroom,
		     HTT_RX_UL_MAX_UPLINK_RSSI_TRACK);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_rx_fse_stats_tlv(const u32 *tag_buf,
					      struct debug_htt_stats_req *stats_req)
{
	struct htt_rx_fse_stats_tlv *htt_stats_buf =
		(struct htt_rx_fse_stats_tlv *)tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_STATS_RX_FSE_STATS_TLV: \n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "=== Software RX FSE STATS ===\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Enable count  = %u\n", htt_stats_buf->fse_enable_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Disable count = %u\n", htt_stats_buf->fse_disable_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Cache Invalidate Entry Count   = %u\n",
			   htt_stats_buf->fse_cache_invalidate_entry_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Full Cache Invalidate Count    = %u\n",
			   htt_stats_buf->fse_full_cache_invalidate_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=== Hardware RX FSE STATS ===\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Cache hits Count = %u\n",
			   htt_stats_buf->fse_num_cache_hits_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Cache No. of searches = %u\n",
			   htt_stats_buf->fse_num_searches_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Cache occupancy Peak Count: \n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   " [0] = %u [1-16] = %u [17-32] = %u "
			   "[33-48] = %u [49-64] = %u [65-80] = %u "
			   "[81-96] = %u [97-112] = %u [113-127] = %u "
			   "[128] = %u\n",
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[0],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[1],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[2],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[3],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[4],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[5],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[6],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[7],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[8],
			   htt_stats_buf->fse_cache_occupancy_peak_cnt[9]);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Cache occupancy Current Count: \n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   " [0] = %u [1-16] = %u [17-32] = %u "
			   "[33-48] = %u [49-64] = %u [65-80] = %u "
			   "[81-96] = %u [97-112] = %u [113-127] = %u "
			   "[128] = %u\n",
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[0],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[1],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[2],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[3],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[4],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[5],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[6],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[7],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[8],
			   htt_stats_buf->fse_cache_occupancy_curr_cnt[9]);
	len += HTT_DBG_OUT(buf + len, buf_len - len,"Cache search Square Count: \n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   " [0] = %u [1-50] = %u [51-100] = %u "
			   "[101-200] = %u [201-255] = %u [256] = %u \n",
			   htt_stats_buf->fse_search_stat_square_cnt[0],
			   htt_stats_buf->fse_search_stat_square_cnt[1],
			   htt_stats_buf->fse_search_stat_square_cnt[2],
			   htt_stats_buf->fse_search_stat_square_cnt[3],
			   htt_stats_buf->fse_search_stat_square_cnt[4],
			   htt_stats_buf->fse_search_stat_square_cnt[5]);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Cache search Peak Pending Count:  \n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   " [0] = %u [1-2] = %u [3-4] = %u "
			   "[Greater/Equal to 5] = %u \n",
			   htt_stats_buf->fse_search_stat_peak_cnt[0],
			   htt_stats_buf->fse_search_stat_peak_cnt[1],
			   htt_stats_buf->fse_search_stat_peak_cnt[2],
			   htt_stats_buf->fse_search_stat_peak_cnt[3]);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Cache search Number of Pending Count: \n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "[0] = %u [1-2] = %u [3-4] = %u "
			   "[Greater/Equal to 5] = %u \n",
			   htt_stats_buf->fse_search_stat_search_pending_cnt[0],
			   htt_stats_buf->fse_search_stat_search_pending_cnt[1],
			   htt_stats_buf->fse_search_stat_search_pending_cnt[2],
			   htt_stats_buf->fse_search_stat_search_pending_cnt[3]);

	if (len >= buf_len) {
		buf[buf_len - 1] = 0;
		stats_req->buf_len = buf_len - 1;
	}
	else {
		buf[len] = 0;
		stats_req->buf_len = len;;
	}
}

static inline void htt_print_rx_pdev_rate_ext_stats_tlv(const void *tag_buf,
							struct debug_htt_stats_req *stats_req)
{
	const struct htt_rx_pdev_rate_ext_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 j;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_EXT_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_mcast = %d\n",
			   htt_stats_buf->rssi_mcast);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rssi_mgmt = %d\n",
			   htt_stats_buf->rssi_mgmt);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrssi_chain_ext[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain_ext[j],
			     HTT_RX_PDEV_STATS_NUM_BW_EXT_COUNTERS);
	}

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_per_chain_rssi_ext_in_dbm[%u] = ",j);
		CHAIN_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_per_chain_rssi_ext_in_dbm[j],
				   HTT_RX_PDEV_STATS_NUM_BW_EXT_COUNTERS);
	}

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_mcs_ext = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs_ext,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_stbc_ext = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc_ext,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_gi_ext[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi_ext[j],
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);
	}

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_mcs_ext = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_mcs_ext,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);

	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\nul_ofdma_rx_gi_ext[%u] = ",j);
		ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_gi_ext[j],
			     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);
	}

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_su_txbf_mcs_ext = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_su_txbf_mcs_ext,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_mu_txbf_mcs_ext = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_mu_txbf_mcs_ext,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);

        len += HTT_DBG_OUT(buf + len, buf_len - len, "\nrx_11ax_dl_ofdma_mcs_ext = ");
        ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_mcs_ext,
		     HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_pdev_tx_rate_txbf_stats_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_txrate_txbf_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i, j;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_STATS_PDEV_TX_RATE_TXBF_STATS:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Legacy OFDM Rates: 6 Mbps: %u, 9 Mbps: %u, 12 Mbps: %u, 18 Mbps: %u\n"
			   "                   24 Mbps: %u, 36 Mbps: %u, 48 Mbps: %u, 54 Mbps: %u\n",
			   htt_stats_buf->tx_legacy_ofdm_rate[0],
			   htt_stats_buf->tx_legacy_ofdm_rate[1],
			   htt_stats_buf->tx_legacy_ofdm_rate[2],
			   htt_stats_buf->tx_legacy_ofdm_rate[3],
			   htt_stats_buf->tx_legacy_ofdm_rate[4],
			   htt_stats_buf->tx_legacy_ofdm_rate[5],
			   htt_stats_buf->tx_legacy_ofdm_rate[6],
			   htt_stats_buf->tx_legacy_ofdm_rate[7]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_ol_mcs = ");
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_ol_mcs[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_ibf_mcs = ");
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_ibf_mcs[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_txbf_mcs =");
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_txbf_mcs[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_ol_nss = ");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_ol_nss[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_ibf_nss = ");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_ibf_nss[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_txbf_nss = ");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_txbf_nss[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_ol_bw = ");
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_ol_bw[i]);

	for (j = 0; j < HTT_TX_TXBF_RATE_STATS_NUM_REDUCED_CHAN_TYPES; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, j == 0 ?
				   "\nhalf_tx_ol_bw = " : "\nquarter_tx_ol_bw = ");
		ARRAY_TO_BUF(buf, len, htt_stats_buf->reduced_tx_su_ol_bw[j],
			     HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_ibf_bw = ");
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_ibf_bw[i]);

	for (j = 0; j < HTT_TX_TXBF_RATE_STATS_NUM_REDUCED_CHAN_TYPES; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, j == 0 ?
				   "\nhalf_tx_ibf_bw = " : "\nquarter_tx_ibf_bw = ");
		ARRAY_TO_BUF(buf, len, htt_stats_buf->reduced_tx_su_ibf_bw[j],
			     HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\ntx_txbf_bw = ");
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "%d:%u,", i, htt_stats_buf->tx_su_txbf_bw[i]);

	for (j = 0; j < HTT_TX_TXBF_RATE_STATS_NUM_REDUCED_CHAN_TYPES; j++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, j == 0 ?
				   "\nhalf_tx_txbf_bw = " : "\nquarter_tx_txbf_bw = ");
		ARRAY_TO_BUF(buf, len, htt_stats_buf->reduced_tx_su_txbf_bw[j],
			     HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS);
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_txbf_ofdma_ndpa_stats_tlv(const void *tag_buf,
						       struct debug_htt_stats_req *stats_req)
{
	const struct htt_txbf_ofdma_ndpa_stats_tlv *htt_stats_buf = tag_buf;
        u8 *buf = stats_req->buf;
        u32 len = stats_req->buf_len;
        u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
        int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TXBF_OFDMA_NDPA_STATS_TLV:\n");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndpa_queued_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndpa_queued[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndpa_tried_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndpa_tried[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndpa_flushed_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndpa_flushed[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndpa_err_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndpa_err[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_txbf_ofdma_ndp_stats_tlv(const void *tag_buf,
						      struct debug_htt_stats_req *stats_req)
{
	const struct htt_txbf_ofdma_ndp_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TXBF_OFDMA_NDP_STATS_TLV:\n");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndp_queued_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndp_queued[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndp_tried_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndp_tried[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndp_flushed_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndp_flushed[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_ndp_err_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_ndp_err[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_txbf_ofdma_brp_stats_tlv(const void *tag_buf,
						      struct debug_htt_stats_req *stats_req)
{
	const struct htt_txbf_ofdma_brp_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TXBF_OFDMA_BRP_STATS_TLV:\n");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_brpoll_queued_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_brpoll_queued[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_brpoll_tried_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_brpoll_tried[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_brpoll_flushed_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_brpoll_flushed[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_brp_err_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_brp_err[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_brp_err_num_cbf_rcvd_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_brp_err_num_cbf_rcvd[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_txbf_ofdma_steer_stats_tlv(const void *tag_buf,
							struct debug_htt_stats_req *stats_req)
{
	const struct htt_txbf_ofdma_steer_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_TXBF_OFDMA_STEER_STATS_TLV:\n");
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_num_ppdu_steer_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_num_ppdu_steer[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_num_ppdu_ol_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_num_ppdu_ol[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_num_usrs_prefetch_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_num_usrs_prefetch[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_num_usrs_sound_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_num_usrs_sound[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "ax_ofdma_num_usrs_force_sound_user%d = %u\n",
				   i, htt_stats_buf->ax_ofdma_num_usrs_force_sound[i]);
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;

}

static inline void htt_print_phy_counters_tlv(const void *tag_buf,
					      struct debug_htt_stats_req *stats_req)
{
	const struct htt_phy_counters_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PHY_COUNTERS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ofdma_timing_err_cnt = %u\n",
			   htt_stats_buf->rx_ofdma_timing_err_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_cck_fail_cnt = %u\n",
			   htt_stats_buf->rx_cck_fail_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mactx_abort_cnt = %u\n",
			   htt_stats_buf->mactx_abort_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "macrx_abort_cnt = %u\n",
			   htt_stats_buf->macrx_abort_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phytx_abort_cnt = %u\n",
			   htt_stats_buf->phytx_abort_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phyrx_abort_cnt = %u\n",
			   htt_stats_buf->phyrx_abort_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "phyrx_defer_abort_cnt = %u\n",
			   htt_stats_buf->phyrx_defer_abort_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_gain_adj_lstf_event_cnt = %u\n",
			   htt_stats_buf->rx_gain_adj_lstf_event_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_gain_adj_non_legacy_cnt = %u\n",
			   htt_stats_buf->rx_gain_adj_non_legacy_cnt);

	for (i = 0; i < HTT_MAX_RX_PKT_CNT; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_pkt_cnt[%d] = %u\n",
				   i, htt_stats_buf->rx_pkt_cnt[i]);

	for (i = 0; i < HTT_MAX_RX_PKT_CRC_PASS_CNT; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "rx_pkt_crc_pass_cnt[%d] = %u\n",
				   i, htt_stats_buf->rx_pkt_crc_pass_cnt[i]);

	for (i = 0; i < HTT_MAX_PER_BLK_ERR_CNT; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "per_blk_err_cnt[%d] = %u\n",
				   i, htt_stats_buf->per_blk_err_cnt[i]);

	for (i = 0; i < HTT_MAX_RX_OTA_ERR_CNT; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "rx_ota_err_cnt[%d] = %u\n",
				   i, htt_stats_buf->rx_ota_err_cnt[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_phy_stats_tlv(const void *tag_buf,
					   struct debug_htt_stats_req *stats_req)
{
	const struct htt_phy_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PHY_STATS_TLV:\n");
	for (i = 0; i < HTT_STATS_MAX_CHAINS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len, "bdf_nf_chain[%d] = %d\n",
				   i, htt_stats_buf->nf_chain[i]);

	for (i = 0; i < HTT_STATS_MAX_CHAINS; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len, "runtime_nf_chain[%d] = %d\n",
				   i, htt_stats_buf->runtime_nf_chain[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "false_radar_cnt = %u / %u (mins)\n",
			   htt_stats_buf->false_radar_cnt,
			   htt_stats_buf->fw_run_time);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "radar_cs_cnt = %u\n",
			   htt_stats_buf->radar_cs_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ani_level = %d\n",
			   htt_stats_buf->ani_level);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_phy_reset_counters_tlv(const void *tag_buf,
						    struct debug_htt_stats_req *stats_req)
{
	const struct htt_phy_reset_counters_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PHY_RESET_COUNTERS_TLV:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_counts : pdev_id = %u\n",
			   htt_stats_buf->pdev_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_counts : cf_active_low_fail_cnt = %u\n",
			   htt_stats_buf->cf_active_low_fail_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_counts : cf_active_low_pass_cnt = %u\n",
			   htt_stats_buf->cf_active_low_pass_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_counts : phy_off_through_vreg_cnt = %u\n",
			   htt_stats_buf->phy_off_through_vreg_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_counts : force_calibration_cnt = %u\n",
			   htt_stats_buf->force_calibration_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_counts : rf_mode_switch_phy_off_cnt = %u\n",
			   htt_stats_buf->rf_mode_switch_phy_off_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_phy_reset_stats_tlv(const void *tag_buf,
						 struct debug_htt_stats_req *stats_req)
{
	const struct htt_phy_reset_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PHY_RESET_STATS_TLV:\n");

	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : pdev_id = %u\n",
			   htt_stats_buf->pdev_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : chan_mhz = %u\n",
			   htt_stats_buf->chan_mhz);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : chan_band_center_freq1 = %u\n",
			   htt_stats_buf->chan_band_center_freq1);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : chan_band_center_freq2 = %u\n",
			   htt_stats_buf->chan_band_center_freq2);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : chan_phy_mode = %u\n",
			   htt_stats_buf->chan_phy_mode);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : chan_flags = 0x%0x\n",
			   htt_stats_buf->chan_flags);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : chan_num = %u\n",
			   htt_stats_buf->chan_num);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : reset_cause = 0x%0x\n",
			   htt_stats_buf->reset_cause);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : prev_reset_cause = 0x%0x\n",
			   htt_stats_buf->prev_reset_cause);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_warm_reset_src = 0x%0x\n",
			   htt_stats_buf->phy_warm_reset_src);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : rx_gain_tbl_mode = %d\n",
			   htt_stats_buf->rx_gain_tbl_mode);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : xbar_val = 0x%0x\n",
			   htt_stats_buf->xbar_val);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : force_calibration = %u\n",
			   htt_stats_buf->force_calibration);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phyrf_mode = %u\n",
			   htt_stats_buf->phyrf_mode);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_homechan = %u\n",
			   htt_stats_buf->phy_homechan);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_tx_ch_mask = 0x%0x\n",
			   htt_stats_buf->phy_tx_ch_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_rx_ch_mask = 0x%0x\n",
			   htt_stats_buf->phy_rx_ch_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phybb_ini_mask = 0x%0x\n",
			   htt_stats_buf->phybb_ini_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phyrf_ini_mask = 0x%0x\n",
			   htt_stats_buf->phyrf_ini_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_dfs_en_mask = 0x%0x\n",
			   htt_stats_buf->phy_dfs_en_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_sscan_en_mask = 0x%0x\n",
			   htt_stats_buf->phy_sscan_en_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_synth_sel_mask = 0x%0x\n",
			   htt_stats_buf->phy_synth_sel_mask);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_adfs_freq = %u\n",
			   htt_stats_buf->phy_adfs_freq);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : cck_fir_settings = 0x%0x\n",
			   htt_stats_buf->cck_fir_settings);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : phy_dyn_pri_chan = %u\n",
			   htt_stats_buf->phy_dyn_pri_chan);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : cca_thresh = 0x%0x\n",
			   htt_stats_buf->cca_thresh);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : dyn_cca_status = %u\n",
			   htt_stats_buf->dyn_cca_status);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : rxdesense_thresh_hw = 0x%x\n",
			   htt_stats_buf->rxdesense_thresh_hw);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "reset_stats : rxdesense_thresh_sw = 0x%x\n",
			   htt_stats_buf->rxdesense_thresh_sw);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_peer_ctrl_path_txrx_stats_tlv(const void *tag_buf,
							   struct debug_htt_stats_req *stats_req)
{
	const struct htt_peer_ctrl_path_txrx_stats_tlv *htt_stat_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;
	const char *mgmt_frm_type[ATH11K_STATS_MGMT_FRM_TYPE_MAX] = {"ASSOC_REQ", "ASSOC_RES",
								     "REASSOC_REQ", "REASSOC_RES",
								     "PRB_REQ", "PRB_RES", "RESV",
								     "RESV", "BCN", "ATIM",
								     "DISASSOC", "AUTH", "DAUTH",
								     "ACTN", "RESV", "RESV",};

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_STATS_PEER_CTRL_PATH_TXRX_STATS_TAG:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_mac_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
			   htt_stat_buf->peer_mac_addr[0], htt_stat_buf->peer_mac_addr[1],
			   htt_stat_buf->peer_mac_addr[2], htt_stat_buf->peer_mac_addr[3],
			   htt_stat_buf->peer_mac_addr[4], htt_stat_buf->peer_mac_addr[5]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_tx_mgmt_fc_subtype:\n");
	for (i = 0; i < ATH11K_STATS_MGMT_FRM_TYPE_MAX; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\t%s[%d]:%u\n",
				   mgmt_frm_type[i], i,
				   htt_stat_buf->peer_rx_mgmt_subtype[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_rx_mgmt_fc_subtype:\n");
	for (i = 0; i < ATH11K_STATS_MGMT_FRM_TYPE_MAX; i++)
		len += HTT_DBG_OUT(buf + len, buf_len - len, "\t%s[%d]:%u\n",
				   mgmt_frm_type[i], i,
				   htt_stat_buf->peer_rx_mgmt_subtype[i]);

	len += HTT_DBG_OUT(buf + len, buf_len - len,"\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_pdev_ctrl_path_tx_stats_tlv(const void *tag_buf,
							 struct debug_htt_stats_req *stats_req)
{
	const struct htt_pdev_ctrl_path_tx_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_STATS_PDEV_CTRL_PATH_TX_STATS_TAG:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "fw_tx_mgmt_subtype = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_tx_mgmt_subtype,
		     HTT_STATS_SUBTYPE_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_sched_txq_supercycle_trigger_tlv(const void *tag_buf, u16 tag_len,
					   struct debug_htt_stats_req *stats_req)
{
	const struct htt_sched_txq_supercycle_triggers_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_SCHED_SUPERCYCLE_TRIGGER_MAX);

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_SCHED_TXQ_SUPERCYCLE_TRIGGER_V:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "supercycle_triggers = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->supercycle_triggers, num_elems);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_hw_war_tlv(const void *tag_buf, u16 tag_len,
					struct debug_htt_stats_req *stats_req)
{
	const struct htt_hw_war_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	u8 i;
	u32 tag_words = tag_len >> 2;

	tag_words--;         /* first word beyond TLV header is for mac_id */

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_HW_WAR_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "mac_id = %u\n",
			  htt_stats_buf->mac_id__word & 0xFF);

	for (i = 0; i < tag_words; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len, "hw_war %u = %u\n",
				   i, htt_stats_buf->hw_wars[i]);
	}

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_peer_sched_stats_tlv(const void *tag_buf,
						  struct debug_htt_stats_req *stats_req)
{
	const struct htt_peer_sched_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PEER_SCHED_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_id = %u\n",
			   htt_stats_buf->peer_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_sched_dl = %u\n",
			   htt_stats_buf->num_sched_dl);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "num_sched_ul = %u\n",
			   htt_stats_buf->num_sched_ul);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_tx_active_dur_ms = %llu\n",
			   (div_u64((htt_stats_buf->peer_tx_active_dur_us_low |
			   ((unsigned long long)htt_stats_buf->peer_tx_active_dur_us_high << 32)),
			   1000)));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_rx_active_dur_ms = %llu\n",
			   (div_u64((htt_stats_buf->peer_rx_active_dur_us_low |
			   ((unsigned long long)htt_stats_buf->peer_rx_active_dur_us_high << 32)),
			   1000)));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "peer_curr_rate_kbps = %u\n",
			   htt_stats_buf->peer_curr_rate_kbps);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_ac_sched_status_stats_tlv(const void *tag_buf,
					       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_ac_sched_status_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_SELFGEN_AC_SCHED_STATUS_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ac_su_ndpa_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_su_ndpa_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_su_ndp_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_su_ndp_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_ndpa_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_ndpa_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_ndp_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_ndp_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_brp_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_brp_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_su_ndp_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_su_ndp_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_ndp_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_ndp_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nac_mu_mimo_brp_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_brp_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_tx_selfgen_ax_sched_status_stats_tlv(const void *tag_buf,
					       struct debug_htt_stats_req *stats_req)
{
	const struct htt_tx_selfgen_ax_sched_status_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "HTT_TX_SELFGEN_AX_SCHED_STATUS_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ax_su_ndpa_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_su_ndpa_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_su_ndp_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_su_ndp_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_ndpa_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_ndpa_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_ndp_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_ndp_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_brp_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_brp_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_bar_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_bar_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_basic_trig_sch_status = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_basic_trig_sch_status,
		     HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_su_ndp_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_su_ndp_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_mimo_ndp_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_ndp_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_brp_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_brp_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_mu_bar_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_bar_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\nax_basic_trig_sch_flag_err = ");
	ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_basic_trig_sch_flag_err,
		     HTT_TX_SELFGEN_NUM_SCH_TSFLAG_ERROR_STATS);

	len += HTT_DBG_OUT(buf + len, buf_len - len, "\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_unavailable_error_stats_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_stats_error_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_ERROR_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "No stats to print for current request: %d\n",
			   htt_stats_buf->htt_stats_type);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void
htt_print_unsupported_error_stats_tlv(const void *tag_buf,
				      struct debug_htt_stats_req *stats_req)
{
	const struct htt_stats_error_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_ERROR_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "Unsupported HTT stats type: %d\n",
			   htt_stats_buf->htt_stats_type);

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_vdev_rtt_resp_stats_tlv(const void *tag_buf,
						     struct debug_htt_stats_req *stats_req)
{
	const struct htt_vdev_rtt_resp_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_VDEV_RTT_RESP_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "vdev_id = %u\n",
			   htt_stats_buf->vdev_id);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_ftm_suc = %u\n",
			   htt_stats_buf->tx_ftm_suc);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_ftm_suc_retry = %u\n",
			   htt_stats_buf->tx_ftm_suc_retry);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "tx_ftm_fail = %u\n",
			   htt_stats_buf->tx_ftm_fail);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ftmr_cnt = %u\n",
			   htt_stats_buf->rx_ftmr_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_ftmr_dup_cnt = %u\n",
			   htt_stats_buf->rx_ftmr_dup_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_iftmr_cnt = %u\n",
			   htt_stats_buf->rx_iftmr_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "rx_iftmr_dup_cnt = %u\n",
			   htt_stats_buf->rx_iftmr_dup_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "initiator_active_responder_rejected_cnt = %u\n",
			   htt_stats_buf->initiator_active_responder_rejected_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "responder_terminate_cnt = %u\n",
			   htt_stats_buf->responder_terminate_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_pktlog_and_htt_ring_stats_tlv(const void *tag_buf,
							   struct debug_htt_stats_req *stats_req)
{
	const struct htt_pktlog_and_htt_ring_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_PKTLOG_AND_HTT_RING_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pktlog_lite_drop_cnt = %u\n",
			   htt_stats_buf->pktlog_lite_drop_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pktlog_tqm_drop_cnt = %u\n",
			   htt_stats_buf->pktlog_tqm_drop_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pktlog_ppdu_stats_drop_cnt = %u\n",
			   htt_stats_buf->pktlog_ppdu_stats_drop_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pktlog_ppdu_ctrl_drop_cnt = %u\n",
			   htt_stats_buf->pktlog_ppdu_ctrl_drop_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len, "pktlog_sw_events_drop_cnt = %u\n",
			   htt_stats_buf->pktlog_sw_events_drop_cnt);
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static inline void htt_print_dlpager_stats_tlv(const void *tag_buf,
					       struct debug_htt_stats_req *stats_req)
{
	const struct htt_dl_pager_stats_tlv *htt_stats_buf = tag_buf;
	u8 *buf = stats_req->buf;
	u32 len = stats_req->buf_len;
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
	int i;

	len += HTT_DBG_OUT(buf + len, buf_len - len, "HTT_DLPAGER_STATS_TLV:\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "ASYNC locked pages = %u\n",
			   HTT_DLPAGER_ASYNC_LOCK_PAGE_COUNT_GET(htt_stats_buf->msg_dword_1));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "SYNC locked pages = %u\n",
			   HTT_DLPAGER_SYNC_LOCK_PAGE_COUNT_GET(htt_stats_buf->msg_dword_1));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Total locked pages = %u\n",
			   HTT_DLPAGER_TOTAL_LOCKED_PAGES_GET(htt_stats_buf->msg_dword_2));
	len += HTT_DBG_OUT(buf + len, buf_len - len, "Total free pages = %u\n",
			   HTT_DLPAGER_TOTAL_FREE_PAGES_GET(htt_stats_buf->msg_dword_2));
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "LOCKED PAGES HISTORY\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_locked_page_idx = %u\n",
			   (HTT_DLPAGER_LAST_LOCKED_PAGE_IDX_GET(htt_stats_buf->msg_dword_3)) ? \
			   (HTT_DLPAGER_LAST_LOCKED_PAGE_IDX_GET(htt_stats_buf->msg_dword_3) - 1) : (HTT_DLPAGER_STATS_MAX_HIST-1));

	for (i = 0; i < HTT_DLPAGER_STATS_MAX_HIST; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "Index - %u : Page Number - %u : Num of pages - %u : Timestamp - %llu us\n",
				   i, htt_stats_buf->last_pages_info[HTT_STATS_PAGE_LOCKED][i].page_num,
				   htt_stats_buf->last_pages_info[HTT_STATS_PAGE_LOCKED][i].num_of_pages,
				   ((htt_stats_buf->last_pages_info[HTT_STATS_PAGE_LOCKED][i].timestamp_lsbs) |
				    (((unsigned long long) htt_stats_buf->last_pages_info[HTT_STATS_PAGE_LOCKED][i].timestamp_msbs) << 32)));
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "UNLOCKED PAGES HISTORY\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");
	len += HTT_DBG_OUT(buf + len, buf_len - len, "last_unlocked_page_idx = %u\n",
			   (HTT_DLPAGER_LAST_UNLOCKED_PAGE_IDX_GET(htt_stats_buf->msg_dword_3)) ? \
			   (HTT_DLPAGER_LAST_UNLOCKED_PAGE_IDX_GET(htt_stats_buf->msg_dword_3) - 1) : (HTT_DLPAGER_STATS_MAX_HIST-1));

	for (i = 0; i < HTT_DLPAGER_STATS_MAX_HIST; i++) {
		len += HTT_DBG_OUT(buf + len, buf_len - len,
				   "Index - %u : Page Number - %u : Num of pages - %u : Timestamp - %llu us\n",
				   i, htt_stats_buf->last_pages_info[HTT_STATS_PAGE_UNLOCKED][i].page_num,
				   htt_stats_buf->last_pages_info[HTT_STATS_PAGE_UNLOCKED][i].num_of_pages,
				   ((htt_stats_buf->last_pages_info[HTT_STATS_PAGE_UNLOCKED][i].timestamp_lsbs) |
				    (((unsigned long long) htt_stats_buf->last_pages_info[HTT_STATS_PAGE_UNLOCKED][i].timestamp_msbs) << 32)));
	}

	len += HTT_DBG_OUT(buf + len, buf_len - len,
			   "=================================================\n");

	if (len >= buf_len)
		buf[buf_len - 1] = 0;
	else
		buf[len] = 0;

	stats_req->buf_len = len;
}

static int ath11k_dbg_htt_ext_stats_parse(struct ath11k_base *ab,
					  u16 tag, u16 len, const void *tag_buf,
					  void *user_data)
{
	struct debug_htt_stats_req *stats_req = user_data;
	u8  *buf;
	u32 buf_len;
	u32 buf_size = ATH11K_HTT_STATS_BUF_SIZE;

	switch (tag) {
	case HTT_STATS_TX_PDEV_CMN_TAG:
		htt_print_tx_pdev_stats_cmn_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TX_PDEV_UNDERRUN_TAG:
		htt_print_tx_pdev_stats_urrn_tlv_v(tag_buf, len, stats_req);
		break;
	case HTT_STATS_TX_PDEV_SIFS_TAG:
		htt_print_tx_pdev_stats_sifs_tlv_v(tag_buf, len, stats_req);
		break;
	case HTT_STATS_TX_PDEV_FLUSH_TAG:
		htt_print_tx_pdev_stats_flush_tlv_v(tag_buf, len, stats_req);
		break;
	case HTT_STATS_TX_PDEV_PHY_ERR_TAG:
		htt_print_tx_pdev_stats_phy_err_tlv_v(tag_buf, len, stats_req);
		break;
	case HTT_STATS_TX_PDEV_SIFS_HIST_TAG:
		htt_print_tx_pdev_stats_sifs_hist_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_PDEV_TX_PPDU_STATS_TAG:
		htt_print_tx_pdev_stats_tx_ppdu_stats_tlv_v(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_PDEV_TRIED_MPDU_CNT_HIST_TAG:
		htt_print_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v(tag_buf, len,
								  stats_req);
		break;

	case HTT_STATS_STRING_TAG:
		htt_print_stats_string_tlv(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_HWQ_CMN_TAG:
		htt_print_tx_hwq_stats_cmn_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_HWQ_DIFS_LATENCY_TAG:
		htt_print_tx_hwq_difs_latency_stats_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_HWQ_CMD_RESULT_TAG:
		htt_print_tx_hwq_cmd_result_stats_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_HWQ_CMD_STALL_TAG:
		htt_print_tx_hwq_cmd_stall_stats_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_HWQ_FES_STATUS_TAG:
		htt_print_tx_hwq_fes_result_stats_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_HWQ_TRIED_MPDU_CNT_HIST_TAG:
		htt_print_tx_hwq_tried_mpdu_cnt_hist_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_HWQ_TXOP_USED_CNT_HIST_TAG:
		htt_print_tx_hwq_txop_used_cnt_hist_tlv_v(tag_buf, len, stats_req);
		break;
	case HTT_STATS_TX_TQM_GEN_MPDU_TAG:
		htt_print_tx_tqm_gen_mpdu_stats_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_TQM_LIST_MPDU_TAG:
		htt_print_tx_tqm_list_mpdu_stats_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG:
		htt_print_tx_tqm_list_mpdu_cnt_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_TQM_CMN_TAG:
		htt_print_tx_tqm_cmn_stats_tlv(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_TQM_PDEV_TAG:
		htt_print_tx_tqm_pdev_stats_tlv_v(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_TQM_CMDQ_STATUS_TAG:
		htt_print_tx_tqm_cmdq_status_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG:
		htt_print_tx_de_eapol_packets_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG:
		htt_print_tx_de_classify_failed_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG:
		htt_print_tx_de_classify_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG:
		htt_print_tx_de_classify_status_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG:
		htt_print_tx_de_enqueue_packets_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG:
		htt_print_tx_de_enqueue_discard_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_FW2WBM_RING_FULL_HIST_TAG:
		htt_print_tx_de_fw2wbm_ring_full_hist_tlv(tag_buf, len, stats_req);
		break;

	case HTT_STATS_TX_DE_CMN_TAG:
		htt_print_tx_de_cmn_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_RING_IF_TAG:
		htt_print_ring_if_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG:
		htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_SFM_CMN_TAG:
		htt_print_sfm_cmn_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_SRING_STATS_TAG:
		htt_print_sring_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_RX_PDEV_FW_STATS_TAG:
		htt_print_rx_pdev_fw_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_RX_PDEV_FW_RING_MPDU_ERR_TAG:
		htt_print_rx_pdev_fw_ring_mpdu_err_tlv_v(tag_buf, stats_req);
		break;

	case HTT_STATS_RX_PDEV_FW_MPDU_DROP_TAG:
		htt_print_rx_pdev_fw_mpdu_drop_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_RX_SOC_FW_STATS_TAG:
		htt_print_rx_soc_fw_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_RX_SOC_FW_REFILL_RING_EMPTY_TAG:
		htt_print_rx_soc_fw_refill_ring_empty_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_RX_SOC_FW_REFILL_RING_NUM_REFILL_TAG:
		htt_print_rx_soc_fw_refill_ring_num_refill_tlv_v(
				tag_buf, len, stats_req);
		break;
	case HTT_STATS_RX_REFILL_RXDMA_ERR_TAG:
		htt_print_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v(
				tag_buf, len, stats_req);
		break;

	case HTT_STATS_RX_REFILL_REO_ERR_TAG:
		htt_print_rx_soc_fw_refill_ring_num_reo_err_tlv_v(
				tag_buf, len, stats_req);
		break;

	case HTT_STATS_RX_REO_RESOURCE_STATS_TAG:
		htt_print_rx_reo_debug_stats_tlv_v(
				tag_buf, stats_req);
		break;
	case HTT_STATS_RX_PDEV_FW_STATS_PHY_ERR_TAG:
		htt_print_rx_pdev_fw_stats_phy_err_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_PDEV_RATE_STATS_TAG:
		htt_print_tx_pdev_rate_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_RX_PDEV_RATE_STATS_TAG:
		htt_print_rx_pdev_rate_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG:
		htt_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TX_SCHED_CMN_TAG:
		htt_print_stats_tx_sched_cmn_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_PDEV_MPDU_STATS_TAG:
		htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG:
		htt_print_sched_txq_cmd_posted_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_RING_IF_CMN_TAG:
		htt_print_ring_if_cmn_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_SFM_CLIENT_USER_TAG:
		htt_print_sfm_client_user_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_SFM_CLIENT_TAG:
		htt_print_sfm_client_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_TQM_ERROR_STATS_TAG:
		htt_print_tx_tqm_error_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG:
		htt_print_sched_txq_cmd_reaped_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_SRING_CMN_TAG:
		htt_print_sring_cmn_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_SOUNDING_STATS_TAG:
		htt_print_tx_sounding_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG:
		htt_print_tx_selfgen_ac_err_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG:
		htt_print_tx_selfgen_cmn_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_SELFGEN_AC_STATS_TAG:
		htt_print_tx_selfgen_ac_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_SELFGEN_AX_STATS_TAG:
		htt_print_tx_selfgen_ax_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG:
		htt_print_tx_selfgen_ax_err_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_HWQ_MUMIMO_SCH_STATS_TAG:
		htt_print_tx_hwq_mu_mimo_sch_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_HWQ_MUMIMO_MPDU_STATS_TAG:
		htt_print_tx_hwq_mu_mimo_mpdu_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_HWQ_MUMIMO_CMN_STATS_TAG:
		htt_print_tx_hwq_mu_mimo_cmn_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_HW_INTR_MISC_TAG:
		htt_print_hw_stats_intr_misc_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_HW_WD_TIMEOUT_TAG:
		htt_print_hw_stats_wd_timeout_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_HW_PDEV_ERRS_TAG:
		htt_print_hw_stats_pdev_errs_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_COUNTER_NAME_TAG:
		htt_print_counter_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_TID_DETAILS_TAG:
		htt_print_tx_tid_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_TID_DETAILS_V1_TAG:
		htt_print_tx_tid_stats_v1_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_RX_TID_DETAILS_TAG:
		htt_print_rx_tid_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PEER_STATS_CMN_TAG:
		htt_print_peer_stats_cmn_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PEER_DETAILS_TAG:
		htt_print_peer_details_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PEER_MSDU_FLOWQ_TAG:
		htt_print_msdu_flow_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PEER_TX_RATE_STATS_TAG:
		htt_print_tx_peer_rate_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PEER_RX_RATE_STATS_TAG:
		htt_print_rx_peer_rate_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_TX_DE_COMPL_STATS_TAG:
		htt_print_tx_de_compl_stats_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PDEV_CCA_1SEC_HIST_TAG:
	case HTT_STATS_PDEV_CCA_100MSEC_HIST_TAG:
	case HTT_STATS_PDEV_CCA_STAT_CUMULATIVE_TAG:
		htt_print_pdev_cca_stats_hist_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PDEV_CCA_COUNTERS_TAG:
		htt_print_pdev_stats_cca_counters_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_WHAL_TX_TAG:
		htt_print_hw_stats_whal_tx_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PDEV_TWT_SESSIONS_TAG:
		htt_print_pdev_stats_twt_sessions_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_PDEV_TWT_SESSION_TAG:
		htt_print_pdev_stats_twt_session_tlv(tag_buf, stats_req);
		break;

	case HTT_STATS_SCHED_TXQ_SCHED_ORDER_SU_TAG:
		htt_print_sched_txq_sched_order_su_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_SCHED_TXQ_SCHED_INELIGIBILITY_TAG:
		htt_print_sched_txq_sched_ineligibility_tlv_v(tag_buf, len, stats_req);
		break;

	case HTT_STATS_PDEV_OBSS_PD_TAG:
		htt_print_pdev_obss_pd_stats_tlv_v(tag_buf, stats_req);
		break;
	case HTT_STATS_HW_WAR_TAG:
		htt_print_hw_war_tlv(tag_buf, len, stats_req);
		break;
	case HTT_STATS_RING_BACKPRESSURE_STATS_TAG:
		htt_print_backpressure_stats_tlv_v(tag_buf, user_data);
		break;
	case HTT_STATS_LATENCY_PROF_STATS_TAG:
		htt_print_latency_prof_stats_tlv_v(tag_buf, user_data);
		break;
	case HTT_STATS_LATENCY_CTX_TAG:
		htt_print_latency_prof_ctx_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_LATENCY_CNT_TAG:
		htt_print_latency_prof_cnt(tag_buf, stats_req);
		break;
	case HTT_STATS_RX_PDEV_UL_TRIG_STATS_TAG:
		htt_print_ul_ofdma_trigger_stats(tag_buf, stats_req);
		break;
	case HTT_STATS_RX_PDEV_UL_OFDMA_USER_STATS_TAG:
		htt_print_ul_ofdma_user_stats(tag_buf, stats_req);
		break;
	case HTT_STATS_RX_PDEV_UL_MIMO_USER_STATS_TAG:
		htt_print_ul_mimo_user_stats(tag_buf, stats_req);
		break;
	case HTT_STATS_RX_PDEV_UL_MUMIMO_TRIG_STATS_TAG:
		htt_print_ul_mumimo_trig_stats(tag_buf, stats_req);
		break;
	case HTT_STATS_RX_FSE_STATS_TAG:
		htt_print_rx_fse_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PEER_SCHED_STATS_TAG:
		htt_print_peer_sched_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_SCHED_TXQ_SUPERCYCLE_TRIGGER_TAG:
		htt_print_sched_txq_supercycle_trigger_tlv(tag_buf, len, stats_req);
		break;
	case HTT_STATS_PDEV_CTRL_PATH_TX_STATS_TAG:
		htt_print_pdev_ctrl_path_tx_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_RX_PDEV_RATE_EXT_STATS_TAG:
		htt_print_rx_pdev_rate_ext_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PDEV_TX_RATE_TXBF_STATS_TAG:
		htt_print_pdev_tx_rate_txbf_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TXBF_OFDMA_NDPA_STATS_TAG:
		htt_print_txbf_ofdma_ndpa_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TXBF_OFDMA_NDP_STATS_TAG:
		htt_print_txbf_ofdma_ndp_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TXBF_OFDMA_BRP_STATS_TAG:
		htt_print_txbf_ofdma_brp_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TXBF_OFDMA_STEER_STATS_TAG:
		htt_print_txbf_ofdma_steer_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TX_SELFGEN_AC_SCHED_STATUS_STATS_TAG:
		htt_print_tx_selfgen_ac_sched_status_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_TX_SELFGEN_AX_SCHED_STATUS_STATS_TAG:
		htt_print_tx_selfgen_ax_sched_status_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_UNAVAILABLE_ERROR_STATS_TAG:
		htt_print_unavailable_error_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_UNSUPPORTED_ERROR_STATS_TAG:
		htt_print_unsupported_error_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_VDEV_RTT_RESP_STATS_TAG:
		htt_print_vdev_rtt_resp_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PKTLOG_AND_HTT_RING_STATS_TAG:
		htt_print_pktlog_and_htt_ring_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_DLPAGER_STATS_TAG:
		htt_print_dlpager_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PHY_COUNTERS_TAG:
		htt_print_phy_counters_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PHY_STATS_TAG:
		htt_print_phy_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PHY_RESET_COUNTERS_TAG:
		htt_print_phy_reset_counters_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PHY_RESET_STATS_TAG:
		htt_print_phy_reset_stats_tlv(tag_buf, stats_req);
		break;
	case HTT_STATS_PEER_CTRL_PATH_TXRX_STATS_TAG:
		htt_print_peer_ctrl_path_txrx_stats_tlv(tag_buf, stats_req);
		break;
	default:
		break;
	}
	/* Append line break after each TLV */
	buf = stats_req->buf;
	buf_len = stats_req->buf_len;
	buf_len += HTT_DBG_OUT(buf + buf_len, buf_size - buf_len, "\n");

	stats_req->buf_len = buf_len;

	return 0;
}

void ath11k_debugfs_htt_ext_stats_handler(struct ath11k_base *ab,
					  struct sk_buff *skb)
{
	struct ath11k_htt_extd_stats_msg *msg;
	struct debug_htt_stats_req *stats_req;
	struct ath11k *ar;
	u32 len;
	u64 cookie;
	int ret;
	bool send_completion = false;
	u8 pdev_id;

	msg = (struct ath11k_htt_extd_stats_msg *)skb->data;
	cookie = msg->cookie;

	if (FIELD_GET(HTT_STATS_COOKIE_MSB, cookie) != HTT_STATS_MAGIC_VALUE) {
		ath11k_warn(ab, "received invalid htt ext stats event\n");
		return;
	}

	pdev_id = FIELD_GET(HTT_STATS_COOKIE_LSB, cookie);
	rcu_read_lock();
	ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id);
	rcu_read_unlock();
	if (!ar) {
		ath11k_warn(ab, "failed to get ar for pdev_id %d\n", pdev_id);
		return;
	}

	stats_req = ar->debug.htt_stats.stats_req;
	if (!stats_req)
		return;

	spin_lock_bh(&ar->debug.htt_stats.lock);

	stats_req->done = FIELD_GET(HTT_T2H_EXT_STATS_INFO1_DONE, msg->info1);
	if (stats_req->done)
		send_completion = true;

	spin_unlock_bh(&ar->debug.htt_stats.lock);

	len = FIELD_GET(HTT_T2H_EXT_STATS_INFO1_LENGTH, msg->info1);
	ret = ath11k_dp_htt_tlv_iter(ab, msg->data, len,
				     ath11k_dbg_htt_ext_stats_parse,
				     stats_req);
	if (ret)
		ath11k_warn(ab, "Failed to parse tlv %d\n", ret);

	if (send_completion)
		complete(&stats_req->cmpln);
}

static ssize_t ath11k_read_htt_stats_type(struct file *file,
					  char __user *user_buf,
					  size_t count, loff_t *ppos)
{
	struct ath11k *ar = file->private_data;
	char buf[32];
	size_t len;

	len = scnprintf(buf, sizeof(buf), "%u\n", ar->debug.htt_stats.type);

	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}

static ssize_t ath11k_write_htt_stats_type(struct file *file,
					   const char __user *user_buf,
					   size_t count, loff_t *ppos)
{
	struct ath11k *ar = file->private_data;
	u8 type;
	int ret;

	ret = kstrtou8_from_user(user_buf, count, 0, &type);
	if (ret)
		return ret;

	if (type >= ATH11K_DBG_HTT_NUM_EXT_STATS)
		return -E2BIG;

	if (type == ATH11K_DBG_HTT_EXT_STATS_RESET)
		return -EPERM;

	ar->debug.htt_stats.type = type;

	ret = count;

	return ret;
}

static const struct file_operations fops_htt_stats_type = {
	.read = ath11k_read_htt_stats_type,
	.write = ath11k_write_htt_stats_type,
	.open = simple_open,
	.owner = THIS_MODULE,
	.llseek = default_llseek,
};

static int ath11k_prep_htt_stats_cfg_params(struct ath11k *ar, u8 type,
					    const u8 *mac_addr,
					    struct htt_ext_stats_cfg_params *cfg_params)
{
	if (!cfg_params)
		return -EINVAL;

	switch (type) {
	case ATH11K_DBG_HTT_EXT_STATS_PDEV_TX_HWQ:
	case ATH11K_DBG_HTT_EXT_STATS_TX_MU_HWQ:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_HWQS;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_PDEV_TX_SCHED:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_TXQS;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_TQM_CMDQ:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_CMDQS;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_PEER_INFO:
		cfg_params->cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR;
		cfg_params->cfg0 |= FIELD_PREP(GENMASK(15, 1),
					HTT_PEER_STATS_REQ_MODE_FLUSH_TQM);
		cfg_params->cfg1 = HTT_STAT_DEFAULT_PEER_REQ_TYPE;
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(7, 0), mac_addr[0]);
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(15, 8), mac_addr[1]);
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(23, 16), mac_addr[2]);
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(31, 24), mac_addr[3]);
		cfg_params->cfg3 |= FIELD_PREP(GENMASK(7, 0), mac_addr[4]);
		cfg_params->cfg3 |= FIELD_PREP(GENMASK(15, 8), mac_addr[5]);
		break;
	case ATH11K_DBG_HTT_EXT_STATS_RING_IF_INFO:
	case ATH11K_DBG_HTT_EXT_STATS_SRNG_INFO:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_RINGS;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_ACTIVE_PEERS_LIST:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_PEERS;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_PDEV_CCA_STATS:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_CCA_CUMULATIVE;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_TX_SOUNDING_INFO:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_VDEVS;
		break;
	case ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS:
		cfg_params->cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR;
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(7, 0), mac_addr[0]);
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(15, 8), mac_addr[1]);
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(23, 16), mac_addr[2]);
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(31, 24), mac_addr[3]);
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(7, 0), mac_addr[4]);
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(15, 8), mac_addr[5]);
		break;
	case ATH11K_DBG_HTT_EXT_VDEV_RTT_RESP_STATS:
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_VDEVS;
		break;
	default:
		break;
	}

	return 0;
}

int ath11k_debugfs_htt_stats_req(struct ath11k *ar)
{
	struct debug_htt_stats_req *stats_req = ar->debug.htt_stats.stats_req;
	u8 type = stats_req->type;
	u64 cookie = 0;
	int ret, pdev_id = ar->pdev->pdev_id;
	struct htt_ext_stats_cfg_params cfg_params = { 0 };

	init_completion(&stats_req->cmpln);

	stats_req->done = false;
	stats_req->pdev_id = pdev_id;

	cookie = FIELD_PREP(HTT_STATS_COOKIE_MSB, HTT_STATS_MAGIC_VALUE) |
		 FIELD_PREP(HTT_STATS_COOKIE_LSB, pdev_id);

	ret = ath11k_prep_htt_stats_cfg_params(ar, type, stats_req->peer_addr,
					       &cfg_params);
	if (ret) {
		ath11k_warn(ar->ab, "failed to set htt stats cfg params: %d\n", ret);
		return ret;
	}

	ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar, type, &cfg_params, cookie);
	if (ret) {
		ath11k_warn(ar->ab, "failed to send htt stats request: %d\n", ret);
		return ret;
	}

	while (!wait_for_completion_timeout(&stats_req->cmpln, 3 * HZ)) {
		spin_lock_bh(&ar->debug.htt_stats.lock);
		if (!stats_req->done) {
			stats_req->done = true;
			spin_unlock_bh(&ar->debug.htt_stats.lock);
			ath11k_warn(ar->ab, "stats request timed out\n");
			return -ETIMEDOUT;
		}
		spin_unlock_bh(&ar->debug.htt_stats.lock);
	}

	return 0;
}

static int ath11k_open_htt_stats(struct inode *inode, struct file *file)
{
	struct ath11k *ar = inode->i_private;
	struct debug_htt_stats_req *stats_req;
	u8 type = ar->debug.htt_stats.type;
	int ret;

	if (type == ATH11K_DBG_HTT_EXT_STATS_RESET ||
	    type == ATH11K_DBG_HTT_EXT_STATS_PEER_INFO ||
	    type == ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS)
		return -EPERM;

	mutex_lock(&ar->conf_mutex);

	if (ar->state != ATH11K_STATE_ON &&
	    ar->ab->fw_mode != ATH11K_FIRMWARE_MODE_FTM) {
		ret = -ENETDOWN;
		goto err_unlock;
	}

	if (ar->debug.htt_stats.stats_req) {
		ret = -EAGAIN;
		goto err_unlock;
	}

	stats_req = vzalloc(sizeof(*stats_req) + ATH11K_HTT_STATS_BUF_SIZE);
	if (!stats_req) {
		ret = -ENOMEM;
		goto err_unlock;
	}

	ar->debug.htt_stats.stats_req = stats_req;
	stats_req->type = type;

	ret = ath11k_debugfs_htt_stats_req(ar);
	if (ret < 0)
		goto out;

	file->private_data = stats_req;

	mutex_unlock(&ar->conf_mutex);

	return 0;
out:
	vfree(stats_req);
	ar->debug.htt_stats.stats_req = NULL;
err_unlock:
	mutex_unlock(&ar->conf_mutex);

	return ret;
}

static int ath11k_release_htt_stats(struct inode *inode, struct file *file)
{
	struct ath11k *ar = inode->i_private;

	mutex_lock(&ar->conf_mutex);
	vfree(file->private_data);
	ar->debug.htt_stats.stats_req = NULL;
	mutex_unlock(&ar->conf_mutex);

	return 0;
}

static ssize_t ath11k_read_htt_stats(struct file *file,
				     char __user *user_buf,
				     size_t count, loff_t *ppos)
{
	struct debug_htt_stats_req *stats_req = file->private_data;
	char *buf;
	u32 length = 0;

	buf = stats_req->buf;
	length = min_t(u32, stats_req->buf_len, ATH11K_HTT_STATS_BUF_SIZE);
	return simple_read_from_buffer(user_buf, count, ppos, buf, length);
}

static const struct file_operations fops_dump_htt_stats = {
	.open = ath11k_open_htt_stats,
	.release = ath11k_release_htt_stats,
	.read = ath11k_read_htt_stats,
	.owner = THIS_MODULE,
	.llseek = default_llseek,
};

static ssize_t ath11k_read_htt_stats_reset(struct file *file,
					   char __user *user_buf,
					   size_t count, loff_t *ppos)
{
	struct ath11k *ar = file->private_data;
	char buf[32];
	size_t len;

	len = scnprintf(buf, sizeof(buf), "%u\n", ar->debug.htt_stats.reset);

	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
}

static ssize_t ath11k_write_htt_stats_reset(struct file *file,
					    const char __user *user_buf,
					    size_t count, loff_t *ppos)
{
	struct ath11k *ar = file->private_data;
	u8 type;
	struct htt_ext_stats_cfg_params cfg_params = { 0 };
	int ret;

	ret = kstrtou8_from_user(user_buf, count, 0, &type);
	if (ret)
		return ret;

	if (type >= ATH11K_DBG_HTT_NUM_EXT_STATS ||
	    type == ATH11K_DBG_HTT_EXT_STATS_RESET)
		return -E2BIG;

	mutex_lock(&ar->conf_mutex);
	cfg_params.cfg0 = HTT_STAT_DEFAULT_RESET_START_OFFSET;
	cfg_params.cfg1 = 1 << (cfg_params.cfg0 + type);
	ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar,
						 ATH11K_DBG_HTT_EXT_STATS_RESET,
						 &cfg_params,
						 0ULL);
	if (ret) {
		ath11k_warn(ar->ab, "failed to send htt stats request: %d\n", ret);
		mutex_unlock(&ar->conf_mutex);
		return ret;
	}

	ar->debug.htt_stats.reset = type;
	mutex_unlock(&ar->conf_mutex);

	ret = count;

	return ret;
}

static const struct file_operations fops_htt_stats_reset = {
	.read = ath11k_read_htt_stats_reset,
	.write = ath11k_write_htt_stats_reset,
	.open = simple_open,
	.owner = THIS_MODULE,
	.llseek = default_llseek,
};

void ath11k_debugfs_htt_stats_init(struct ath11k *ar)
{
	spin_lock_init(&ar->debug.htt_stats.lock);
	debugfs_create_file("htt_stats_type", 0600, ar->debug.debugfs_pdev,
			    ar, &fops_htt_stats_type);
	debugfs_create_file("htt_stats", 0400, ar->debug.debugfs_pdev,
			    ar, &fops_dump_htt_stats);
	debugfs_create_file("htt_stats_reset", 0600, ar->debug.debugfs_pdev,
			    ar, &fops_htt_stats_reset);
}