Quelle  debugfs_htt_stats.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause-Clear
/*
 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 */

#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_MAX_PRINT_CHAR_PER_ELEM 15

#define HTT_TLV_HDR_LEN 4

#define PRINT_ARRAY_TO_BUF(out, buflen, arr, str, len, newline)    \
 do {          \
  int index = 0; u8 i; const char *str_val = str;    \
  const char *new_line = newline;      \
  if (str_val) {        \
   index += scnprintf((out + buflen),    \
     (ATH11K_HTT_STATS_BUF_SIZE - buflen),   \
     "%s = ", str_val);     \
  }         \
  for (i = 0; i < len; i++) {      \
   index += scnprintf((out + buflen) + index,   \
     (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,  \
     " %u:%u,", i, arr[i]);     \
  }         \
  index += scnprintf((out + buflen) + index,    \
    (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,   \
     "%s", new_line);      \
  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 += scnprintf(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n");

 len += scnprintf(buf + len, buf_len - len,
    "data = ");
 for (i = 0; i < tag_len; i++) {
  len += scnprintf(buf + len,
     buf_len - len,
     "%.*s", 4, (char *)&(htt_stats_buf->data[i]));
 }
 /* New lines are added for better display */
 len += scnprintf(buf + len, buf_len - len, "\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
    FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
 len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n",
    htt_stats_buf->hw_queued);
 len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n",
    htt_stats_buf->hw_reaped);
 len += scnprintf(buf + len, buf_len - len, "underrun = %u\n",
    htt_stats_buf->underrun);
 len += scnprintf(buf + len, buf_len - len, "hw_paused = %u\n",
    htt_stats_buf->hw_paused);
 len += scnprintf(buf + len, buf_len - len, "hw_flush = %u\n",
    htt_stats_buf->hw_flush);
 len += scnprintf(buf + len, buf_len - len, "hw_filt = %u\n",
    htt_stats_buf->hw_filt);
 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n",
    htt_stats_buf->tx_abort);
 len += scnprintf(buf + len, buf_len - len, "mpdu_requeued = %u\n",
    htt_stats_buf->mpdu_requeued);
 len += scnprintf(buf + len, buf_len - len, "tx_xretry = %u\n",
    htt_stats_buf->tx_xretry);
 len += scnprintf(buf + len, buf_len - len, "data_rc = %u\n",
    htt_stats_buf->data_rc);
 len += scnprintf(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n",
    htt_stats_buf->mpdu_dropped_xretry);
 len += scnprintf(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n",
    htt_stats_buf->illgl_rate_phy_err);
 len += scnprintf(buf + len, buf_len - len, "cont_xretry = %u\n",
    htt_stats_buf->cont_xretry);
 len += scnprintf(buf + len, buf_len - len, "tx_timeout = %u\n",
    htt_stats_buf->tx_timeout);
 len += scnprintf(buf + len, buf_len - len, "pdev_resets = %u\n",
    htt_stats_buf->pdev_resets);
 len += scnprintf(buf + len, buf_len - len, "phy_underrun = %u\n",
    htt_stats_buf->phy_underrun);
 len += scnprintf(buf + len, buf_len - len, "txop_ovf = %u\n",
    htt_stats_buf->txop_ovf);
 len += scnprintf(buf + len, buf_len - len, "seq_posted = %u\n",
    htt_stats_buf->seq_posted);
 len += scnprintf(buf + len, buf_len - len, "seq_failed_queueing = %u\n",
    htt_stats_buf->seq_failed_queueing);
 len += scnprintf(buf + len, buf_len - len, "seq_completed = %u\n",
    htt_stats_buf->seq_completed);
 len += scnprintf(buf + len, buf_len - len, "seq_restarted = %u\n",
    htt_stats_buf->seq_restarted);
 len += scnprintf(buf + len, buf_len - len, "mu_seq_posted = %u\n",
    htt_stats_buf->mu_seq_posted);
 len += scnprintf(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n",
    htt_stats_buf->seq_switch_hw_paused);
 len += scnprintf(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n",
    htt_stats_buf->next_seq_posted_dsr);
 len += scnprintf(buf + len, buf_len - len, "seq_posted_isr = %u\n",
    htt_stats_buf->seq_posted_isr);
 len += scnprintf(buf + len, buf_len - len, "seq_ctrl_cached = %u\n",
    htt_stats_buf->seq_ctrl_cached);
 len += scnprintf(buf + len, buf_len - len, "mpdu_count_tqm = %u\n",
    htt_stats_buf->mpdu_count_tqm);
 len += scnprintf(buf + len, buf_len - len, "msdu_count_tqm = %u\n",
    htt_stats_buf->msdu_count_tqm);
 len += scnprintf(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n",
    htt_stats_buf->mpdu_removed_tqm);
 len += scnprintf(buf + len, buf_len - len, "msdu_removed_tqm = %u\n",
    htt_stats_buf->msdu_removed_tqm);
 len += scnprintf(buf + len, buf_len - len, "mpdus_sw_flush = %u\n",
    htt_stats_buf->mpdus_sw_flush);
 len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
    htt_stats_buf->mpdus_hw_filter);
 len += scnprintf(buf + len, buf_len - len, "mpdus_truncated = %u\n",
    htt_stats_buf->mpdus_truncated);
 len += scnprintf(buf + len, buf_len - len, "mpdus_ack_failed = %u\n",
    htt_stats_buf->mpdus_ack_failed);
 len += scnprintf(buf + len, buf_len - len, "mpdus_expired = %u\n",
    htt_stats_buf->mpdus_expired);
 len += scnprintf(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n",
    htt_stats_buf->mpdus_seq_hw_retry);
 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
    htt_stats_buf->ack_tlv_proc);
 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n",
    htt_stats_buf->coex_abort_mpdu_cnt_valid);
 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n",
    htt_stats_buf->coex_abort_mpdu_cnt);
 len += scnprintf(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n",
    htt_stats_buf->num_total_ppdus_tried_ota);
 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n",
    htt_stats_buf->num_data_ppdus_tried_ota);
 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n",
    htt_stats_buf->local_ctrl_mgmt_enqued);
 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n",
    htt_stats_buf->local_ctrl_mgmt_freed);
 len += scnprintf(buf + len, buf_len - len, "local_data_enqued = %u\n",
    htt_stats_buf->local_data_enqued);
 len += scnprintf(buf + len, buf_len - len, "local_data_freed = %u\n",
    htt_stats_buf->local_data_freed);
 len += scnprintf(buf + len, buf_len - len, "mpdu_tried = %u\n",
    htt_stats_buf->mpdu_tried);
 len += scnprintf(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n",
    htt_stats_buf->isr_wait_seq_posted);
 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n",
    htt_stats_buf->tx_active_dur_us_low);
 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n\n",
    htt_stats_buf->tx_active_dur_us_high);

 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 += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_URRN_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->urrn_stats, "urrn_stats",
      num_elems, "\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_FLUSH_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->flush_errs, "flush_errs",
      num_elems, "\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_SIFS_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_status, "sifs_status",
      num_elems, "\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_PHY_ERR_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_errs, "phy_errs",
      num_elems, "\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_PDEV_STATS_SIFS_HIST_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_hist_status,
      "sifs_hist_status", num_elems, "\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_PDEV_STATS_TX_PPDU_STATS_TLV_V:\n");

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

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

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

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

 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_ax_su_txbf = %u\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_PDEV_STATS_TRIED_MPDU_CNT_HIST_TLV_V:\n");
 len += scnprintf(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n",
    htt_stats_buf->hist_bin_size);

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist,
      "tried_mpdu_cnt_hist", num_elements, "\n\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] = {};

 len += scnprintf(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 += scnprintf(buf + len, buf_len - len, "hw_intr_name = %s\n", hw_intr_name);
 len += scnprintf(buf + len, buf_len - len, "mask = %u\n",
    htt_stats_buf->mask);
 len += scnprintf(buf + len, buf_len - len, "count = %u\n\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] = {};

 len += scnprintf(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 += scnprintf(buf + len, buf_len - len, "hw_module_name = %s\n",
    hw_module_name);
 len += scnprintf(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 += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
    FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n",
    htt_stats_buf->tx_abort);
 len += scnprintf(buf + len, buf_len - len, "tx_abort_fail_count = %u\n",
    htt_stats_buf->tx_abort_fail_count);
 len += scnprintf(buf + len, buf_len - len, "rx_abort = %u\n",
    htt_stats_buf->rx_abort);
 len += scnprintf(buf + len, buf_len - len, "rx_abort_fail_count = %u\n",
    htt_stats_buf->rx_abort_fail_count);
 len += scnprintf(buf + len, buf_len - len, "warm_reset = %u\n",
    htt_stats_buf->warm_reset);
 len += scnprintf(buf + len, buf_len - len, "cold_reset = %u\n",
    htt_stats_buf->cold_reset);
 len += scnprintf(buf + len, buf_len - len, "tx_flush = %u\n",
    htt_stats_buf->tx_flush);
 len += scnprintf(buf + len, buf_len - len, "tx_glb_reset = %u\n",
    htt_stats_buf->tx_glb_reset);
 len += scnprintf(buf + len, buf_len - len, "tx_txq_reset = %u\n",
    htt_stats_buf->tx_txq_reset);
 len += scnprintf(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n",
    htt_stats_buf->rx_timeout_reset);

 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 += scnprintf(buf + len, buf_len - len, "HTT_MSDU_FLOW_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "last_update_timestamp = %u\n",
    htt_stats_buf->last_update_timestamp);
 len += scnprintf(buf + len, buf_len - len, "last_add_timestamp = %u\n",
    htt_stats_buf->last_add_timestamp);
 len += scnprintf(buf + len, buf_len - len, "last_remove_timestamp = %u\n",
    htt_stats_buf->last_remove_timestamp);
 len += scnprintf(buf + len, buf_len - len, "total_processed_msdu_count = %u\n",
    htt_stats_buf->total_processed_msdu_count);
 len += scnprintf(buf + len, buf_len - len, "cur_msdu_count_in_flowq = %u\n",
    htt_stats_buf->cur_msdu_count_in_flowq);
 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n",
    htt_stats_buf->sw_peer_id);
 len += scnprintf(buf + len, buf_len - len, "tx_flow_no = %lu\n",
    FIELD_GET(HTT_MSDU_FLOW_STATS_TX_FLOW_NO,
       htt_stats_buf->tx_flow_no__tid_num__drop_rule));
 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
    FIELD_GET(HTT_MSDU_FLOW_STATS_TID_NUM,
       htt_stats_buf->tx_flow_no__tid_num__drop_rule));
 len += scnprintf(buf + len, buf_len - len, "drop_rule = %lu\n",
    FIELD_GET(HTT_MSDU_FLOW_STATS_DROP_RULE,
       htt_stats_buf->tx_flow_no__tid_num__drop_rule));
 len += scnprintf(buf + len, buf_len - len, "last_cycle_enqueue_count = %u\n",
    htt_stats_buf->last_cycle_enqueue_count);
 len += scnprintf(buf + len, buf_len - len, "last_cycle_dequeue_count = %u\n",
    htt_stats_buf->last_cycle_dequeue_count);
 len += scnprintf(buf + len, buf_len - len, "last_cycle_drop_count = %u\n",
    htt_stats_buf->last_cycle_drop_count);
 len += scnprintf(buf + len, buf_len - len, "current_drop_th = %u\n\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] = {};

 len += scnprintf(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 += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name);
 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_SW_PEER_ID,
       htt_stats_buf->sw_peer_id__tid_num));
 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_TID_NUM,
       htt_stats_buf->sw_peer_id__tid_num));
 len += scnprintf(buf + len, buf_len - len, "num_sched_pending = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_NUM_SCHED_PENDING,
       htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
 len += scnprintf(buf + len, buf_len - len, "num_ppdu_in_hwq = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_NUM_PPDU_IN_HWQ,
       htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
 len += scnprintf(buf + len, buf_len - len, "tid_flags = 0x%x\n",
    htt_stats_buf->tid_flags);
 len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n",
    htt_stats_buf->hw_queued);
 len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n",
    htt_stats_buf->hw_reaped);
 len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
    htt_stats_buf->mpdus_hw_filter);
 len += scnprintf(buf + len, buf_len - len, "qdepth_bytes = %u\n",
    htt_stats_buf->qdepth_bytes);
 len += scnprintf(buf + len, buf_len - len, "qdepth_num_msdu = %u\n",
    htt_stats_buf->qdepth_num_msdu);
 len += scnprintf(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n",
    htt_stats_buf->qdepth_num_mpdu);
 len += scnprintf(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n",
    htt_stats_buf->last_scheduled_tsmp);
 len += scnprintf(buf + len, buf_len - len, "pause_module_id = %u\n",
    htt_stats_buf->pause_module_id);
 len += scnprintf(buf + len, buf_len - len, "block_module_id = %u\n\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] = {};

 len += scnprintf(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 += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name);
 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_V1_SW_PEER_ID,
       htt_stats_buf->sw_peer_id__tid_num));
 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_V1_TID_NUM,
       htt_stats_buf->sw_peer_id__tid_num));
 len += scnprintf(buf + len, buf_len - len, "num_sched_pending = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_V1_NUM_SCHED_PENDING,
       htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
 len += scnprintf(buf + len, buf_len - len, "num_ppdu_in_hwq = %lu\n",
    FIELD_GET(HTT_TX_TID_STATS_V1_NUM_PPDU_IN_HWQ,
       htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
 len += scnprintf(buf + len, buf_len - len, "tid_flags = 0x%x\n",
    htt_stats_buf->tid_flags);
 len += scnprintf(buf + len, buf_len - len, "max_qdepth_bytes = %u\n",
    htt_stats_buf->max_qdepth_bytes);
 len += scnprintf(buf + len, buf_len - len, "max_qdepth_n_msdus = %u\n",
    htt_stats_buf->max_qdepth_n_msdus);
 len += scnprintf(buf + len, buf_len - len, "rsvd = %u\n",
    htt_stats_buf->rsvd);
 len += scnprintf(buf + len, buf_len - len, "qdepth_bytes = %u\n",
    htt_stats_buf->qdepth_bytes);
 len += scnprintf(buf + len, buf_len - len, "qdepth_num_msdu = %u\n",
    htt_stats_buf->qdepth_num_msdu);
 len += scnprintf(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n",
    htt_stats_buf->qdepth_num_mpdu);
 len += scnprintf(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n",
    htt_stats_buf->last_scheduled_tsmp);
 len += scnprintf(buf + len, buf_len - len, "pause_module_id = %u\n",
    htt_stats_buf->pause_module_id);
 len += scnprintf(buf + len, buf_len - len, "block_module_id = %u\n",
    htt_stats_buf->block_module_id);
 len += scnprintf(buf + len, buf_len - len, "allow_n_flags = 0x%x\n",
    htt_stats_buf->allow_n_flags);
 len += scnprintf(buf + len, buf_len - len, "sendn_frms_allowed = %u\n\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] = {};

 len += scnprintf(buf + len, buf_len - len, "HTT_RX_TID_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n",
    FIELD_GET(HTT_RX_TID_STATS_SW_PEER_ID,
       htt_stats_buf->sw_peer_id__tid_num));
 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
    FIELD_GET(HTT_RX_TID_STATS_TID_NUM,
       htt_stats_buf->sw_peer_id__tid_num));
 memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
 len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name);
 len += scnprintf(buf + len, buf_len - len, "dup_in_reorder = %u\n",
    htt_stats_buf->dup_in_reorder);
 len += scnprintf(buf + len, buf_len - len, "dup_past_outside_window = %u\n",
    htt_stats_buf->dup_past_outside_window);
 len += scnprintf(buf + len, buf_len - len, "dup_past_within_window = %u\n",
    htt_stats_buf->dup_past_within_window);
 len += scnprintf(buf + len, buf_len - len, "rxdesc_err_decrypt = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_COUNTER_TLV:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->counter_name,
      "counter_name",
      HTT_MAX_COUNTER_NAME, "\n");
 len += scnprintf(buf + len, buf_len - len, "count = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_PEER_STATS_CMN_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "ppdu_cnt = %u\n",
    htt_stats_buf->ppdu_cnt);
 len += scnprintf(buf + len, buf_len - len, "mpdu_cnt = %u\n",
    htt_stats_buf->mpdu_cnt);
 len += scnprintf(buf + len, buf_len - len, "msdu_cnt = %u\n",
    htt_stats_buf->msdu_cnt);
 len += scnprintf(buf + len, buf_len - len, "pause_bitmap = %u\n",
    htt_stats_buf->pause_bitmap);
 len += scnprintf(buf + len, buf_len - len, "block_bitmap = %u\n",
    htt_stats_buf->block_bitmap);
 len += scnprintf(buf + len, buf_len - len, "last_rssi = %d\n",
    htt_stats_buf->rssi);
 len += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len, "ttl_removed_count = %u\n",
    htt_stats_buf->peer_ttl_removed_count);
 len += scnprintf(buf + len, buf_len - len, "inactive_time = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_PEER_DETAILS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "peer_type = %u\n",
    htt_stats_buf->peer_type);
 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n",
    htt_stats_buf->sw_peer_id);
 len += scnprintf(buf + len, buf_len - len, "vdev_id = %lu\n",
    FIELD_GET(HTT_PEER_DETAILS_VDEV_ID,
       htt_stats_buf->vdev_pdev_ast_idx));
 len += scnprintf(buf + len, buf_len - len, "pdev_id = %lu\n",
    FIELD_GET(HTT_PEER_DETAILS_PDEV_ID,
       htt_stats_buf->vdev_pdev_ast_idx));
 len += scnprintf(buf + len, buf_len - len, "ast_idx = %lu\n",
    FIELD_GET(HTT_PEER_DETAILS_AST_IDX,
       htt_stats_buf->vdev_pdev_ast_idx));
 len += scnprintf(buf + len, buf_len - len,
    "mac_addr = %02lx:%02lx:%02lx:%02lx:%02lx:%02lx\n",
    FIELD_GET(HTT_MAC_ADDR_L32_0,
       htt_stats_buf->mac_addr.mac_addr_l32),
    FIELD_GET(HTT_MAC_ADDR_L32_1,
       htt_stats_buf->mac_addr.mac_addr_l32),
    FIELD_GET(HTT_MAC_ADDR_L32_2,
       htt_stats_buf->mac_addr.mac_addr_l32),
    FIELD_GET(HTT_MAC_ADDR_L32_3,
       htt_stats_buf->mac_addr.mac_addr_l32),
    FIELD_GET(HTT_MAC_ADDR_H16_0,
       htt_stats_buf->mac_addr.mac_addr_h16),
    FIELD_GET(HTT_MAC_ADDR_H16_1,
       htt_stats_buf->mac_addr.mac_addr_h16));
 len += scnprintf(buf + len, buf_len - len, "peer_flags = 0x%x\n",
    htt_stats_buf->peer_flags);
 len += scnprintf(buf + len, buf_len - len, "qpeer_flags = 0x%x\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_PEER_RATE_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n",
    htt_stats_buf->tx_ldpc);
 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
    htt_stats_buf->rts_cnt);
 len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n",
    htt_stats_buf->ack_rssi);

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs, "tx_mcs",
      HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_su_mcs, "tx_su_mcs",
      HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mu_mcs, "tx_mu_mcs",
      HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss, "tx_nss",
      HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw, "tx_bw",
      HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc, "tx_stbc",
      HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream, "tx_pream",
      HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");

 for (j = 0; j < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; j++) {
  len += scnprintf(buf + len, buf_len - len,
     "tx_gi[%u] = ", j);
  PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_gi[j], NULL,
       HTT_TX_PEER_STATS_NUM_MCS_COUNTERS, "\n");
 }

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm, "tx_dcm",
      HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\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 += scnprintf(buf + len, buf_len - len, "HTT_RX_PEER_RATE_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "nsts = %u\n",
    htt_stats_buf->nsts);
 len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n",
    htt_stats_buf->rx_ldpc);
 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
    htt_stats_buf->rts_cnt);
 len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n",
    htt_stats_buf->rssi_mgmt);
 len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n",
    htt_stats_buf->rssi_data);
 len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n",
    htt_stats_buf->rssi_comb);

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs, "rx_mcs",
      HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss, "rx_nss",
      HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm, "rx_dcm",
      HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc, "rx_stbc",
      HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw, "rx_bw",
      HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");

 for (j = 0; j < HTT_RX_PEER_STATS_NUM_SPATIAL_STREAMS; j++) {
  len += scnprintf(buf + len, (buf_len - len),
     "rssi_chain[%u] = ", j);
  PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain[j], NULL,
       HTT_RX_PEER_STATS_NUM_BW_COUNTERS, "\n");
 }

 for (j = 0; j < HTT_RX_PEER_STATS_NUM_GI_COUNTERS; j++) {
  len += scnprintf(buf + len, (buf_len - len),
     "rx_gi[%u] = ", j);
  PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi[j], NULL,
       HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
 }

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream, "rx_pream",
      HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_SCH_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
    htt_stats_buf->mu_mimo_sch_posted);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
    htt_stats_buf->mu_mimo_sch_failed);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_HWQ_MU_MIMO_MPDU_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_queued_usr = %u\n",
    htt_stats_buf->mu_mimo_mpdus_queued_usr);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_tried_usr = %u\n",
    htt_stats_buf->mu_mimo_mpdus_tried_usr);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_failed_usr = %u\n",
    htt_stats_buf->mu_mimo_mpdus_failed_usr);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_requeued_usr = %u\n",
    htt_stats_buf->mu_mimo_mpdus_requeued_usr);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_err_no_ba_usr = %u\n",
    htt_stats_buf->mu_mimo_err_no_ba_usr);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdu_underrun_usr = %u\n",
    htt_stats_buf->mu_mimo_mpdu_underrun_usr);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ampdu_underrun_usr = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_CMN_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
    FIELD_GET(HTT_TX_HWQ_STATS_MAC_ID,
       htt_stats_buf->mac_id__hwq_id__word));
 len += scnprintf(buf + len, buf_len - len, "hwq_id = %lu\n\n",
    FIELD_GET(HTT_TX_HWQ_STATS_HWQ_ID,
       htt_stats_buf->mac_id__hwq_id__word));

 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 += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_STATS_CMN_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
    FIELD_GET(HTT_TX_HWQ_STATS_MAC_ID,
       htt_stats_buf->mac_id__hwq_id__word));
 len += scnprintf(buf + len, buf_len - len, "hwq_id = %lu\n",
    FIELD_GET(HTT_TX_HWQ_STATS_HWQ_ID,
       htt_stats_buf->mac_id__hwq_id__word));
 len += scnprintf(buf + len, buf_len - len, "xretry = %u\n",
    htt_stats_buf->xretry);
 len += scnprintf(buf + len, buf_len - len, "underrun_cnt = %u\n",
    htt_stats_buf->underrun_cnt);
 len += scnprintf(buf + len, buf_len - len, "flush_cnt = %u\n",
    htt_stats_buf->flush_cnt);
 len += scnprintf(buf + len, buf_len - len, "filt_cnt = %u\n",
    htt_stats_buf->filt_cnt);
 len += scnprintf(buf + len, buf_len - len, "null_mpdu_bmap = %u\n",
    htt_stats_buf->null_mpdu_bmap);
 len += scnprintf(buf + len, buf_len - len, "user_ack_failure = %u\n",
    htt_stats_buf->user_ack_failure);
 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
    htt_stats_buf->ack_tlv_proc);
 len += scnprintf(buf + len, buf_len - len, "sched_id_proc = %u\n",
    htt_stats_buf->sched_id_proc);
 len += scnprintf(buf + len, buf_len - len, "null_mpdu_tx_count = %u\n",
    htt_stats_buf->null_mpdu_tx_count);
 len += scnprintf(buf + len, buf_len - len, "mpdu_bmap_not_recvd = %u\n",
    htt_stats_buf->mpdu_bmap_not_recvd);
 len += scnprintf(buf + len, buf_len - len, "num_bar = %u\n",
    htt_stats_buf->num_bar);
 len += scnprintf(buf + len, buf_len - len, "rts = %u\n",
    htt_stats_buf->rts);
 len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n",
    htt_stats_buf->cts2self);
 len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n",
    htt_stats_buf->qos_null);
 len += scnprintf(buf + len, buf_len - len, "mpdu_tried_cnt = %u\n",
    htt_stats_buf->mpdu_tried_cnt);
 len += scnprintf(buf + len, buf_len - len, "mpdu_queued_cnt = %u\n",
    htt_stats_buf->mpdu_queued_cnt);
 len += scnprintf(buf + len, buf_len - len, "mpdu_ack_fail_cnt = %u\n",
    htt_stats_buf->mpdu_ack_fail_cnt);
 len += scnprintf(buf + len, buf_len - len, "mpdu_filt_cnt = %u\n",
    htt_stats_buf->mpdu_filt_cnt);
 len += scnprintf(buf + len, buf_len - len, "false_mpdu_ack_count = %u\n",
    htt_stats_buf->false_mpdu_ack_count);
 len += scnprintf(buf + len, buf_len - len, "txq_timeout = %u\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_HWQ_DIFS_LATENCY_STATS_TLV_V:\n");
 len += scnprintf(buf + len, buf_len - len, "hist_intvl = %u\n",
    htt_stats_buf->hist_intvl);

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->difs_latency_hist,
      "difs_latency_hist", data_len, "\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_HWQ_CMD_RESULT_STATS_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_result, "cmd_result",
      data_len, "\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_CMD_STALL_STATS_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_stall_status,
      "cmd_stall_status", num_elems, "\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_HWQ_FES_RESULT_STATS_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fes_result, "fes_result",
      num_elems, "\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_HWQ_TRIED_MPDU_CNT_HIST_TLV_V:\n");
 len += scnprintf(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n",
    htt_stats_buf->hist_bin_size);

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist,
      "tried_mpdu_cnt_hist", num_elements, "\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_HWQ_TXOP_USED_CNT_HIST_TLV_V:\n");

 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->txop_used_cnt_hist,
      "txop_used_cnt_hist", num_elements, "\n\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 += scnprintf(buf + len, buf_len - len,
     "\nHTT_TX_AC_SOUNDING_STATS_TLV:\n\n");
  len += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len,
     "\nHTT_TX_AX_SOUNDING_STATS_TLV:\n");
  len += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
    FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
 len += scnprintf(buf + len, buf_len - len, "su_bar = %u\n",
    htt_stats_buf->su_bar);
 len += scnprintf(buf + len, buf_len - len, "rts = %u\n",
    htt_stats_buf->rts);
 len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n",
    htt_stats_buf->cts2self);
 len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n",
    htt_stats_buf->qos_null);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_1 = %u\n",
    htt_stats_buf->delayed_bar_1);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_2 = %u\n",
    htt_stats_buf->delayed_bar_2);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_3 = %u\n",
    htt_stats_buf->delayed_bar_3);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_4 = %u\n",
    htt_stats_buf->delayed_bar_4);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_5 = %u\n",
    htt_stats_buf->delayed_bar_5);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_6 = %u\n",
    htt_stats_buf->delayed_bar_6);
 len += scnprintf(buf + len, buf_len - len, "delayed_bar_7 = %u\n\n",
    htt_stats_buf->delayed_bar_7);

 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 += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa = %u\n",
    htt_stats_buf->ac_su_ndpa);
 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp = %u\n",
    htt_stats_buf->ac_su_ndp);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa = %u\n",
    htt_stats_buf->ac_mu_mimo_ndpa);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp = %u\n",
    htt_stats_buf->ac_mu_mimo_ndp);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_1 = %u\n",
    htt_stats_buf->ac_mu_mimo_brpoll_1);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_2 = %u\n",
    htt_stats_buf->ac_mu_mimo_brpoll_2);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_3 = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa = %u\n",
    htt_stats_buf->ax_su_ndpa);
 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp = %u\n",
    htt_stats_buf->ax_su_ndp);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa = %u\n",
    htt_stats_buf->ax_mu_mimo_ndpa);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp = %u\n",
    htt_stats_buf->ax_mu_mimo_ndp);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_1 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_1);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_2 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_2);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_3 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_3);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_4 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_4);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_5 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_5);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_6 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_6);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_7 = %u\n",
    htt_stats_buf->ax_mu_mimo_brpoll_7);
 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger = %u\n",
    htt_stats_buf->ax_basic_trigger);
 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_trigger = %u\n",
    htt_stats_buf->ax_ulmumimo_trigger);
 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger = %u\n",
    htt_stats_buf->ax_bsr_trigger);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n",
    htt_stats_buf->ax_mu_bar_trigger);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_err = %u\n",
    htt_stats_buf->ac_su_ndp_err);
 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n",
    htt_stats_buf->ac_su_ndpa_err);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n",
    htt_stats_buf->ac_mu_mimo_ndpa_err);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n",
    htt_stats_buf->ac_mu_mimo_ndp_err);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n",
    htt_stats_buf->ac_mu_mimo_brp1_err);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n",
    htt_stats_buf->ac_mu_mimo_brp2_err);
 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n",
    htt_stats_buf->ac_mu_mimo_brp3_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_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 += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_err = %u\n",
    htt_stats_buf->ax_su_ndp_err);
 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n",
    htt_stats_buf->ax_su_ndpa_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n",
    htt_stats_buf->ax_mu_mimo_ndpa_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n",
    htt_stats_buf->ax_mu_mimo_ndp_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp1_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp1_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp2_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp2_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp3_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp3_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp4_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp4_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp5_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp5_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp6_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp6_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp7_err = %u\n",
    htt_stats_buf->ax_mu_mimo_brp7_err);
 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger_err = %u\n",
    htt_stats_buf->ax_basic_trigger_err);
 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_trigger_err = %u\n",
    htt_stats_buf->ax_ulmumimo_trigger_err);
 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n",
    htt_stats_buf->ax_bsr_trigger_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n",
    htt_stats_buf->ax_mu_bar_trigger_err);
 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n\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 += scnprintf(buf + len, buf_len - len,
    "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n");
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
    htt_stats_buf->mu_mimo_sch_posted);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
    htt_stats_buf->mu_mimo_sch_failed);
 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n\n",
    htt_stats_buf->mu_mimo_ppdu_posted);

 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++)
  len += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len,
     "ac_mu_mimo_sch_nusers_%u = %u\n",
     i, htt_stats_buf->ac_mu_mimo_sch_nusers[i]);

 len += scnprintf(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 += scnprintf(buf + len, buf_len - len,
     "ax_mu_mimo_sch_nusers_%u = %u\n",
     i, htt_stats_buf->ax_mu_mimo_sch_nusers[i]);

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

 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
  len += scnprintf(buf + len, buf_len - len,
     "ax_ofdma_sch_nusers_%u = %u\n",
     i, htt_stats_buf->ax_ofdma_sch_nusers[i]);
  len += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len,
      "ac_mu_mimo_ampdu_underrun_usr_%u = %u\n\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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len,
      "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n\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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(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 += scnprintf(buf + len, buf_len - len,
      "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n\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 += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV_V:\n");

--> --------------------

--> maximum size reached

--> --------------------