FILE
debugfs_htt_stats.c
File preview with syntax highlighting.
linux-6.19.14/drivers/net/wireless/ath/ath12k/debugfs_htt_stats.c
1// SPDX-License-Identifier: BSD-3-Clause-Clear 2/* 3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 5 */ 6 7#include <linux/vmalloc.h> 8#include "core.h" 9#include "debug.h" 10#include "debugfs_htt_stats.h" 11#include "dp_tx.h" 12#include "dp_rx.h" 13 14static u32 15print_array_to_buf_index(u8 *buf, u32 offset, const char *header, u32 stats_index, 16 const __le32 *array, u32 array_len, const char *footer) 17{ 18 int index = 0; 19 u8 i; 20 21 if (header) { 22 index += scnprintf(buf + offset, 23 ATH12K_HTT_STATS_BUF_SIZE - offset, 24 "%s = ", header); 25 } 26 for (i = 0; i < array_len; i++) { 27 index += scnprintf(buf + offset + index, 28 (ATH12K_HTT_STATS_BUF_SIZE - offset) - index, 29 " %u:%u,", stats_index++, le32_to_cpu(array[i])); 30 } 31 /* To overwrite the last trailing comma */ 32 if (array_len > 0) { 33 index--; 34 *(buf + offset + index) = '\0'; 35 } 36 37 if (footer) { 38 index += scnprintf(buf + offset + index, 39 (ATH12K_HTT_STATS_BUF_SIZE - offset) - index, 40 "%s", footer); 41 } 42 return index; 43} 44 45static u32 46print_array_to_buf(u8 *buf, u32 offset, const char *header, 47 const __le32 *array, u32 array_len, const char *footer) 48{ 49 return print_array_to_buf_index(buf, offset, header, 0, array, array_len, 50 footer); 51} 52 53static u32 54print_array_to_buf_s8(u8 *buf, u32 offset, const char *header, u32 stats_index, 55 const s8 *array, u32 array_len, const char *footer) 56{ 57 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 58 int index = 0; 59 u8 i; 60 61 if (header) 62 index += scnprintf(buf + offset, buf_len - offset, "%s = ", header); 63 64 for (i = 0; i < array_len; i++) { 65 index += scnprintf(buf + offset + index, (buf_len - offset) - index, 66 " %u:%d,", stats_index++, array[i]); 67 } 68 69 index--; 70 if ((offset + index) < buf_len) 71 buf[offset + index] = '\0'; 72 73 if (footer) { 74 index += scnprintf(buf + offset + index, (buf_len - offset) - index, 75 "%s", footer); 76 } 77 78 return index; 79} 80 81static const char *ath12k_htt_ax_tx_rx_ru_size_to_str(u8 ru_size) 82{ 83 switch (ru_size) { 84 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_26: 85 return "26"; 86 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_52: 87 return "52"; 88 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_106: 89 return "106"; 90 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_242: 91 return "242"; 92 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_484: 93 return "484"; 94 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_996: 95 return "996"; 96 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_996x2: 97 return "996x2"; 98 default: 99 return "unknown"; 100 } 101} 102 103static const char *ath12k_htt_be_tx_rx_ru_size_to_str(u8 ru_size) 104{ 105 switch (ru_size) { 106 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_26: 107 return "26"; 108 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_52: 109 return "52"; 110 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_52_26: 111 return "52+26"; 112 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_106: 113 return "106"; 114 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_106_26: 115 return "106+26"; 116 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_242: 117 return "242"; 118 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_484: 119 return "484"; 120 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_484_242: 121 return "484+242"; 122 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996: 123 return "996"; 124 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996_484: 125 return "996+484"; 126 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996_484_242: 127 return "996+484+242"; 128 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x2: 129 return "996x2"; 130 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x2_484: 131 return "996x2+484"; 132 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x3: 133 return "996x3"; 134 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x3_484: 135 return "996x3+484"; 136 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x4: 137 return "996x4"; 138 default: 139 return "unknown"; 140 } 141} 142 143static const char* 144ath12k_tx_ru_size_to_str(enum ath12k_htt_stats_ru_type ru_type, u8 ru_size) 145{ 146 if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY) 147 return ath12k_htt_ax_tx_rx_ru_size_to_str(ru_size); 148 else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU) 149 return ath12k_htt_be_tx_rx_ru_size_to_str(ru_size); 150 else 151 return "unknown"; 152} 153 154static void 155htt_print_tx_pdev_stats_cmn_tlv(const void *tag_buf, u16 tag_len, 156 struct debug_htt_stats_req *stats_req) 157{ 158 const struct ath12k_htt_tx_pdev_stats_cmn_tlv *htt_stats_buf = tag_buf; 159 u8 *buf = stats_req->buf; 160 u32 len = stats_req->buf_len; 161 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 162 u32 mac_id_word; 163 164 if (tag_len < sizeof(*htt_stats_buf)) 165 return; 166 167 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 168 169 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n"); 170 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 171 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 172 len += scnprintf(buf + len, buf_len - len, "comp_delivered = %u\n", 173 le32_to_cpu(htt_stats_buf->comp_delivered)); 174 len += scnprintf(buf + len, buf_len - len, "self_triggers = %u\n", 175 le32_to_cpu(htt_stats_buf->self_triggers)); 176 len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n", 177 le32_to_cpu(htt_stats_buf->hw_queued)); 178 len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n", 179 le32_to_cpu(htt_stats_buf->hw_reaped)); 180 len += scnprintf(buf + len, buf_len - len, "underrun = %u\n", 181 le32_to_cpu(htt_stats_buf->underrun)); 182 len += scnprintf(buf + len, buf_len - len, "hw_paused = %u\n", 183 le32_to_cpu(htt_stats_buf->hw_paused)); 184 len += scnprintf(buf + len, buf_len - len, "hw_flush = %u\n", 185 le32_to_cpu(htt_stats_buf->hw_flush)); 186 len += scnprintf(buf + len, buf_len - len, "hw_filt = %u\n", 187 le32_to_cpu(htt_stats_buf->hw_filt)); 188 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n", 189 le32_to_cpu(htt_stats_buf->tx_abort)); 190 len += scnprintf(buf + len, buf_len - len, "ppdu_ok = %u\n", 191 le32_to_cpu(htt_stats_buf->ppdu_ok)); 192 len += scnprintf(buf + len, buf_len - len, "mpdu_requeued = %u\n", 193 le32_to_cpu(htt_stats_buf->mpdu_requed)); 194 len += scnprintf(buf + len, buf_len - len, "tx_xretry = %u\n", 195 le32_to_cpu(htt_stats_buf->tx_xretry)); 196 len += scnprintf(buf + len, buf_len - len, "data_rc = %u\n", 197 le32_to_cpu(htt_stats_buf->data_rc)); 198 len += scnprintf(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n", 199 le32_to_cpu(htt_stats_buf->mpdu_dropped_xretry)); 200 len += scnprintf(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n", 201 le32_to_cpu(htt_stats_buf->illgl_rate_phy_err)); 202 len += scnprintf(buf + len, buf_len - len, "cont_xretry = %u\n", 203 le32_to_cpu(htt_stats_buf->cont_xretry)); 204 len += scnprintf(buf + len, buf_len - len, "tx_timeout = %u\n", 205 le32_to_cpu(htt_stats_buf->tx_timeout)); 206 len += scnprintf(buf + len, buf_len - len, "tx_time_dur_data = %u\n", 207 le32_to_cpu(htt_stats_buf->tx_time_dur_data)); 208 len += scnprintf(buf + len, buf_len - len, "pdev_resets = %u\n", 209 le32_to_cpu(htt_stats_buf->pdev_resets)); 210 len += scnprintf(buf + len, buf_len - len, "phy_underrun = %u\n", 211 le32_to_cpu(htt_stats_buf->phy_underrun)); 212 len += scnprintf(buf + len, buf_len - len, "txop_ovf = %u\n", 213 le32_to_cpu(htt_stats_buf->txop_ovf)); 214 len += scnprintf(buf + len, buf_len - len, "seq_posted = %u\n", 215 le32_to_cpu(htt_stats_buf->seq_posted)); 216 len += scnprintf(buf + len, buf_len - len, "seq_failed_queueing = %u\n", 217 le32_to_cpu(htt_stats_buf->seq_failed_queueing)); 218 len += scnprintf(buf + len, buf_len - len, "seq_completed = %u\n", 219 le32_to_cpu(htt_stats_buf->seq_completed)); 220 len += scnprintf(buf + len, buf_len - len, "seq_restarted = %u\n", 221 le32_to_cpu(htt_stats_buf->seq_restarted)); 222 len += scnprintf(buf + len, buf_len - len, "seq_txop_repost_stop = %u\n", 223 le32_to_cpu(htt_stats_buf->seq_txop_repost_stop)); 224 len += scnprintf(buf + len, buf_len - len, "next_seq_cancel = %u\n", 225 le32_to_cpu(htt_stats_buf->next_seq_cancel)); 226 len += scnprintf(buf + len, buf_len - len, "dl_mu_mimo_seq_posted = %u\n", 227 le32_to_cpu(htt_stats_buf->mu_seq_posted)); 228 len += scnprintf(buf + len, buf_len - len, "dl_mu_ofdma_seq_posted = %u\n", 229 le32_to_cpu(htt_stats_buf->mu_ofdma_seq_posted)); 230 len += scnprintf(buf + len, buf_len - len, "ul_mu_mimo_seq_posted = %u\n", 231 le32_to_cpu(htt_stats_buf->ul_mumimo_seq_posted)); 232 len += scnprintf(buf + len, buf_len - len, "ul_mu_ofdma_seq_posted = %u\n", 233 le32_to_cpu(htt_stats_buf->ul_ofdma_seq_posted)); 234 len += scnprintf(buf + len, buf_len - len, "mu_mimo_peer_blacklisted = %u\n", 235 le32_to_cpu(htt_stats_buf->num_mu_peer_blacklisted)); 236 len += scnprintf(buf + len, buf_len - len, "seq_qdepth_repost_stop = %u\n", 237 le32_to_cpu(htt_stats_buf->seq_qdepth_repost_stop)); 238 len += scnprintf(buf + len, buf_len - len, "seq_min_msdu_repost_stop = %u\n", 239 le32_to_cpu(htt_stats_buf->seq_min_msdu_repost_stop)); 240 len += scnprintf(buf + len, buf_len - len, "mu_seq_min_msdu_repost_stop = %u\n", 241 le32_to_cpu(htt_stats_buf->mu_seq_min_msdu_repost_stop)); 242 len += scnprintf(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n", 243 le32_to_cpu(htt_stats_buf->seq_switch_hw_paused)); 244 len += scnprintf(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n", 245 le32_to_cpu(htt_stats_buf->next_seq_posted_dsr)); 246 len += scnprintf(buf + len, buf_len - len, "seq_posted_isr = %u\n", 247 le32_to_cpu(htt_stats_buf->seq_posted_isr)); 248 len += scnprintf(buf + len, buf_len - len, "seq_ctrl_cached = %u\n", 249 le32_to_cpu(htt_stats_buf->seq_ctrl_cached)); 250 len += scnprintf(buf + len, buf_len - len, "mpdu_count_tqm = %u\n", 251 le32_to_cpu(htt_stats_buf->mpdu_count_tqm)); 252 len += scnprintf(buf + len, buf_len - len, "msdu_count_tqm = %u\n", 253 le32_to_cpu(htt_stats_buf->msdu_count_tqm)); 254 len += scnprintf(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n", 255 le32_to_cpu(htt_stats_buf->mpdu_removed_tqm)); 256 len += scnprintf(buf + len, buf_len - len, "msdu_removed_tqm = %u\n", 257 le32_to_cpu(htt_stats_buf->msdu_removed_tqm)); 258 len += scnprintf(buf + len, buf_len - len, "remove_mpdus_max_retries = %u\n", 259 le32_to_cpu(htt_stats_buf->remove_mpdus_max_retries)); 260 len += scnprintf(buf + len, buf_len - len, "mpdus_sw_flush = %u\n", 261 le32_to_cpu(htt_stats_buf->mpdus_sw_flush)); 262 len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n", 263 le32_to_cpu(htt_stats_buf->mpdus_hw_filter)); 264 len += scnprintf(buf + len, buf_len - len, "mpdus_truncated = %u\n", 265 le32_to_cpu(htt_stats_buf->mpdus_truncated)); 266 len += scnprintf(buf + len, buf_len - len, "mpdus_ack_failed = %u\n", 267 le32_to_cpu(htt_stats_buf->mpdus_ack_failed)); 268 len += scnprintf(buf + len, buf_len - len, "mpdus_expired = %u\n", 269 le32_to_cpu(htt_stats_buf->mpdus_expired)); 270 len += scnprintf(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n", 271 le32_to_cpu(htt_stats_buf->mpdus_seq_hw_retry)); 272 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 273 le32_to_cpu(htt_stats_buf->ack_tlv_proc)); 274 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n", 275 le32_to_cpu(htt_stats_buf->coex_abort_mpdu_cnt_valid)); 276 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n", 277 le32_to_cpu(htt_stats_buf->coex_abort_mpdu_cnt)); 278 len += scnprintf(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n", 279 le32_to_cpu(htt_stats_buf->num_total_ppdus_tried_ota)); 280 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n", 281 le32_to_cpu(htt_stats_buf->num_data_ppdus_tried_ota)); 282 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n", 283 le32_to_cpu(htt_stats_buf->local_ctrl_mgmt_enqued)); 284 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n", 285 le32_to_cpu(htt_stats_buf->local_ctrl_mgmt_freed)); 286 len += scnprintf(buf + len, buf_len - len, "local_data_enqued = %u\n", 287 le32_to_cpu(htt_stats_buf->local_data_enqued)); 288 len += scnprintf(buf + len, buf_len - len, "local_data_freed = %u\n", 289 le32_to_cpu(htt_stats_buf->local_data_freed)); 290 len += scnprintf(buf + len, buf_len - len, "mpdu_tried = %u\n", 291 le32_to_cpu(htt_stats_buf->mpdu_tried)); 292 len += scnprintf(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n", 293 le32_to_cpu(htt_stats_buf->isr_wait_seq_posted)); 294 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n", 295 le32_to_cpu(htt_stats_buf->tx_active_dur_us_low)); 296 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n", 297 le32_to_cpu(htt_stats_buf->tx_active_dur_us_high)); 298 len += scnprintf(buf + len, buf_len - len, "fes_offsets_err_cnt = %u\n\n", 299 le32_to_cpu(htt_stats_buf->fes_offsets_err_cnt)); 300 301 stats_req->buf_len = len; 302} 303 304static void 305htt_print_tx_pdev_stats_urrn_tlv(const void *tag_buf, 306 u16 tag_len, 307 struct debug_htt_stats_req *stats_req) 308{ 309 const struct ath12k_htt_tx_pdev_stats_urrn_tlv *htt_stats_buf = tag_buf; 310 u8 *buf = stats_req->buf; 311 u32 len = stats_req->buf_len; 312 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 313 u16 num_elems = min_t(u16, (tag_len >> 2), 314 HTT_TX_PDEV_MAX_URRN_STATS); 315 316 len += scnprintf(buf + len, buf_len - len, 317 "HTT_TX_PDEV_STATS_URRN_TLV:\n"); 318 319 len += print_array_to_buf(buf, len, "urrn_stats", htt_stats_buf->urrn_stats, 320 num_elems, "\n\n"); 321 322 stats_req->buf_len = len; 323} 324 325static void 326htt_print_tx_pdev_stats_flush_tlv(const void *tag_buf, 327 u16 tag_len, 328 struct debug_htt_stats_req *stats_req) 329{ 330 const struct ath12k_htt_tx_pdev_stats_flush_tlv *htt_stats_buf = tag_buf; 331 u8 *buf = stats_req->buf; 332 u32 len = stats_req->buf_len; 333 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 334 u16 num_elems = min_t(u16, (tag_len >> 2), 335 ATH12K_HTT_TX_PDEV_MAX_FLUSH_REASON_STATS); 336 337 len += scnprintf(buf + len, buf_len - len, 338 "HTT_TX_PDEV_STATS_FLUSH_TLV:\n"); 339 340 len += print_array_to_buf(buf, len, "flush_errs", htt_stats_buf->flush_errs, 341 num_elems, "\n\n"); 342 343 stats_req->buf_len = len; 344} 345 346static void 347htt_print_tx_pdev_stats_sifs_tlv(const void *tag_buf, 348 u16 tag_len, 349 struct debug_htt_stats_req *stats_req) 350{ 351 const struct ath12k_htt_tx_pdev_stats_sifs_tlv *htt_stats_buf = tag_buf; 352 u8 *buf = stats_req->buf; 353 u32 len = stats_req->buf_len; 354 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 355 u16 num_elems = min_t(u16, (tag_len >> 2), 356 ATH12K_HTT_TX_PDEV_MAX_SIFS_BURST_STATS); 357 358 len += scnprintf(buf + len, buf_len - len, 359 "HTT_TX_PDEV_STATS_SIFS_TLV:\n"); 360 361 len += print_array_to_buf(buf, len, "sifs_status", htt_stats_buf->sifs_status, 362 num_elems, "\n\n"); 363 364 stats_req->buf_len = len; 365} 366 367static void 368htt_print_tx_pdev_mu_ppdu_dist_stats_tlv(const void *tag_buf, u16 tag_len, 369 struct debug_htt_stats_req *stats_req) 370{ 371 const struct ath12k_htt_tx_pdev_mu_ppdu_dist_stats_tlv *htt_stats_buf = tag_buf; 372 char *mode; 373 u8 j, hw_mode, i, str_buf_len; 374 u8 *buf = stats_req->buf; 375 u32 len = stats_req->buf_len; 376 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 377 u32 stats_value; 378 u8 max_ppdu = ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST; 379 u8 max_sched = ATH12K_HTT_STATS_MAX_NUM_SCHED_STATUS; 380 char str_buf[ATH12K_HTT_MAX_STRING_LEN]; 381 382 if (tag_len < sizeof(*htt_stats_buf)) 383 return; 384 385 hw_mode = le32_to_cpu(htt_stats_buf->hw_mode); 386 387 switch (hw_mode) { 388 case ATH12K_HTT_STATS_HWMODE_AC: 389 len += scnprintf(buf + len, buf_len - len, 390 "HTT_TX_PDEV_AC_MU_PPDU_DISTRIBUTION_STATS:\n"); 391 mode = "ac"; 392 break; 393 case ATH12K_HTT_STATS_HWMODE_AX: 394 len += scnprintf(buf + len, buf_len - len, 395 "HTT_TX_PDEV_AX_MU_PPDU_DISTRIBUTION_STATS:\n"); 396 mode = "ax"; 397 break; 398 case ATH12K_HTT_STATS_HWMODE_BE: 399 len += scnprintf(buf + len, buf_len - len, 400 "HTT_TX_PDEV_BE_MU_PPDU_DISTRIBUTION_STATS:\n"); 401 mode = "be"; 402 break; 403 default: 404 return; 405 } 406 407 for (i = 0; i < ATH12K_HTT_STATS_NUM_NR_BINS ; i++) { 408 len += scnprintf(buf + len, buf_len - len, 409 "%s_mu_mimo_num_seq_posted_nr%u = %u\n", mode, 410 ((i + 1) * 4), htt_stats_buf->num_seq_posted[i]); 411 str_buf_len = 0; 412 memset(str_buf, 0x0, sizeof(str_buf)); 413 for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST ; j++) { 414 stats_value = le32_to_cpu(htt_stats_buf->num_ppdu_posted_per_burst 415 [i * max_ppdu + j]); 416 str_buf_len += scnprintf(&str_buf[str_buf_len], 417 ATH12K_HTT_MAX_STRING_LEN - str_buf_len, 418 " %u:%u,", j, stats_value); 419 } 420 /* To overwrite the last trailing comma */ 421 str_buf[str_buf_len - 1] = '\0'; 422 len += scnprintf(buf + len, buf_len - len, 423 "%s_mu_mimo_num_ppdu_posted_per_burst_nr%u = %s\n", 424 mode, ((i + 1) * 4), str_buf); 425 str_buf_len = 0; 426 memset(str_buf, 0x0, sizeof(str_buf)); 427 for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST ; j++) { 428 stats_value = le32_to_cpu(htt_stats_buf->num_ppdu_cmpl_per_burst 429 [i * max_ppdu + j]); 430 str_buf_len += scnprintf(&str_buf[str_buf_len], 431 ATH12K_HTT_MAX_STRING_LEN - str_buf_len, 432 " %u:%u,", j, stats_value); 433 } 434 /* To overwrite the last trailing comma */ 435 str_buf[str_buf_len - 1] = '\0'; 436 len += scnprintf(buf + len, buf_len - len, 437 "%s_mu_mimo_num_ppdu_completed_per_burst_nr%u = %s\n", 438 mode, ((i + 1) * 4), str_buf); 439 str_buf_len = 0; 440 memset(str_buf, 0x0, sizeof(str_buf)); 441 for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_SCHED_STATUS ; j++) { 442 stats_value = le32_to_cpu(htt_stats_buf->num_seq_term_status 443 [i * max_sched + j]); 444 str_buf_len += scnprintf(&str_buf[str_buf_len], 445 ATH12K_HTT_MAX_STRING_LEN - str_buf_len, 446 " %u:%u,", j, stats_value); 447 } 448 /* To overwrite the last trailing comma */ 449 str_buf[str_buf_len - 1] = '\0'; 450 len += scnprintf(buf + len, buf_len - len, 451 "%s_mu_mimo_num_seq_term_status_nr%u = %s\n\n", 452 mode, ((i + 1) * 4), str_buf); 453 } 454 455 stats_req->buf_len = len; 456} 457 458static void 459htt_print_tx_pdev_stats_sifs_hist_tlv(const void *tag_buf, 460 u16 tag_len, 461 struct debug_htt_stats_req *stats_req) 462{ 463 const struct ath12k_htt_tx_pdev_stats_sifs_hist_tlv *htt_stats_buf = tag_buf; 464 u8 *buf = stats_req->buf; 465 u32 len = stats_req->buf_len; 466 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 467 u16 num_elems = min_t(u16, (tag_len >> 2), 468 ATH12K_HTT_TX_PDEV_MAX_SIFS_BURST_HIST_STATS); 469 470 len += scnprintf(buf + len, buf_len - len, 471 "HTT_TX_PDEV_STATS_SIFS_HIST_TLV:\n"); 472 473 len += print_array_to_buf(buf, len, "sifs_hist_status", 474 htt_stats_buf->sifs_hist_status, num_elems, "\n\n"); 475 476 stats_req->buf_len = len; 477} 478 479static void 480htt_print_pdev_ctrl_path_tx_stats_tlv(const void *tag_buf, u16 tag_len, 481 struct debug_htt_stats_req *stats_req) 482{ 483 const struct ath12k_htt_pdev_ctrl_path_tx_stats_tlv *htt_stats_buf = tag_buf; 484 u8 *buf = stats_req->buf; 485 u32 len = stats_req->buf_len; 486 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 487 488 if (len < sizeof(*htt_stats_buf)) 489 return; 490 491 len += scnprintf(buf + len, buf_len - len, 492 "HTT_TX_PDEV_STATS_CTRL_PATH_TX_STATS:\n"); 493 len += print_array_to_buf(buf, len, "fw_tx_mgmt_subtype", 494 htt_stats_buf->fw_tx_mgmt_subtype, 495 ATH12K_HTT_STATS_SUBTYPE_MAX, "\n\n"); 496 497 stats_req->buf_len = len; 498} 499 500static void 501ath12k_htt_print_stats_tx_sched_cmn_tlv(const void *tag_buf, 502 u16 tag_len, 503 struct debug_htt_stats_req *stats_req) 504{ 505 const struct ath12k_htt_stats_tx_sched_cmn_tlv *htt_stats_buf = tag_buf; 506 u8 *buf = stats_req->buf; 507 u32 len = stats_req->buf_len; 508 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 509 u32 mac_id_word; 510 511 if (tag_len < sizeof(*htt_stats_buf)) 512 return; 513 514 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 515 516 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_TX_SCHED_CMN_TLV:\n"); 517 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 518 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 519 len += scnprintf(buf + len, buf_len - len, "current_timestamp = %u\n\n", 520 le32_to_cpu(htt_stats_buf->current_timestamp)); 521 522 stats_req->buf_len = len; 523} 524 525static void 526ath12k_htt_print_tx_pdev_stats_sched_per_txq_tlv(const void *tag_buf, 527 u16 tag_len, 528 struct debug_htt_stats_req *stats_req) 529{ 530 const struct ath12k_htt_tx_pdev_stats_sched_per_txq_tlv *htt_stats_buf = tag_buf; 531 u8 *buf = stats_req->buf; 532 u32 len = stats_req->buf_len; 533 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 534 u32 mac_id_word; 535 536 if (tag_len < sizeof(*htt_stats_buf)) 537 return; 538 539 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 540 541 len += scnprintf(buf + len, buf_len - len, 542 "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:\n"); 543 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 544 u32_get_bits(mac_id_word, 545 ATH12K_HTT_TX_PDEV_STATS_SCHED_PER_TXQ_MAC_ID)); 546 len += scnprintf(buf + len, buf_len - len, "txq_id = %u\n", 547 u32_get_bits(mac_id_word, 548 ATH12K_HTT_TX_PDEV_STATS_SCHED_PER_TXQ_ID)); 549 len += scnprintf(buf + len, buf_len - len, "sched_policy = %u\n", 550 le32_to_cpu(htt_stats_buf->sched_policy)); 551 len += scnprintf(buf + len, buf_len - len, 552 "last_sched_cmd_posted_timestamp = %u\n", 553 le32_to_cpu(htt_stats_buf->last_sched_cmd_posted_timestamp)); 554 len += scnprintf(buf + len, buf_len - len, 555 "last_sched_cmd_compl_timestamp = %u\n", 556 le32_to_cpu(htt_stats_buf->last_sched_cmd_compl_timestamp)); 557 len += scnprintf(buf + len, buf_len - len, "sched_2_tac_lwm_count = %u\n", 558 le32_to_cpu(htt_stats_buf->sched_2_tac_lwm_count)); 559 len += scnprintf(buf + len, buf_len - len, "sched_2_tac_ring_full = %u\n", 560 le32_to_cpu(htt_stats_buf->sched_2_tac_ring_full)); 561 len += scnprintf(buf + len, buf_len - len, "sched_cmd_post_failure = %u\n", 562 le32_to_cpu(htt_stats_buf->sched_cmd_post_failure)); 563 len += scnprintf(buf + len, buf_len - len, "num_active_tids = %u\n", 564 le32_to_cpu(htt_stats_buf->num_active_tids)); 565 len += scnprintf(buf + len, buf_len - len, "num_ps_schedules = %u\n", 566 le32_to_cpu(htt_stats_buf->num_ps_schedules)); 567 len += scnprintf(buf + len, buf_len - len, "sched_cmds_pending = %u\n", 568 le32_to_cpu(htt_stats_buf->sched_cmds_pending)); 569 len += scnprintf(buf + len, buf_len - len, "num_tid_register = %u\n", 570 le32_to_cpu(htt_stats_buf->num_tid_register)); 571 len += scnprintf(buf + len, buf_len - len, "num_tid_unregister = %u\n", 572 le32_to_cpu(htt_stats_buf->num_tid_unregister)); 573 len += scnprintf(buf + len, buf_len - len, "num_qstats_queried = %u\n", 574 le32_to_cpu(htt_stats_buf->num_qstats_queried)); 575 len += scnprintf(buf + len, buf_len - len, "qstats_update_pending = %u\n", 576 le32_to_cpu(htt_stats_buf->qstats_update_pending)); 577 len += scnprintf(buf + len, buf_len - len, "last_qstats_query_timestamp = %u\n", 578 le32_to_cpu(htt_stats_buf->last_qstats_query_timestamp)); 579 len += scnprintf(buf + len, buf_len - len, "num_tqm_cmdq_full = %u\n", 580 le32_to_cpu(htt_stats_buf->num_tqm_cmdq_full)); 581 len += scnprintf(buf + len, buf_len - len, "num_de_sched_algo_trigger = %u\n", 582 le32_to_cpu(htt_stats_buf->num_de_sched_algo_trigger)); 583 len += scnprintf(buf + len, buf_len - len, "num_rt_sched_algo_trigger = %u\n", 584 le32_to_cpu(htt_stats_buf->num_rt_sched_algo_trigger)); 585 len += scnprintf(buf + len, buf_len - len, "num_tqm_sched_algo_trigger = %u\n", 586 le32_to_cpu(htt_stats_buf->num_tqm_sched_algo_trigger)); 587 len += scnprintf(buf + len, buf_len - len, "notify_sched = %u\n", 588 le32_to_cpu(htt_stats_buf->notify_sched)); 589 len += scnprintf(buf + len, buf_len - len, "dur_based_sendn_term = %u\n", 590 le32_to_cpu(htt_stats_buf->dur_based_sendn_term)); 591 len += scnprintf(buf + len, buf_len - len, "su_notify2_sched = %u\n", 592 le32_to_cpu(htt_stats_buf->su_notify2_sched)); 593 len += scnprintf(buf + len, buf_len - len, "su_optimal_queued_msdus_sched = %u\n", 594 le32_to_cpu(htt_stats_buf->su_optimal_queued_msdus_sched)); 595 len += scnprintf(buf + len, buf_len - len, "su_delay_timeout_sched = %u\n", 596 le32_to_cpu(htt_stats_buf->su_delay_timeout_sched)); 597 len += scnprintf(buf + len, buf_len - len, "su_min_txtime_sched_delay = %u\n", 598 le32_to_cpu(htt_stats_buf->su_min_txtime_sched_delay)); 599 len += scnprintf(buf + len, buf_len - len, "su_no_delay = %u\n", 600 le32_to_cpu(htt_stats_buf->su_no_delay)); 601 len += scnprintf(buf + len, buf_len - len, "num_supercycles = %u\n", 602 le32_to_cpu(htt_stats_buf->num_supercycles)); 603 len += scnprintf(buf + len, buf_len - len, "num_subcycles_with_sort = %u\n", 604 le32_to_cpu(htt_stats_buf->num_subcycles_with_sort)); 605 len += scnprintf(buf + len, buf_len - len, "num_subcycles_no_sort = %u\n\n", 606 le32_to_cpu(htt_stats_buf->num_subcycles_no_sort)); 607 608 stats_req->buf_len = len; 609} 610 611static void 612ath12k_htt_print_sched_txq_cmd_posted_tlv(const void *tag_buf, 613 u16 tag_len, 614 struct debug_htt_stats_req *stats_req) 615{ 616 const struct ath12k_htt_sched_txq_cmd_posted_tlv *htt_stats_buf = tag_buf; 617 u8 *buf = stats_req->buf; 618 u32 len = stats_req->buf_len; 619 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 620 u16 num_elements = tag_len >> 2; 621 622 len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV:\n"); 623 len += print_array_to_buf(buf, len, "sched_cmd_posted", 624 htt_stats_buf->sched_cmd_posted, num_elements, "\n\n"); 625 626 stats_req->buf_len = len; 627} 628 629static void 630ath12k_htt_print_sched_txq_cmd_reaped_tlv(const void *tag_buf, 631 u16 tag_len, 632 struct debug_htt_stats_req *stats_req) 633{ 634 const struct ath12k_htt_sched_txq_cmd_reaped_tlv *htt_stats_buf = tag_buf; 635 u8 *buf = stats_req->buf; 636 u32 len = stats_req->buf_len; 637 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 638 u16 num_elements = tag_len >> 2; 639 640 len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_REAPED_TLV:\n"); 641 len += print_array_to_buf(buf, len, "sched_cmd_reaped", 642 htt_stats_buf->sched_cmd_reaped, num_elements, "\n\n"); 643 644 stats_req->buf_len = len; 645} 646 647static void 648ath12k_htt_print_sched_txq_sched_order_su_tlv(const void *tag_buf, 649 u16 tag_len, 650 struct debug_htt_stats_req *stats_req) 651{ 652 const struct ath12k_htt_sched_txq_sched_order_su_tlv *htt_stats_buf = tag_buf; 653 u8 *buf = stats_req->buf; 654 u32 len = stats_req->buf_len; 655 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 656 u32 sched_order_su_num_entries = min_t(u32, (tag_len >> 2), 657 ATH12K_HTT_TX_PDEV_NUM_SCHED_ORDER_LOG); 658 659 len += scnprintf(buf + len, buf_len - len, 660 "HTT_SCHED_TXQ_SCHED_ORDER_SU_TLV:\n"); 661 len += print_array_to_buf(buf, len, "sched_order_su", 662 htt_stats_buf->sched_order_su, 663 sched_order_su_num_entries, "\n\n"); 664 665 stats_req->buf_len = len; 666} 667 668static void 669ath12k_htt_print_sched_txq_sched_ineligibility_tlv(const void *tag_buf, 670 u16 tag_len, 671 struct debug_htt_stats_req *stats_req) 672{ 673 const struct ath12k_htt_sched_txq_sched_ineligibility_tlv *htt_stats_buf = 674 tag_buf; 675 u8 *buf = stats_req->buf; 676 u32 len = stats_req->buf_len; 677 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 678 u32 sched_ineligibility_num_entries = tag_len >> 2; 679 680 len += scnprintf(buf + len, buf_len - len, 681 "HTT_SCHED_TXQ_SCHED_INELIGIBILITY:\n"); 682 len += print_array_to_buf(buf, len, "sched_ineligibility", 683 htt_stats_buf->sched_ineligibility, 684 sched_ineligibility_num_entries, "\n\n"); 685 686 stats_req->buf_len = len; 687} 688 689static void 690ath12k_htt_print_sched_txq_supercycle_trigger_tlv(const void *tag_buf, 691 u16 tag_len, 692 struct debug_htt_stats_req *stats_req) 693{ 694 const struct ath12k_htt_sched_txq_supercycle_triggers_tlv *htt_stats_buf = 695 tag_buf; 696 u8 *buf = stats_req->buf; 697 u32 len = stats_req->buf_len; 698 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 699 u16 num_elems = min_t(u16, (tag_len >> 2), 700 ATH12K_HTT_SCHED_SUPERCYCLE_TRIGGER_MAX); 701 702 len += scnprintf(buf + len, buf_len - len, 703 "HTT_SCHED_TXQ_SUPERCYCLE_TRIGGER:\n"); 704 len += print_array_to_buf(buf, len, "supercycle_triggers", 705 htt_stats_buf->supercycle_triggers, num_elems, "\n\n"); 706 707 stats_req->buf_len = len; 708} 709 710static void 711ath12k_htt_print_hw_stats_pdev_errs_tlv(const void *tag_buf, u16 tag_len, 712 struct debug_htt_stats_req *stats_req) 713{ 714 const struct ath12k_htt_hw_stats_pdev_errs_tlv *htt_buf = tag_buf; 715 u8 *buf = stats_req->buf; 716 u32 len = stats_req->buf_len; 717 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 718 u32 mac_id_word; 719 720 if (tag_len < sizeof(*htt_buf)) 721 return; 722 723 mac_id_word = le32_to_cpu(htt_buf->mac_id__word); 724 725 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n"); 726 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 727 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 728 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n", 729 le32_to_cpu(htt_buf->tx_abort)); 730 len += scnprintf(buf + len, buf_len - len, "tx_abort_fail_count = %u\n", 731 le32_to_cpu(htt_buf->tx_abort_fail_count)); 732 len += scnprintf(buf + len, buf_len - len, "rx_abort = %u\n", 733 le32_to_cpu(htt_buf->rx_abort)); 734 len += scnprintf(buf + len, buf_len - len, "rx_abort_fail_count = %u\n", 735 le32_to_cpu(htt_buf->rx_abort_fail_count)); 736 len += scnprintf(buf + len, buf_len - len, "rx_flush_cnt = %u\n", 737 le32_to_cpu(htt_buf->rx_flush_cnt)); 738 len += scnprintf(buf + len, buf_len - len, "warm_reset = %u\n", 739 le32_to_cpu(htt_buf->warm_reset)); 740 len += scnprintf(buf + len, buf_len - len, "cold_reset = %u\n", 741 le32_to_cpu(htt_buf->cold_reset)); 742 len += scnprintf(buf + len, buf_len - len, "mac_cold_reset_restore_cal = %u\n", 743 le32_to_cpu(htt_buf->mac_cold_reset_restore_cal)); 744 len += scnprintf(buf + len, buf_len - len, "mac_cold_reset = %u\n", 745 le32_to_cpu(htt_buf->mac_cold_reset)); 746 len += scnprintf(buf + len, buf_len - len, "mac_warm_reset = %u\n", 747 le32_to_cpu(htt_buf->mac_warm_reset)); 748 len += scnprintf(buf + len, buf_len - len, "mac_only_reset = %u\n", 749 le32_to_cpu(htt_buf->mac_only_reset)); 750 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset = %u\n", 751 le32_to_cpu(htt_buf->phy_warm_reset)); 752 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_ucode_trig = %u\n", 753 le32_to_cpu(htt_buf->phy_warm_reset_ucode_trig)); 754 len += scnprintf(buf + len, buf_len - len, "mac_warm_reset_restore_cal = %u\n", 755 le32_to_cpu(htt_buf->mac_warm_reset_restore_cal)); 756 len += scnprintf(buf + len, buf_len - len, "mac_sfm_reset = %u\n", 757 le32_to_cpu(htt_buf->mac_sfm_reset)); 758 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_m3_ssr = %u\n", 759 le32_to_cpu(htt_buf->phy_warm_reset_m3_ssr)); 760 len += scnprintf(buf + len, buf_len - len, "fw_rx_rings_reset = %u\n", 761 le32_to_cpu(htt_buf->fw_rx_rings_reset)); 762 len += scnprintf(buf + len, buf_len - len, "tx_flush = %u\n", 763 le32_to_cpu(htt_buf->tx_flush)); 764 len += scnprintf(buf + len, buf_len - len, "tx_glb_reset = %u\n", 765 le32_to_cpu(htt_buf->tx_glb_reset)); 766 len += scnprintf(buf + len, buf_len - len, "tx_txq_reset = %u\n", 767 le32_to_cpu(htt_buf->tx_txq_reset)); 768 len += scnprintf(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n", 769 le32_to_cpu(htt_buf->rx_timeout_reset)); 770 771 len += scnprintf(buf + len, buf_len - len, "PDEV_PHY_WARM_RESET_REASONS:\n"); 772 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_reason_phy_m3 = %u\n", 773 le32_to_cpu(htt_buf->phy_warm_reset_reason_phy_m3)); 774 len += scnprintf(buf + len, buf_len - len, 775 "phy_warm_reset_reason_tx_hw_stuck = %u\n", 776 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_hw_stuck)); 777 len += scnprintf(buf + len, buf_len - len, 778 "phy_warm_reset_reason_num_cca_rx_frame_stuck = %u\n", 779 le32_to_cpu(htt_buf->phy_warm_reset_reason_num_rx_frame_stuck)); 780 len += scnprintf(buf + len, buf_len - len, 781 "phy_warm_reset_reason_wal_rx_recovery_rst_rx_busy = %u\n", 782 le32_to_cpu(htt_buf->phy_warm_reset_reason_wal_rx_rec_rx_busy)); 783 len += scnprintf(buf + len, buf_len - len, 784 "phy_warm_reset_reason_wal_rx_recovery_rst_mac_hang = %u\n", 785 le32_to_cpu(htt_buf->phy_warm_reset_reason_wal_rx_rec_mac_hng)); 786 len += scnprintf(buf + len, buf_len - len, 787 "phy_warm_reset_reason_mac_reset_converted_phy_reset = %u\n", 788 le32_to_cpu(htt_buf->phy_warm_reset_reason_mac_conv_phy_reset)); 789 len += scnprintf(buf + len, buf_len - len, 790 "phy_warm_reset_reason_tx_lifetime_expiry_cca_stuck = %u\n", 791 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_exp_cca_stuck)); 792 len += scnprintf(buf + len, buf_len - len, 793 "phy_warm_reset_reason_tx_consecutive_flush9_war = %u\n", 794 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_consec_flsh_war)); 795 len += scnprintf(buf + len, buf_len - len, 796 "phy_warm_reset_reason_tx_hwsch_reset_war = %u\n", 797 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_hwsch_reset_war)); 798 len += scnprintf(buf + len, buf_len - len, 799 "phy_warm_reset_reason_hwsch_wdog_or_cca_wdog_war = %u\n\n", 800 le32_to_cpu(htt_buf->phy_warm_reset_reason_hwsch_cca_wdog_war)); 801 802 len += scnprintf(buf + len, buf_len - len, "WAL_RX_RECOVERY_STATS:\n"); 803 len += scnprintf(buf + len, buf_len - len, 804 "wal_rx_recovery_rst_mac_hang_count = %u\n", 805 le32_to_cpu(htt_buf->wal_rx_recovery_rst_mac_hang_cnt)); 806 len += scnprintf(buf + len, buf_len - len, 807 "wal_rx_recovery_rst_known_sig_count = %u\n", 808 le32_to_cpu(htt_buf->wal_rx_recovery_rst_known_sig_cnt)); 809 len += scnprintf(buf + len, buf_len - len, 810 "wal_rx_recovery_rst_no_rx_count = %u\n", 811 le32_to_cpu(htt_buf->wal_rx_recovery_rst_no_rx_cnt)); 812 len += scnprintf(buf + len, buf_len - len, 813 "wal_rx_recovery_rst_no_rx_consecutive_count = %u\n", 814 le32_to_cpu(htt_buf->wal_rx_recovery_rst_no_rx_consec_cnt)); 815 len += scnprintf(buf + len, buf_len - len, 816 "wal_rx_recovery_rst_rx_busy_count = %u\n", 817 le32_to_cpu(htt_buf->wal_rx_recovery_rst_rx_busy_cnt)); 818 len += scnprintf(buf + len, buf_len - len, 819 "wal_rx_recovery_rst_phy_mac_hang_count = %u\n\n", 820 le32_to_cpu(htt_buf->wal_rx_recovery_rst_phy_mac_hang_cnt)); 821 822 len += scnprintf(buf + len, buf_len - len, "HTT_RX_DEST_DRAIN_STATS:\n"); 823 len += scnprintf(buf + len, buf_len - len, 824 "rx_dest_drain_rx_descs_leak_prevention_done = %u\n", 825 le32_to_cpu(htt_buf->rx_dest_drain_rx_descs_leak_prevented)); 826 len += scnprintf(buf + len, buf_len - len, 827 "rx_dest_drain_rx_descs_saved_cnt = %u\n", 828 le32_to_cpu(htt_buf->rx_dest_drain_rx_descs_saved_cnt)); 829 len += scnprintf(buf + len, buf_len - len, 830 "rx_dest_drain_rxdma2reo_leak_detected = %u\n", 831 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2reo_leak_detected)); 832 len += scnprintf(buf + len, buf_len - len, 833 "rx_dest_drain_rxdma2fw_leak_detected = %u\n", 834 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2fw_leak_detected)); 835 len += scnprintf(buf + len, buf_len - len, 836 "rx_dest_drain_rxdma2wbm_leak_detected = %u\n", 837 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2wbm_leak_detected)); 838 len += scnprintf(buf + len, buf_len - len, 839 "rx_dest_drain_rxdma1_2sw_leak_detected = %u\n", 840 le32_to_cpu(htt_buf->rx_dest_drain_rxdma1_2sw_leak_detected)); 841 len += scnprintf(buf + len, buf_len - len, 842 "rx_dest_drain_rx_drain_ok_mac_idle = %u\n", 843 le32_to_cpu(htt_buf->rx_dest_drain_rx_drain_ok_mac_idle)); 844 len += scnprintf(buf + len, buf_len - len, 845 "rx_dest_drain_ok_mac_not_idle = %u\n", 846 le32_to_cpu(htt_buf->rx_dest_drain_ok_mac_not_idle)); 847 len += scnprintf(buf + len, buf_len - len, 848 "rx_dest_drain_prerequisite_invld = %u\n", 849 le32_to_cpu(htt_buf->rx_dest_drain_prerequisite_invld)); 850 len += scnprintf(buf + len, buf_len - len, 851 "rx_dest_drain_skip_for_non_lmac_reset = %u\n", 852 le32_to_cpu(htt_buf->rx_dest_drain_skip_non_lmac_reset)); 853 len += scnprintf(buf + len, buf_len - len, 854 "rx_dest_drain_hw_fifo_not_empty_post_drain_wait = %u\n\n", 855 le32_to_cpu(htt_buf->rx_dest_drain_hw_fifo_notempty_post_wait)); 856 857 stats_req->buf_len = len; 858} 859 860static void 861ath12k_htt_print_hw_stats_intr_misc_tlv(const void *tag_buf, u16 tag_len, 862 struct debug_htt_stats_req *stats_req) 863{ 864 const struct ath12k_htt_hw_stats_intr_misc_tlv *htt_stats_buf = tag_buf; 865 u8 *buf = stats_req->buf; 866 u32 len = stats_req->buf_len; 867 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 868 869 if (tag_len < sizeof(*htt_stats_buf)) 870 return; 871 872 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_INTR_MISC_TLV:\n"); 873 len += scnprintf(buf + len, buf_len - len, "hw_intr_name = %s\n", 874 htt_stats_buf->hw_intr_name); 875 len += scnprintf(buf + len, buf_len - len, "mask = %u\n", 876 le32_to_cpu(htt_stats_buf->mask)); 877 len += scnprintf(buf + len, buf_len - len, "count = %u\n\n", 878 le32_to_cpu(htt_stats_buf->count)); 879 880 stats_req->buf_len = len; 881} 882 883static void 884ath12k_htt_print_hw_stats_whal_tx_tlv(const void *tag_buf, u16 tag_len, 885 struct debug_htt_stats_req *stats_req) 886{ 887 const struct ath12k_htt_hw_stats_whal_tx_tlv *htt_stats_buf = tag_buf; 888 u8 *buf = stats_req->buf; 889 u32 len = stats_req->buf_len; 890 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 891 u32 mac_id_word; 892 893 if (tag_len < sizeof(*htt_stats_buf)) 894 return; 895 896 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 897 898 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WHAL_TX_TLV:\n"); 899 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 900 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 901 len += scnprintf(buf + len, buf_len - len, "last_unpause_ppdu_id = %u\n", 902 le32_to_cpu(htt_stats_buf->last_unpause_ppdu_id)); 903 len += scnprintf(buf + len, buf_len - len, "hwsch_unpause_wait_tqm_write = %u\n", 904 le32_to_cpu(htt_stats_buf->hwsch_unpause_wait_tqm_write)); 905 len += scnprintf(buf + len, buf_len - len, "hwsch_dummy_tlv_skipped = %u\n", 906 le32_to_cpu(htt_stats_buf->hwsch_dummy_tlv_skipped)); 907 len += scnprintf(buf + len, buf_len - len, 908 "hwsch_misaligned_offset_received = %u\n", 909 le32_to_cpu(htt_stats_buf->hwsch_misaligned_offset_received)); 910 len += scnprintf(buf + len, buf_len - len, "hwsch_reset_count = %u\n", 911 le32_to_cpu(htt_stats_buf->hwsch_reset_count)); 912 len += scnprintf(buf + len, buf_len - len, "hwsch_dev_reset_war = %u\n", 913 le32_to_cpu(htt_stats_buf->hwsch_dev_reset_war)); 914 len += scnprintf(buf + len, buf_len - len, "hwsch_delayed_pause = %u\n", 915 le32_to_cpu(htt_stats_buf->hwsch_delayed_pause)); 916 len += scnprintf(buf + len, buf_len - len, "hwsch_long_delayed_pause = %u\n", 917 le32_to_cpu(htt_stats_buf->hwsch_long_delayed_pause)); 918 len += scnprintf(buf + len, buf_len - len, "sch_rx_ppdu_no_response = %u\n", 919 le32_to_cpu(htt_stats_buf->sch_rx_ppdu_no_response)); 920 len += scnprintf(buf + len, buf_len - len, "sch_selfgen_response = %u\n", 921 le32_to_cpu(htt_stats_buf->sch_selfgen_response)); 922 len += scnprintf(buf + len, buf_len - len, "sch_rx_sifs_resp_trigger= %u\n\n", 923 le32_to_cpu(htt_stats_buf->sch_rx_sifs_resp_trigger)); 924 925 stats_req->buf_len = len; 926} 927 928static void 929ath12k_htt_print_hw_war_tlv(const void *tag_buf, u16 tag_len, 930 struct debug_htt_stats_req *stats_req) 931{ 932 const struct ath12k_htt_hw_war_stats_tlv *htt_stats_buf = tag_buf; 933 u8 *buf = stats_req->buf; 934 u32 len = stats_req->buf_len; 935 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 936 u16 fixed_len, array_len; 937 u8 i, array_words; 938 u32 mac_id; 939 940 if (tag_len < sizeof(*htt_stats_buf)) 941 return; 942 943 mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word); 944 fixed_len = sizeof(*htt_stats_buf); 945 array_len = tag_len - fixed_len; 946 array_words = array_len >> 2; 947 948 len += scnprintf(buf + len, buf_len - len, "HTT_HW_WAR_STATS_TLV:\n"); 949 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 950 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID)); 951 952 for (i = 0; i < array_words; i++) { 953 len += scnprintf(buf + len, buf_len - len, "hw_war %u = %u\n\n", 954 i, le32_to_cpu(htt_stats_buf->hw_wars[i])); 955 } 956 957 stats_req->buf_len = len; 958} 959 960static void 961ath12k_htt_print_tx_tqm_cmn_stats_tlv(const void *tag_buf, u16 tag_len, 962 struct debug_htt_stats_req *stats_req) 963{ 964 const struct ath12k_htt_tx_tqm_cmn_stats_tlv *htt_stats_buf = tag_buf; 965 u8 *buf = stats_req->buf; 966 u32 len = stats_req->buf_len; 967 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 968 u32 mac_id_word; 969 970 if (tag_len < sizeof(*htt_stats_buf)) 971 return; 972 973 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 974 975 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMN_STATS_TLV:\n"); 976 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 977 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 978 len += scnprintf(buf + len, buf_len - len, "max_cmdq_id = %u\n", 979 le32_to_cpu(htt_stats_buf->max_cmdq_id)); 980 len += scnprintf(buf + len, buf_len - len, "list_mpdu_cnt_hist_intvl = %u\n", 981 le32_to_cpu(htt_stats_buf->list_mpdu_cnt_hist_intvl)); 982 len += scnprintf(buf + len, buf_len - len, "add_msdu = %u\n", 983 le32_to_cpu(htt_stats_buf->add_msdu)); 984 len += scnprintf(buf + len, buf_len - len, "q_empty = %u\n", 985 le32_to_cpu(htt_stats_buf->q_empty)); 986 len += scnprintf(buf + len, buf_len - len, "q_not_empty = %u\n", 987 le32_to_cpu(htt_stats_buf->q_not_empty)); 988 len += scnprintf(buf + len, buf_len - len, "drop_notification = %u\n", 989 le32_to_cpu(htt_stats_buf->drop_notification)); 990 len += scnprintf(buf + len, buf_len - len, "desc_threshold = %u\n", 991 le32_to_cpu(htt_stats_buf->desc_threshold)); 992 len += scnprintf(buf + len, buf_len - len, "hwsch_tqm_invalid_status = %u\n", 993 le32_to_cpu(htt_stats_buf->hwsch_tqm_invalid_status)); 994 len += scnprintf(buf + len, buf_len - len, "missed_tqm_gen_mpdus = %u\n", 995 le32_to_cpu(htt_stats_buf->missed_tqm_gen_mpdus)); 996 len += scnprintf(buf + len, buf_len - len, 997 "total_msduq_timestamp_updates = %u\n", 998 le32_to_cpu(htt_stats_buf->msduq_timestamp_updates)); 999 len += scnprintf(buf + len, buf_len - len, 1000 "total_msduq_timestamp_updates_by_get_mpdu_head_info_cmd = %u\n", 1001 le32_to_cpu(htt_stats_buf->msduq_updates_mpdu_head_info_cmd)); 1002 len += scnprintf(buf + len, buf_len - len, 1003 "total_msduq_timestamp_updates_by_emp_to_nonemp_status = %u\n", 1004 le32_to_cpu(htt_stats_buf->msduq_updates_emp_to_nonemp_status)); 1005 len += scnprintf(buf + len, buf_len - len, 1006 "total_get_mpdu_head_info_cmds_by_sched_algo_la_query = %u\n", 1007 le32_to_cpu(htt_stats_buf->get_mpdu_head_info_cmds_by_query)); 1008 len += scnprintf(buf + len, buf_len - len, 1009 "total_get_mpdu_head_info_cmds_by_tac = %u\n", 1010 le32_to_cpu(htt_stats_buf->get_mpdu_head_info_cmds_by_tac)); 1011 len += scnprintf(buf + len, buf_len - len, 1012 "total_gen_mpdu_cmds_by_sched_algo_la_query = %u\n", 1013 le32_to_cpu(htt_stats_buf->gen_mpdu_cmds_by_query)); 1014 len += scnprintf(buf + len, buf_len - len, "active_tqm_tids = %u\n", 1015 le32_to_cpu(htt_stats_buf->tqm_active_tids)); 1016 len += scnprintf(buf + len, buf_len - len, "inactive_tqm_tids = %u\n", 1017 le32_to_cpu(htt_stats_buf->tqm_inactive_tids)); 1018 len += scnprintf(buf + len, buf_len - len, "tqm_active_msduq_flows = %u\n", 1019 le32_to_cpu(htt_stats_buf->tqm_active_msduq_flows)); 1020 len += scnprintf(buf + len, buf_len - len, "hi_prio_q_not_empty = %u\n\n", 1021 le32_to_cpu(htt_stats_buf->high_prio_q_not_empty)); 1022 1023 stats_req->buf_len = len; 1024} 1025 1026static void 1027ath12k_htt_print_tx_tqm_error_stats_tlv(const void *tag_buf, u16 tag_len, 1028 struct debug_htt_stats_req *stats_req) 1029{ 1030 const struct ath12k_htt_tx_tqm_error_stats_tlv *htt_stats_buf = tag_buf; 1031 u8 *buf = stats_req->buf; 1032 u32 len = stats_req->buf_len; 1033 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1034 1035 if (tag_len < sizeof(*htt_stats_buf)) 1036 return; 1037 1038 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_ERROR_STATS_TLV:\n"); 1039 len += scnprintf(buf + len, buf_len - len, "q_empty_failure = %u\n", 1040 le32_to_cpu(htt_stats_buf->q_empty_failure)); 1041 len += scnprintf(buf + len, buf_len - len, "q_not_empty_failure = %u\n", 1042 le32_to_cpu(htt_stats_buf->q_not_empty_failure)); 1043 len += scnprintf(buf + len, buf_len - len, "add_msdu_failure = %u\n\n", 1044 le32_to_cpu(htt_stats_buf->add_msdu_failure)); 1045 1046 len += scnprintf(buf + len, buf_len - len, "TQM_ERROR_RESET_STATS:\n"); 1047 len += scnprintf(buf + len, buf_len - len, "tqm_cache_ctl_err = %u\n", 1048 le32_to_cpu(htt_stats_buf->tqm_cache_ctl_err)); 1049 len += scnprintf(buf + len, buf_len - len, "tqm_soft_reset = %u\n", 1050 le32_to_cpu(htt_stats_buf->tqm_soft_reset)); 1051 len += scnprintf(buf + len, buf_len - len, 1052 "tqm_reset_total_num_in_use_link_descs = %u\n", 1053 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_link_descs)); 1054 len += scnprintf(buf + len, buf_len - len, 1055 "tqm_reset_worst_case_num_lost_link_descs = %u\n", 1056 le32_to_cpu(htt_stats_buf->tqm_reset_num_lost_link_descs)); 1057 len += scnprintf(buf + len, buf_len - len, 1058 "tqm_reset_worst_case_num_lost_host_tx_bufs_count = %u\n", 1059 le32_to_cpu(htt_stats_buf->tqm_reset_num_lost_host_tx_buf_cnt)); 1060 len += scnprintf(buf + len, buf_len - len, 1061 "tqm_reset_num_in_use_link_descs_internal_tqm = %u\n", 1062 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_internal_tqm)); 1063 len += scnprintf(buf + len, buf_len - len, 1064 "tqm_reset_num_in_use_link_descs_wbm_idle_link_ring = %u\n", 1065 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_idle_link_rng)); 1066 len += scnprintf(buf + len, buf_len - len, 1067 "tqm_reset_time_to_tqm_hang_delta_ms = %u\n", 1068 le32_to_cpu(htt_stats_buf->tqm_reset_time_to_tqm_hang_delta_ms)); 1069 len += scnprintf(buf + len, buf_len - len, "tqm_reset_recovery_time_ms = %u\n", 1070 le32_to_cpu(htt_stats_buf->tqm_reset_recovery_time_ms)); 1071 len += scnprintf(buf + len, buf_len - len, "tqm_reset_num_peers_hdl = %u\n", 1072 le32_to_cpu(htt_stats_buf->tqm_reset_num_peers_hdl)); 1073 len += scnprintf(buf + len, buf_len - len, 1074 "tqm_reset_cumm_dirty_hw_mpduq_proc_cnt = %u\n", 1075 le32_to_cpu(htt_stats_buf->tqm_reset_cumm_dirty_hw_mpduq_cnt)); 1076 len += scnprintf(buf + len, buf_len - len, 1077 "tqm_reset_cumm_dirty_hw_msduq_proc = %u\n", 1078 le32_to_cpu(htt_stats_buf->tqm_reset_cumm_dirty_hw_msduq_proc)); 1079 len += scnprintf(buf + len, buf_len - len, 1080 "tqm_reset_flush_cache_cmd_su_cnt = %u\n", 1081 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_su_cnt)); 1082 len += scnprintf(buf + len, buf_len - len, 1083 "tqm_reset_flush_cache_cmd_other_cnt = %u\n", 1084 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_other_cnt)); 1085 len += scnprintf(buf + len, buf_len - len, 1086 "tqm_reset_flush_cache_cmd_trig_type = %u\n", 1087 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_trig_type)); 1088 len += scnprintf(buf + len, buf_len - len, 1089 "tqm_reset_flush_cache_cmd_trig_cfg = %u\n", 1090 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_trig_cfg)); 1091 len += scnprintf(buf + len, buf_len - len, 1092 "tqm_reset_flush_cache_cmd_skip_cmd_status_null = %u\n\n", 1093 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cmd_skp_status_null)); 1094 1095 stats_req->buf_len = len; 1096} 1097 1098static void 1099ath12k_htt_print_tx_tqm_gen_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 1100 struct debug_htt_stats_req *stats_req) 1101{ 1102 const struct ath12k_htt_tx_tqm_gen_mpdu_stats_tlv *htt_stats_buf = tag_buf; 1103 u8 *buf = stats_req->buf; 1104 u32 len = stats_req->buf_len; 1105 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1106 u16 num_elements = tag_len >> 2; 1107 1108 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_GEN_MPDU_STATS_TLV:\n"); 1109 len += print_array_to_buf(buf, len, "gen_mpdu_end_reason", 1110 htt_stats_buf->gen_mpdu_end_reason, num_elements, 1111 "\n\n"); 1112 1113 stats_req->buf_len = len; 1114} 1115 1116static void 1117ath12k_htt_print_tx_tqm_list_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 1118 struct debug_htt_stats_req *stats_req) 1119{ 1120 const struct ath12k_htt_tx_tqm_list_mpdu_stats_tlv *htt_stats_buf = tag_buf; 1121 u8 *buf = stats_req->buf; 1122 u32 len = stats_req->buf_len; 1123 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1124 u16 num_elems = min_t(u16, (tag_len >> 2), 1125 ATH12K_HTT_TX_TQM_MAX_LIST_MPDU_END_REASON); 1126 1127 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_STATS_TLV:\n"); 1128 len += print_array_to_buf(buf, len, "list_mpdu_end_reason", 1129 htt_stats_buf->list_mpdu_end_reason, num_elems, "\n\n"); 1130 1131 stats_req->buf_len = len; 1132} 1133 1134static void 1135ath12k_htt_print_tx_tqm_list_mpdu_cnt_tlv(const void *tag_buf, u16 tag_len, 1136 struct debug_htt_stats_req *stats_req) 1137{ 1138 const struct ath12k_htt_tx_tqm_list_mpdu_cnt_tlv *htt_stats_buf = tag_buf; 1139 u8 *buf = stats_req->buf; 1140 u32 len = stats_req->buf_len; 1141 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1142 u16 num_elems = min_t(u16, (tag_len >> 2), 1143 ATH12K_HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS); 1144 1145 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:\n"); 1146 len += print_array_to_buf(buf, len, "list_mpdu_cnt_hist", 1147 htt_stats_buf->list_mpdu_cnt_hist, num_elems, "\n\n"); 1148 1149 stats_req->buf_len = len; 1150} 1151 1152static void 1153ath12k_htt_print_tx_tqm_pdev_stats_tlv(const void *tag_buf, u16 tag_len, 1154 struct debug_htt_stats_req *stats_req) 1155{ 1156 const struct ath12k_htt_tx_tqm_pdev_stats_tlv *htt_stats_buf = tag_buf; 1157 u8 *buf = stats_req->buf; 1158 u32 len = stats_req->buf_len; 1159 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1160 1161 if (tag_len < sizeof(*htt_stats_buf)) 1162 return; 1163 1164 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_PDEV_STATS_TLV_V:\n"); 1165 len += scnprintf(buf + len, buf_len - len, "msdu_count = %u\n", 1166 le32_to_cpu(htt_stats_buf->msdu_count)); 1167 len += scnprintf(buf + len, buf_len - len, "mpdu_count = %u\n", 1168 le32_to_cpu(htt_stats_buf->mpdu_count)); 1169 len += scnprintf(buf + len, buf_len - len, "remove_msdu = %u\n", 1170 le32_to_cpu(htt_stats_buf->remove_msdu)); 1171 len += scnprintf(buf + len, buf_len - len, "remove_mpdu = %u\n", 1172 le32_to_cpu(htt_stats_buf->remove_mpdu)); 1173 len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl = %u\n", 1174 le32_to_cpu(htt_stats_buf->remove_msdu_ttl)); 1175 len += scnprintf(buf + len, buf_len - len, "send_bar = %u\n", 1176 le32_to_cpu(htt_stats_buf->send_bar)); 1177 len += scnprintf(buf + len, buf_len - len, "bar_sync = %u\n", 1178 le32_to_cpu(htt_stats_buf->bar_sync)); 1179 len += scnprintf(buf + len, buf_len - len, "notify_mpdu = %u\n", 1180 le32_to_cpu(htt_stats_buf->notify_mpdu)); 1181 len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n", 1182 le32_to_cpu(htt_stats_buf->sync_cmd)); 1183 len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n", 1184 le32_to_cpu(htt_stats_buf->write_cmd)); 1185 len += scnprintf(buf + len, buf_len - len, "hwsch_trigger = %u\n", 1186 le32_to_cpu(htt_stats_buf->hwsch_trigger)); 1187 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 1188 le32_to_cpu(htt_stats_buf->ack_tlv_proc)); 1189 len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n", 1190 le32_to_cpu(htt_stats_buf->gen_mpdu_cmd)); 1191 len += scnprintf(buf + len, buf_len - len, "gen_list_cmd = %u\n", 1192 le32_to_cpu(htt_stats_buf->gen_list_cmd)); 1193 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n", 1194 le32_to_cpu(htt_stats_buf->remove_mpdu_cmd)); 1195 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_tried_cmd = %u\n", 1196 le32_to_cpu(htt_stats_buf->remove_mpdu_tried_cmd)); 1197 len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n", 1198 le32_to_cpu(htt_stats_buf->mpdu_queue_stats_cmd)); 1199 len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n", 1200 le32_to_cpu(htt_stats_buf->mpdu_head_info_cmd)); 1201 len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n", 1202 le32_to_cpu(htt_stats_buf->msdu_flow_stats_cmd)); 1203 len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n", 1204 le32_to_cpu(htt_stats_buf->remove_msdu_cmd)); 1205 len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl_cmd = %u\n", 1206 le32_to_cpu(htt_stats_buf->remove_msdu_ttl_cmd)); 1207 len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n", 1208 le32_to_cpu(htt_stats_buf->flush_cache_cmd)); 1209 len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n", 1210 le32_to_cpu(htt_stats_buf->update_mpduq_cmd)); 1211 len += scnprintf(buf + len, buf_len - len, "enqueue = %u\n", 1212 le32_to_cpu(htt_stats_buf->enqueue)); 1213 len += scnprintf(buf + len, buf_len - len, "enqueue_notify = %u\n", 1214 le32_to_cpu(htt_stats_buf->enqueue_notify)); 1215 len += scnprintf(buf + len, buf_len - len, "notify_mpdu_at_head = %u\n", 1216 le32_to_cpu(htt_stats_buf->notify_mpdu_at_head)); 1217 len += scnprintf(buf + len, buf_len - len, "notify_mpdu_state_valid = %u\n", 1218 le32_to_cpu(htt_stats_buf->notify_mpdu_state_valid)); 1219 len += scnprintf(buf + len, buf_len - len, "sched_udp_notify1 = %u\n", 1220 le32_to_cpu(htt_stats_buf->sched_udp_notify1)); 1221 len += scnprintf(buf + len, buf_len - len, "sched_udp_notify2 = %u\n", 1222 le32_to_cpu(htt_stats_buf->sched_udp_notify2)); 1223 len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify1 = %u\n", 1224 le32_to_cpu(htt_stats_buf->sched_nonudp_notify1)); 1225 len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify2 = %u\n\n", 1226 le32_to_cpu(htt_stats_buf->sched_nonudp_notify2)); 1227 1228 stats_req->buf_len = len; 1229} 1230 1231static void 1232ath12k_htt_print_tx_de_cmn_stats_tlv(const void *tag_buf, u16 tag_len, 1233 struct debug_htt_stats_req *stats_req) 1234{ 1235 const struct ath12k_htt_tx_de_cmn_stats_tlv *htt_stats_buf = tag_buf; 1236 u8 *buf = stats_req->buf; 1237 u32 len = stats_req->buf_len; 1238 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1239 u32 mac_id_word; 1240 1241 if (tag_len < sizeof(*htt_stats_buf)) 1242 return; 1243 1244 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 1245 1246 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CMN_STATS_TLV:\n"); 1247 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 1248 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 1249 len += scnprintf(buf + len, buf_len - len, "tcl2fw_entry_count = %u\n", 1250 le32_to_cpu(htt_stats_buf->tcl2fw_entry_count)); 1251 len += scnprintf(buf + len, buf_len - len, "not_to_fw = %u\n", 1252 le32_to_cpu(htt_stats_buf->not_to_fw)); 1253 len += scnprintf(buf + len, buf_len - len, "invalid_pdev_vdev_peer = %u\n", 1254 le32_to_cpu(htt_stats_buf->invalid_pdev_vdev_peer)); 1255 len += scnprintf(buf + len, buf_len - len, "tcl_res_invalid_addrx = %u\n", 1256 le32_to_cpu(htt_stats_buf->tcl_res_invalid_addrx)); 1257 len += scnprintf(buf + len, buf_len - len, "wbm2fw_entry_count = %u\n", 1258 le32_to_cpu(htt_stats_buf->wbm2fw_entry_count)); 1259 len += scnprintf(buf + len, buf_len - len, "invalid_pdev = %u\n", 1260 le32_to_cpu(htt_stats_buf->invalid_pdev)); 1261 len += scnprintf(buf + len, buf_len - len, "tcl_res_addrx_timeout = %u\n", 1262 le32_to_cpu(htt_stats_buf->tcl_res_addrx_timeout)); 1263 len += scnprintf(buf + len, buf_len - len, "invalid_vdev = %u\n", 1264 le32_to_cpu(htt_stats_buf->invalid_vdev)); 1265 len += scnprintf(buf + len, buf_len - len, "invalid_tcl_exp_frame_desc = %u\n", 1266 le32_to_cpu(htt_stats_buf->invalid_tcl_exp_frame_desc)); 1267 len += scnprintf(buf + len, buf_len - len, "vdev_id_mismatch_count = %u\n\n", 1268 le32_to_cpu(htt_stats_buf->vdev_id_mismatch_cnt)); 1269 1270 stats_req->buf_len = len; 1271} 1272 1273static void 1274ath12k_htt_print_tx_de_eapol_packets_stats_tlv(const void *tag_buf, u16 tag_len, 1275 struct debug_htt_stats_req *stats_req) 1276{ 1277 const struct ath12k_htt_tx_de_eapol_packets_stats_tlv *htt_stats_buf = tag_buf; 1278 u8 *buf = stats_req->buf; 1279 u32 len = stats_req->buf_len; 1280 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1281 1282 if (tag_len < sizeof(*htt_stats_buf)) 1283 return; 1284 1285 len += scnprintf(buf + len, buf_len - len, 1286 "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:\n"); 1287 len += scnprintf(buf + len, buf_len - len, "m1_packets = %u\n", 1288 le32_to_cpu(htt_stats_buf->m1_packets)); 1289 len += scnprintf(buf + len, buf_len - len, "m2_packets = %u\n", 1290 le32_to_cpu(htt_stats_buf->m2_packets)); 1291 len += scnprintf(buf + len, buf_len - len, "m3_packets = %u\n", 1292 le32_to_cpu(htt_stats_buf->m3_packets)); 1293 len += scnprintf(buf + len, buf_len - len, "m4_packets = %u\n", 1294 le32_to_cpu(htt_stats_buf->m4_packets)); 1295 len += scnprintf(buf + len, buf_len - len, "g1_packets = %u\n", 1296 le32_to_cpu(htt_stats_buf->g1_packets)); 1297 len += scnprintf(buf + len, buf_len - len, "g2_packets = %u\n", 1298 le32_to_cpu(htt_stats_buf->g2_packets)); 1299 len += scnprintf(buf + len, buf_len - len, "rc4_packets = %u\n", 1300 le32_to_cpu(htt_stats_buf->rc4_packets)); 1301 len += scnprintf(buf + len, buf_len - len, "eap_packets = %u\n", 1302 le32_to_cpu(htt_stats_buf->eap_packets)); 1303 len += scnprintf(buf + len, buf_len - len, "eapol_start_packets = %u\n", 1304 le32_to_cpu(htt_stats_buf->eapol_start_packets)); 1305 len += scnprintf(buf + len, buf_len - len, "eapol_logoff_packets = %u\n", 1306 le32_to_cpu(htt_stats_buf->eapol_logoff_packets)); 1307 len += scnprintf(buf + len, buf_len - len, "eapol_encap_asf_packets = %u\n\n", 1308 le32_to_cpu(htt_stats_buf->eapol_encap_asf_packets)); 1309 1310 stats_req->buf_len = len; 1311} 1312 1313static void 1314ath12k_htt_print_tx_de_classify_stats_tlv(const void *tag_buf, u16 tag_len, 1315 struct debug_htt_stats_req *stats_req) 1316{ 1317 const struct ath12k_htt_tx_de_classify_stats_tlv *htt_stats_buf = tag_buf; 1318 u8 *buf = stats_req->buf; 1319 u32 len = stats_req->buf_len; 1320 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1321 1322 if (tag_len < sizeof(*htt_stats_buf)) 1323 return; 1324 1325 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CLASSIFY_STATS_TLV:\n"); 1326 len += scnprintf(buf + len, buf_len - len, "arp_packets = %u\n", 1327 le32_to_cpu(htt_stats_buf->arp_packets)); 1328 len += scnprintf(buf + len, buf_len - len, "igmp_packets = %u\n", 1329 le32_to_cpu(htt_stats_buf->igmp_packets)); 1330 len += scnprintf(buf + len, buf_len - len, "dhcp_packets = %u\n", 1331 le32_to_cpu(htt_stats_buf->dhcp_packets)); 1332 len += scnprintf(buf + len, buf_len - len, "host_inspected = %u\n", 1333 le32_to_cpu(htt_stats_buf->host_inspected)); 1334 len += scnprintf(buf + len, buf_len - len, "htt_included = %u\n", 1335 le32_to_cpu(htt_stats_buf->htt_included)); 1336 len += scnprintf(buf + len, buf_len - len, "htt_valid_mcs = %u\n", 1337 le32_to_cpu(htt_stats_buf->htt_valid_mcs)); 1338 len += scnprintf(buf + len, buf_len - len, "htt_valid_nss = %u\n", 1339 le32_to_cpu(htt_stats_buf->htt_valid_nss)); 1340 len += scnprintf(buf + len, buf_len - len, "htt_valid_preamble_type = %u\n", 1341 le32_to_cpu(htt_stats_buf->htt_valid_preamble_type)); 1342 len += scnprintf(buf + len, buf_len - len, "htt_valid_chainmask = %u\n", 1343 le32_to_cpu(htt_stats_buf->htt_valid_chainmask)); 1344 len += scnprintf(buf + len, buf_len - len, "htt_valid_guard_interval = %u\n", 1345 le32_to_cpu(htt_stats_buf->htt_valid_guard_interval)); 1346 len += scnprintf(buf + len, buf_len - len, "htt_valid_retries = %u\n", 1347 le32_to_cpu(htt_stats_buf->htt_valid_retries)); 1348 len += scnprintf(buf + len, buf_len - len, "htt_valid_bw_info = %u\n", 1349 le32_to_cpu(htt_stats_buf->htt_valid_bw_info)); 1350 len += scnprintf(buf + len, buf_len - len, "htt_valid_power = %u\n", 1351 le32_to_cpu(htt_stats_buf->htt_valid_power)); 1352 len += scnprintf(buf + len, buf_len - len, "htt_valid_key_flags = 0x%x\n", 1353 le32_to_cpu(htt_stats_buf->htt_valid_key_flags)); 1354 len += scnprintf(buf + len, buf_len - len, "htt_valid_no_encryption = %u\n", 1355 le32_to_cpu(htt_stats_buf->htt_valid_no_encryption)); 1356 len += scnprintf(buf + len, buf_len - len, "fse_entry_count = %u\n", 1357 le32_to_cpu(htt_stats_buf->fse_entry_count)); 1358 len += scnprintf(buf + len, buf_len - len, "fse_priority_be = %u\n", 1359 le32_to_cpu(htt_stats_buf->fse_priority_be)); 1360 len += scnprintf(buf + len, buf_len - len, "fse_priority_high = %u\n", 1361 le32_to_cpu(htt_stats_buf->fse_priority_high)); 1362 len += scnprintf(buf + len, buf_len - len, "fse_priority_low = %u\n", 1363 le32_to_cpu(htt_stats_buf->fse_priority_low)); 1364 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_be = %u\n", 1365 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_be)); 1366 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_over_sub = %u\n", 1367 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_over_sub)); 1368 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_bursty = %u\n", 1369 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_bursty)); 1370 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_interactive = %u\n", 1371 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_interactive)); 1372 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_periodic = %u\n", 1373 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_periodic)); 1374 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_alloc = %u\n", 1375 le32_to_cpu(htt_stats_buf->fse_hwqueue_alloc)); 1376 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_created = %u\n", 1377 le32_to_cpu(htt_stats_buf->fse_hwqueue_created)); 1378 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_send_to_host = %u\n", 1379 le32_to_cpu(htt_stats_buf->fse_hwqueue_send_to_host)); 1380 len += scnprintf(buf + len, buf_len - len, "mcast_entry = %u\n", 1381 le32_to_cpu(htt_stats_buf->mcast_entry)); 1382 len += scnprintf(buf + len, buf_len - len, "bcast_entry = %u\n", 1383 le32_to_cpu(htt_stats_buf->bcast_entry)); 1384 len += scnprintf(buf + len, buf_len - len, "htt_update_peer_cache = %u\n", 1385 le32_to_cpu(htt_stats_buf->htt_update_peer_cache)); 1386 len += scnprintf(buf + len, buf_len - len, "htt_learning_frame = %u\n", 1387 le32_to_cpu(htt_stats_buf->htt_learning_frame)); 1388 len += scnprintf(buf + len, buf_len - len, "fse_invalid_peer = %u\n", 1389 le32_to_cpu(htt_stats_buf->fse_invalid_peer)); 1390 len += scnprintf(buf + len, buf_len - len, "mec_notify = %u\n\n", 1391 le32_to_cpu(htt_stats_buf->mec_notify)); 1392 1393 stats_req->buf_len = len; 1394} 1395 1396static void 1397ath12k_htt_print_tx_de_classify_failed_stats_tlv(const void *tag_buf, u16 tag_len, 1398 struct debug_htt_stats_req *stats_req) 1399{ 1400 const struct ath12k_htt_tx_de_classify_failed_stats_tlv *htt_stats_buf = tag_buf; 1401 u8 *buf = stats_req->buf; 1402 u32 len = stats_req->buf_len; 1403 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1404 1405 if (tag_len < sizeof(*htt_stats_buf)) 1406 return; 1407 1408 len += scnprintf(buf + len, buf_len - len, 1409 "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:\n"); 1410 len += scnprintf(buf + len, buf_len - len, "ap_bss_peer_not_found = %u\n", 1411 le32_to_cpu(htt_stats_buf->ap_bss_peer_not_found)); 1412 len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_no_peer = %u\n", 1413 le32_to_cpu(htt_stats_buf->ap_bcast_mcast_no_peer)); 1414 len += scnprintf(buf + len, buf_len - len, "sta_delete_in_progress = %u\n", 1415 le32_to_cpu(htt_stats_buf->sta_delete_in_progress)); 1416 len += scnprintf(buf + len, buf_len - len, "ibss_no_bss_peer = %u\n", 1417 le32_to_cpu(htt_stats_buf->ibss_no_bss_peer)); 1418 len += scnprintf(buf + len, buf_len - len, "invalid_vdev_type = %u\n", 1419 le32_to_cpu(htt_stats_buf->invalid_vdev_type)); 1420 len += scnprintf(buf + len, buf_len - len, "invalid_ast_peer_entry = %u\n", 1421 le32_to_cpu(htt_stats_buf->invalid_ast_peer_entry)); 1422 len += scnprintf(buf + len, buf_len - len, "peer_entry_invalid = %u\n", 1423 le32_to_cpu(htt_stats_buf->peer_entry_invalid)); 1424 len += scnprintf(buf + len, buf_len - len, "ethertype_not_ip = %u\n", 1425 le32_to_cpu(htt_stats_buf->ethertype_not_ip)); 1426 len += scnprintf(buf + len, buf_len - len, "eapol_lookup_failed = %u\n", 1427 le32_to_cpu(htt_stats_buf->eapol_lookup_failed)); 1428 len += scnprintf(buf + len, buf_len - len, "qpeer_not_allow_data = %u\n", 1429 le32_to_cpu(htt_stats_buf->qpeer_not_allow_data)); 1430 len += scnprintf(buf + len, buf_len - len, "fse_tid_override = %u\n", 1431 le32_to_cpu(htt_stats_buf->fse_tid_override)); 1432 len += scnprintf(buf + len, buf_len - len, "ipv6_jumbogram_zero_length = %u\n", 1433 le32_to_cpu(htt_stats_buf->ipv6_jumbogram_zero_length)); 1434 len += scnprintf(buf + len, buf_len - len, "qos_to_non_qos_in_prog = %u\n", 1435 le32_to_cpu(htt_stats_buf->qos_to_non_qos_in_prog)); 1436 len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_eapol = %u\n", 1437 le32_to_cpu(htt_stats_buf->ap_bcast_mcast_eapol)); 1438 len += scnprintf(buf + len, buf_len - len, "unicast_on_ap_bss_peer = %u\n", 1439 le32_to_cpu(htt_stats_buf->unicast_on_ap_bss_peer)); 1440 len += scnprintf(buf + len, buf_len - len, "ap_vdev_invalid = %u\n", 1441 le32_to_cpu(htt_stats_buf->ap_vdev_invalid)); 1442 len += scnprintf(buf + len, buf_len - len, "incomplete_llc = %u\n", 1443 le32_to_cpu(htt_stats_buf->incomplete_llc)); 1444 len += scnprintf(buf + len, buf_len - len, "eapol_duplicate_m3 = %u\n", 1445 le32_to_cpu(htt_stats_buf->eapol_duplicate_m3)); 1446 len += scnprintf(buf + len, buf_len - len, "eapol_duplicate_m4 = %u\n\n", 1447 le32_to_cpu(htt_stats_buf->eapol_duplicate_m4)); 1448 1449 stats_req->buf_len = len; 1450} 1451 1452static void 1453ath12k_htt_print_tx_de_classify_status_stats_tlv(const void *tag_buf, u16 tag_len, 1454 struct debug_htt_stats_req *stats_req) 1455{ 1456 const struct ath12k_htt_tx_de_classify_status_stats_tlv *htt_stats_buf = tag_buf; 1457 u8 *buf = stats_req->buf; 1458 u32 len = stats_req->buf_len; 1459 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1460 1461 if (tag_len < sizeof(*htt_stats_buf)) 1462 return; 1463 1464 len += scnprintf(buf + len, buf_len - len, 1465 "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:\n"); 1466 len += scnprintf(buf + len, buf_len - len, "eok = %u\n", 1467 le32_to_cpu(htt_stats_buf->eok)); 1468 len += scnprintf(buf + len, buf_len - len, "classify_done = %u\n", 1469 le32_to_cpu(htt_stats_buf->classify_done)); 1470 len += scnprintf(buf + len, buf_len - len, "lookup_failed = %u\n", 1471 le32_to_cpu(htt_stats_buf->lookup_failed)); 1472 len += scnprintf(buf + len, buf_len - len, "send_host_dhcp = %u\n", 1473 le32_to_cpu(htt_stats_buf->send_host_dhcp)); 1474 len += scnprintf(buf + len, buf_len - len, "send_host_mcast = %u\n", 1475 le32_to_cpu(htt_stats_buf->send_host_mcast)); 1476 len += scnprintf(buf + len, buf_len - len, "send_host_unknown_dest = %u\n", 1477 le32_to_cpu(htt_stats_buf->send_host_unknown_dest)); 1478 len += scnprintf(buf + len, buf_len - len, "send_host = %u\n", 1479 le32_to_cpu(htt_stats_buf->send_host)); 1480 len += scnprintf(buf + len, buf_len - len, "status_invalid = %u\n\n", 1481 le32_to_cpu(htt_stats_buf->status_invalid)); 1482 1483 stats_req->buf_len = len; 1484} 1485 1486static void 1487ath12k_htt_print_tx_de_enqueue_packets_stats_tlv(const void *tag_buf, u16 tag_len, 1488 struct debug_htt_stats_req *stats_req) 1489{ 1490 const struct ath12k_htt_tx_de_enqueue_packets_stats_tlv *htt_stats_buf = tag_buf; 1491 u8 *buf = stats_req->buf; 1492 u32 len = stats_req->buf_len; 1493 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1494 1495 if (tag_len < sizeof(*htt_stats_buf)) 1496 return; 1497 1498 len += scnprintf(buf + len, buf_len - len, 1499 "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:\n"); 1500 len += scnprintf(buf + len, buf_len - len, "enqueued_pkts = %u\n", 1501 le32_to_cpu(htt_stats_buf->enqueued_pkts)); 1502 len += scnprintf(buf + len, buf_len - len, "to_tqm = %u\n", 1503 le32_to_cpu(htt_stats_buf->to_tqm)); 1504 len += scnprintf(buf + len, buf_len - len, "to_tqm_bypass = %u\n\n", 1505 le32_to_cpu(htt_stats_buf->to_tqm_bypass)); 1506 1507 stats_req->buf_len = len; 1508} 1509 1510static void 1511ath12k_htt_print_tx_de_enqueue_discard_stats_tlv(const void *tag_buf, u16 tag_len, 1512 struct debug_htt_stats_req *stats_req) 1513{ 1514 const struct ath12k_htt_tx_de_enqueue_discard_stats_tlv *htt_stats_buf = tag_buf; 1515 u8 *buf = stats_req->buf; 1516 u32 len = stats_req->buf_len; 1517 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1518 1519 if (tag_len < sizeof(*htt_stats_buf)) 1520 return; 1521 1522 len += scnprintf(buf + len, buf_len - len, 1523 "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:\n"); 1524 len += scnprintf(buf + len, buf_len - len, "discarded_pkts = %u\n", 1525 le32_to_cpu(htt_stats_buf->discarded_pkts)); 1526 len += scnprintf(buf + len, buf_len - len, "local_frames = %u\n", 1527 le32_to_cpu(htt_stats_buf->local_frames)); 1528 len += scnprintf(buf + len, buf_len - len, "is_ext_msdu = %u\n\n", 1529 le32_to_cpu(htt_stats_buf->is_ext_msdu)); 1530 1531 stats_req->buf_len = len; 1532} 1533 1534static void 1535ath12k_htt_print_tx_de_compl_stats_tlv(const void *tag_buf, u16 tag_len, 1536 struct debug_htt_stats_req *stats_req) 1537{ 1538 const struct ath12k_htt_tx_de_compl_stats_tlv *htt_stats_buf = tag_buf; 1539 u8 *buf = stats_req->buf; 1540 u32 len = stats_req->buf_len; 1541 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1542 1543 if (tag_len < sizeof(*htt_stats_buf)) 1544 return; 1545 1546 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_COMPL_STATS_TLV:\n"); 1547 len += scnprintf(buf + len, buf_len - len, "tcl_dummy_frame = %u\n", 1548 le32_to_cpu(htt_stats_buf->tcl_dummy_frame)); 1549 len += scnprintf(buf + len, buf_len - len, "tqm_dummy_frame = %u\n", 1550 le32_to_cpu(htt_stats_buf->tqm_dummy_frame)); 1551 len += scnprintf(buf + len, buf_len - len, "tqm_notify_frame = %u\n", 1552 le32_to_cpu(htt_stats_buf->tqm_notify_frame)); 1553 len += scnprintf(buf + len, buf_len - len, "fw2wbm_enq = %u\n", 1554 le32_to_cpu(htt_stats_buf->fw2wbm_enq)); 1555 len += scnprintf(buf + len, buf_len - len, "tqm_bypass_frame = %u\n\n", 1556 le32_to_cpu(htt_stats_buf->tqm_bypass_frame)); 1557 1558 stats_req->buf_len = len; 1559} 1560 1561static void 1562ath12k_htt_print_tx_selfgen_cmn_stats_tlv(const void *tag_buf, u16 tag_len, 1563 struct debug_htt_stats_req *stats_req) 1564{ 1565 const struct ath12k_htt_tx_selfgen_cmn_stats_tlv *htt_stats_buf = tag_buf; 1566 u8 *buf = stats_req->buf; 1567 u32 len = stats_req->buf_len; 1568 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1569 u32 mac_id_word; 1570 1571 if (tag_len < sizeof(*htt_stats_buf)) 1572 return; 1573 1574 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 1575 1576 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n"); 1577 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 1578 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 1579 len += scnprintf(buf + len, buf_len - len, "su_bar = %u\n", 1580 le32_to_cpu(htt_stats_buf->su_bar)); 1581 len += scnprintf(buf + len, buf_len - len, "rts = %u\n", 1582 le32_to_cpu(htt_stats_buf->rts)); 1583 len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n", 1584 le32_to_cpu(htt_stats_buf->cts2self)); 1585 len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n", 1586 le32_to_cpu(htt_stats_buf->qos_null)); 1587 len += scnprintf(buf + len, buf_len - len, "delayed_bar_1 = %u\n", 1588 le32_to_cpu(htt_stats_buf->delayed_bar_1)); 1589 len += scnprintf(buf + len, buf_len - len, "delayed_bar_2 = %u\n", 1590 le32_to_cpu(htt_stats_buf->delayed_bar_2)); 1591 len += scnprintf(buf + len, buf_len - len, "delayed_bar_3 = %u\n", 1592 le32_to_cpu(htt_stats_buf->delayed_bar_3)); 1593 len += scnprintf(buf + len, buf_len - len, "delayed_bar_4 = %u\n", 1594 le32_to_cpu(htt_stats_buf->delayed_bar_4)); 1595 len += scnprintf(buf + len, buf_len - len, "delayed_bar_5 = %u\n", 1596 le32_to_cpu(htt_stats_buf->delayed_bar_5)); 1597 len += scnprintf(buf + len, buf_len - len, "delayed_bar_6 = %u\n", 1598 le32_to_cpu(htt_stats_buf->delayed_bar_6)); 1599 len += scnprintf(buf + len, buf_len - len, "delayed_bar_7 = %u\n\n", 1600 le32_to_cpu(htt_stats_buf->delayed_bar_7)); 1601 1602 stats_req->buf_len = len; 1603} 1604 1605static void 1606ath12k_htt_print_tx_selfgen_ac_stats_tlv(const void *tag_buf, u16 tag_len, 1607 struct debug_htt_stats_req *stats_req) 1608{ 1609 const struct ath12k_htt_tx_selfgen_ac_stats_tlv *htt_stats_buf = tag_buf; 1610 u8 *buf = stats_req->buf; 1611 u32 len = stats_req->buf_len; 1612 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1613 1614 if (tag_len < sizeof(*htt_stats_buf)) 1615 return; 1616 1617 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n"); 1618 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_tried = %u\n", 1619 le32_to_cpu(htt_stats_buf->ac_su_ndpa)); 1620 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_tried = %u\n", 1621 le32_to_cpu(htt_stats_buf->ac_su_ndp)); 1622 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_tried = %u\n", 1623 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndpa)); 1624 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_tried = %u\n", 1625 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndp)); 1626 len += print_array_to_buf_index(buf, len, "ac_mu_mimo_brpollX_tried = ", 1, 1627 htt_stats_buf->ac_mu_mimo_brpoll, 1628 ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS - 1, 1629 "\n\n"); 1630 1631 stats_req->buf_len = len; 1632} 1633 1634static void 1635ath12k_htt_print_tx_selfgen_ax_stats_tlv(const void *tag_buf, u16 tag_len, 1636 struct debug_htt_stats_req *stats_req) 1637{ 1638 const struct ath12k_htt_tx_selfgen_ax_stats_tlv *htt_stats_buf = tag_buf; 1639 u8 *buf = stats_req->buf; 1640 u32 len = stats_req->buf_len; 1641 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1642 1643 if (tag_len < sizeof(*htt_stats_buf)) 1644 return; 1645 1646 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n"); 1647 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_tried = %u\n", 1648 le32_to_cpu(htt_stats_buf->ax_su_ndpa)); 1649 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_tried = %u\n", 1650 le32_to_cpu(htt_stats_buf->ax_su_ndp)); 1651 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_tried = %u\n", 1652 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndpa)); 1653 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_tried = %u\n", 1654 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndp)); 1655 len += print_array_to_buf_index(buf, len, "ax_mu_mimo_brpollX_tried = ", 1, 1656 htt_stats_buf->ax_mu_mimo_brpoll, 1657 ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS - 1, "\n"); 1658 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger = %u\n", 1659 le32_to_cpu(htt_stats_buf->ax_basic_trigger)); 1660 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_total_trigger = %u\n", 1661 le32_to_cpu(htt_stats_buf->ax_ulmumimo_trigger)); 1662 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger = %u\n", 1663 le32_to_cpu(htt_stats_buf->ax_bsr_trigger)); 1664 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n", 1665 le32_to_cpu(htt_stats_buf->ax_mu_bar_trigger)); 1666 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n\n", 1667 le32_to_cpu(htt_stats_buf->ax_mu_rts_trigger)); 1668 1669 stats_req->buf_len = len; 1670} 1671 1672static void 1673ath12k_htt_print_tx_selfgen_be_stats_tlv(const void *tag_buf, u16 tag_len, 1674 struct debug_htt_stats_req *stats_req) 1675{ 1676 const struct ath12k_htt_tx_selfgen_be_stats_tlv *htt_stats_buf = tag_buf; 1677 u8 *buf = stats_req->buf; 1678 u32 len = stats_req->buf_len; 1679 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1680 1681 if (tag_len < sizeof(*htt_stats_buf)) 1682 return; 1683 1684 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_BE_STATS_TLV:\n"); 1685 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_queued = %u\n", 1686 le32_to_cpu(htt_stats_buf->be_su_ndpa_queued)); 1687 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_tried = %u\n", 1688 le32_to_cpu(htt_stats_buf->be_su_ndpa)); 1689 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_queued = %u\n", 1690 le32_to_cpu(htt_stats_buf->be_su_ndp_queued)); 1691 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_tried = %u\n", 1692 le32_to_cpu(htt_stats_buf->be_su_ndp)); 1693 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_queued = %u\n", 1694 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_queued)); 1695 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_tried = %u\n", 1696 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa)); 1697 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_queued = %u\n", 1698 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_queued)); 1699 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_tried = %u\n", 1700 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp)); 1701 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_queued = ", 1, 1702 htt_stats_buf->be_mu_mimo_brpoll_queued, 1703 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1704 "\n"); 1705 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_tried = ", 1, 1706 htt_stats_buf->be_mu_mimo_brpoll, 1707 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1708 "\n"); 1709 len += print_array_to_buf(buf, len, "be_ul_mumimo_trigger = ", 1710 htt_stats_buf->be_ul_mumimo_trigger, 1711 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n"); 1712 len += scnprintf(buf + len, buf_len - len, "be_basic_trigger = %u\n", 1713 le32_to_cpu(htt_stats_buf->be_basic_trigger)); 1714 len += scnprintf(buf + len, buf_len - len, "be_ulmumimo_total_trigger = %u\n", 1715 le32_to_cpu(htt_stats_buf->be_ulmumimo_trigger)); 1716 len += scnprintf(buf + len, buf_len - len, "be_bsr_trigger = %u\n", 1717 le32_to_cpu(htt_stats_buf->be_bsr_trigger)); 1718 len += scnprintf(buf + len, buf_len - len, "be_mu_bar_trigger = %u\n", 1719 le32_to_cpu(htt_stats_buf->be_mu_bar_trigger)); 1720 len += scnprintf(buf + len, buf_len - len, "be_mu_rts_trigger = %u\n\n", 1721 le32_to_cpu(htt_stats_buf->be_mu_rts_trigger)); 1722 1723 stats_req->buf_len = len; 1724} 1725 1726static void 1727ath12k_htt_print_tx_selfgen_ac_err_stats_tlv(const void *tag_buf, u16 tag_len, 1728 struct debug_htt_stats_req *stats_req) 1729{ 1730 const struct ath12k_htt_tx_selfgen_ac_err_stats_tlv *htt_stats_buf = tag_buf; 1731 u8 *buf = stats_req->buf; 1732 u32 len = stats_req->buf_len; 1733 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1734 1735 if (tag_len < sizeof(*htt_stats_buf)) 1736 return; 1737 1738 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n"); 1739 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_err = %u\n", 1740 le32_to_cpu(htt_stats_buf->ac_su_ndp_err)); 1741 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n", 1742 le32_to_cpu(htt_stats_buf->ac_su_ndpa_err)); 1743 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n", 1744 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndpa_err)); 1745 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n", 1746 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndp_err)); 1747 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n", 1748 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp1_err)); 1749 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n", 1750 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp2_err)); 1751 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n", 1752 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp3_err)); 1753 1754 stats_req->buf_len = len; 1755} 1756 1757static void 1758ath12k_htt_print_tx_selfgen_ax_err_stats_tlv(const void *tag_buf, u16 tag_len, 1759 struct debug_htt_stats_req *stats_req) 1760{ 1761 const struct ath12k_htt_tx_selfgen_ax_err_stats_tlv *htt_stats_buf = tag_buf; 1762 u8 *buf = stats_req->buf; 1763 u32 len = stats_req->buf_len; 1764 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1765 1766 if (tag_len < sizeof(*htt_stats_buf)) 1767 return; 1768 1769 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n"); 1770 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_err = %u\n", 1771 le32_to_cpu(htt_stats_buf->ax_su_ndp_err)); 1772 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n", 1773 le32_to_cpu(htt_stats_buf->ax_su_ndpa_err)); 1774 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n", 1775 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndpa_err)); 1776 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n", 1777 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndp_err)); 1778 len += print_array_to_buf_index(buf, len, "ax_mu_mimo_brpX_err", 1, 1779 htt_stats_buf->ax_mu_mimo_brp_err, 1780 ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS - 1, 1781 "\n"); 1782 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger_err = %u\n", 1783 le32_to_cpu(htt_stats_buf->ax_basic_trigger_err)); 1784 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_total_trigger_err = %u\n", 1785 le32_to_cpu(htt_stats_buf->ax_ulmumimo_trigger_err)); 1786 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n", 1787 le32_to_cpu(htt_stats_buf->ax_bsr_trigger_err)); 1788 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n", 1789 le32_to_cpu(htt_stats_buf->ax_mu_bar_trigger_err)); 1790 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n\n", 1791 le32_to_cpu(htt_stats_buf->ax_mu_rts_trigger_err)); 1792 1793 stats_req->buf_len = len; 1794} 1795 1796static void 1797ath12k_htt_print_tx_selfgen_be_err_stats_tlv(const void *tag_buf, u16 tag_len, 1798 struct debug_htt_stats_req *stats_req) 1799{ 1800 const struct ath12k_htt_tx_selfgen_be_err_stats_tlv *htt_stats_buf = tag_buf; 1801 u8 *buf = stats_req->buf; 1802 u32 len = stats_req->buf_len; 1803 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1804 1805 if (tag_len < sizeof(*htt_stats_buf)) 1806 return; 1807 1808 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_BE_ERR_STATS_TLV:\n"); 1809 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_err = %u\n", 1810 le32_to_cpu(htt_stats_buf->be_su_ndp_err)); 1811 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_flushed = %u\n", 1812 le32_to_cpu(htt_stats_buf->be_su_ndp_flushed)); 1813 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_err = %u\n", 1814 le32_to_cpu(htt_stats_buf->be_su_ndpa_err)); 1815 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_flushed = %u\n", 1816 le32_to_cpu(htt_stats_buf->be_su_ndpa_flushed)); 1817 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_err = %u\n", 1818 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_err)); 1819 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_flushed = %u\n", 1820 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_flushed)); 1821 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_err = %u\n", 1822 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_err)); 1823 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_flushed = %u\n", 1824 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_flushed)); 1825 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpX_err", 1, 1826 htt_stats_buf->be_mu_mimo_brp_err, 1827 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1828 "\n"); 1829 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_flushed", 1, 1830 htt_stats_buf->be_mu_mimo_brpoll_flushed, 1831 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1832 "\n"); 1833 len += print_array_to_buf(buf, len, "be_mu_mimo_num_cbf_rcvd_on_brp_err", 1834 htt_stats_buf->be_mu_mimo_brp_err_num_cbf_rxd, 1835 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n"); 1836 len += print_array_to_buf(buf, len, "be_ul_mumimo_trigger_err", 1837 htt_stats_buf->be_ul_mumimo_trigger_err, 1838 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n"); 1839 len += scnprintf(buf + len, buf_len - len, "be_basic_trigger_err = %u\n", 1840 le32_to_cpu(htt_stats_buf->be_basic_trigger_err)); 1841 len += scnprintf(buf + len, buf_len - len, "be_ulmumimo_total_trig_err = %u\n", 1842 le32_to_cpu(htt_stats_buf->be_ulmumimo_trigger_err)); 1843 len += scnprintf(buf + len, buf_len - len, "be_bsr_trigger_err = %u\n", 1844 le32_to_cpu(htt_stats_buf->be_bsr_trigger_err)); 1845 len += scnprintf(buf + len, buf_len - len, "be_mu_bar_trigger_err = %u\n", 1846 le32_to_cpu(htt_stats_buf->be_mu_bar_trigger_err)); 1847 len += scnprintf(buf + len, buf_len - len, "be_mu_rts_trigger_err = %u\n\n", 1848 le32_to_cpu(htt_stats_buf->be_mu_rts_trigger_err)); 1849 1850 stats_req->buf_len = len; 1851} 1852 1853static void 1854ath12k_htt_print_tx_selfgen_ac_sched_status_stats_tlv(const void *tag_buf, u16 tag_len, 1855 struct debug_htt_stats_req *stats) 1856{ 1857 const struct ath12k_htt_tx_selfgen_ac_sched_status_stats_tlv *htt_stats_buf = 1858 tag_buf; 1859 u8 *buf = stats->buf; 1860 u32 len = stats->buf_len; 1861 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1862 1863 if (tag_len < sizeof(*htt_stats_buf)) 1864 return; 1865 1866 len += scnprintf(buf + len, buf_len - len, 1867 "HTT_TX_SELFGEN_AC_SCHED_STATUS_STATS_TLV:\n"); 1868 len += print_array_to_buf(buf, len, "ac_su_ndpa_sch_status", 1869 htt_stats_buf->ac_su_ndpa_sch_status, 1870 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1871 len += print_array_to_buf(buf, len, "ac_su_ndp_sch_status", 1872 htt_stats_buf->ac_su_ndp_sch_status, 1873 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1874 len += print_array_to_buf(buf, len, "ac_mu_mimo_ndpa_sch_status", 1875 htt_stats_buf->ac_mu_mimo_ndpa_sch_status, 1876 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1877 len += print_array_to_buf(buf, len, "ac_mu_mimo_ndp_sch_status", 1878 htt_stats_buf->ac_mu_mimo_ndp_sch_status, 1879 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1880 len += print_array_to_buf(buf, len, "ac_mu_mimo_brp_sch_status", 1881 htt_stats_buf->ac_mu_mimo_brp_sch_status, 1882 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1883 len += print_array_to_buf(buf, len, "ac_su_ndp_sch_flag_err", 1884 htt_stats_buf->ac_su_ndp_sch_flag_err, 1885 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1886 len += print_array_to_buf(buf, len, "ac_mu_mimo_ndp_sch_flag_err", 1887 htt_stats_buf->ac_mu_mimo_ndp_sch_flag_err, 1888 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1889 len += print_array_to_buf(buf, len, "ac_mu_mimo_brp_sch_flag_err", 1890 htt_stats_buf->ac_mu_mimo_brp_sch_flag_err, 1891 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n"); 1892 1893 stats->buf_len = len; 1894} 1895 1896static void 1897ath12k_htt_print_tx_selfgen_ax_sched_status_stats_tlv(const void *tag_buf, u16 tag_len, 1898 struct debug_htt_stats_req *stats) 1899{ 1900 const struct ath12k_htt_tx_selfgen_ax_sched_status_stats_tlv *htt_stats_buf = 1901 tag_buf; 1902 u8 *buf = stats->buf; 1903 u32 len = stats->buf_len; 1904 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1905 1906 if (tag_len < sizeof(*htt_stats_buf)) 1907 return; 1908 1909 len += scnprintf(buf + len, buf_len - len, 1910 "HTT_TX_SELFGEN_AX_SCHED_STATUS_STATS_TLV:\n"); 1911 len += print_array_to_buf(buf, len, "ax_su_ndpa_sch_status", 1912 htt_stats_buf->ax_su_ndpa_sch_status, 1913 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1914 len += print_array_to_buf(buf, len, "ax_su_ndp_sch_status", 1915 htt_stats_buf->ax_su_ndp_sch_status, 1916 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1917 len += print_array_to_buf(buf, len, "ax_mu_mimo_ndpa_sch_status", 1918 htt_stats_buf->ax_mu_mimo_ndpa_sch_status, 1919 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1920 len += print_array_to_buf(buf, len, "ax_mu_mimo_ndp_sch_status", 1921 htt_stats_buf->ax_mu_mimo_ndp_sch_status, 1922 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1923 len += print_array_to_buf(buf, len, "ax_mu_brp_sch_status", 1924 htt_stats_buf->ax_mu_brp_sch_status, 1925 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1926 len += print_array_to_buf(buf, len, "ax_mu_bar_sch_status", 1927 htt_stats_buf->ax_mu_bar_sch_status, 1928 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1929 len += print_array_to_buf(buf, len, "ax_basic_trig_sch_status", 1930 htt_stats_buf->ax_basic_trig_sch_status, 1931 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1932 len += print_array_to_buf(buf, len, "ax_su_ndp_sch_flag_err", 1933 htt_stats_buf->ax_su_ndp_sch_flag_err, 1934 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1935 len += print_array_to_buf(buf, len, "ax_mu_mimo_ndp_sch_flag_err", 1936 htt_stats_buf->ax_mu_mimo_ndp_sch_flag_err, 1937 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1938 len += print_array_to_buf(buf, len, "ax_mu_brp_sch_flag_err", 1939 htt_stats_buf->ax_mu_brp_sch_flag_err, 1940 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1941 len += print_array_to_buf(buf, len, "ax_mu_bar_sch_flag_err", 1942 htt_stats_buf->ax_mu_bar_sch_flag_err, 1943 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1944 len += print_array_to_buf(buf, len, "ax_basic_trig_sch_flag_err", 1945 htt_stats_buf->ax_basic_trig_sch_flag_err, 1946 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1947 len += print_array_to_buf(buf, len, "ax_ulmumimo_trig_sch_status", 1948 htt_stats_buf->ax_ulmumimo_trig_sch_status, 1949 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1950 len += print_array_to_buf(buf, len, "ax_ulmumimo_trig_sch_flag_err", 1951 htt_stats_buf->ax_ulmumimo_trig_sch_flag_err, 1952 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n"); 1953 1954 stats->buf_len = len; 1955} 1956 1957static void 1958ath12k_htt_print_tx_selfgen_be_sched_status_stats_tlv(const void *tag_buf, u16 tag_len, 1959 struct debug_htt_stats_req *stats) 1960{ 1961 const struct ath12k_htt_tx_selfgen_be_sched_status_stats_tlv *htt_stats_buf = 1962 tag_buf; 1963 u8 *buf = stats->buf; 1964 u32 len = stats->buf_len; 1965 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1966 1967 if (tag_len < sizeof(*htt_stats_buf)) 1968 return; 1969 1970 len += scnprintf(buf + len, buf_len - len, 1971 "HTT_TX_SELFGEN_BE_SCHED_STATUS_STATS_TLV:\n"); 1972 len += print_array_to_buf(buf, len, "be_su_ndpa_sch_status", 1973 htt_stats_buf->be_su_ndpa_sch_status, 1974 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1975 len += print_array_to_buf(buf, len, "be_su_ndp_sch_status", 1976 htt_stats_buf->be_su_ndp_sch_status, 1977 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1978 len += print_array_to_buf(buf, len, "be_mu_mimo_ndpa_sch_status", 1979 htt_stats_buf->be_mu_mimo_ndpa_sch_status, 1980 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1981 len += print_array_to_buf(buf, len, "be_mu_mimo_ndp_sch_status", 1982 htt_stats_buf->be_mu_mimo_ndp_sch_status, 1983 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1984 len += print_array_to_buf(buf, len, "be_mu_brp_sch_status", 1985 htt_stats_buf->be_mu_brp_sch_status, 1986 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1987 len += print_array_to_buf(buf, len, "be_mu_bar_sch_status", 1988 htt_stats_buf->be_mu_bar_sch_status, 1989 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1990 len += print_array_to_buf(buf, len, "be_basic_trig_sch_status", 1991 htt_stats_buf->be_basic_trig_sch_status, 1992 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1993 len += print_array_to_buf(buf, len, "be_su_ndp_sch_flag_err", 1994 htt_stats_buf->be_su_ndp_sch_flag_err, 1995 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1996 len += print_array_to_buf(buf, len, "be_mu_mimo_ndp_sch_flag_err", 1997 htt_stats_buf->be_mu_mimo_ndp_sch_flag_err, 1998 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1999 len += print_array_to_buf(buf, len, "be_mu_brp_sch_flag_err", 2000 htt_stats_buf->be_mu_brp_sch_flag_err, 2001 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 2002 len += print_array_to_buf(buf, len, "be_mu_bar_sch_flag_err", 2003 htt_stats_buf->be_mu_bar_sch_flag_err, 2004 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 2005 len += print_array_to_buf(buf, len, "be_basic_trig_sch_flag_err", 2006 htt_stats_buf->be_basic_trig_sch_flag_err, 2007 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 2008 len += print_array_to_buf(buf, len, "be_basic_trig_sch_flag_err", 2009 htt_stats_buf->be_basic_trig_sch_flag_err, 2010 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 2011 len += print_array_to_buf(buf, len, "be_ulmumimo_trig_sch_flag_err", 2012 htt_stats_buf->be_ulmumimo_trig_sch_flag_err, 2013 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n"); 2014 2015 stats->buf_len = len; 2016} 2017 2018static void 2019ath12k_htt_print_stats_string_tlv(const void *tag_buf, u16 tag_len, 2020 struct debug_htt_stats_req *stats_req) 2021{ 2022 const struct ath12k_htt_stats_string_tlv *htt_stats_buf = tag_buf; 2023 u8 *buf = stats_req->buf; 2024 u32 len = stats_req->buf_len; 2025 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2026 u8 i; 2027 u16 index = 0; 2028 u32 datum; 2029 char data[ATH12K_HTT_MAX_STRING_LEN] = {}; 2030 2031 tag_len = tag_len >> 2; 2032 2033 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n"); 2034 for (i = 0; i < tag_len; i++) { 2035 datum = __le32_to_cpu(htt_stats_buf->data[i]); 2036 index += scnprintf(&data[index], ATH12K_HTT_MAX_STRING_LEN - index, 2037 "%.*s", 4, (char *)&datum); 2038 if (index >= ATH12K_HTT_MAX_STRING_LEN) 2039 break; 2040 } 2041 len += scnprintf(buf + len, buf_len - len, "data = %s\n\n", data); 2042 2043 stats_req->buf_len = len; 2044} 2045 2046static void 2047ath12k_htt_print_sring_stats_tlv(const void *tag_buf, u16 tag_len, 2048 struct debug_htt_stats_req *stats_req) 2049{ 2050 const struct ath12k_htt_sring_stats_tlv *htt_stats_buf = tag_buf; 2051 u8 *buf = stats_req->buf; 2052 u32 len = stats_req->buf_len; 2053 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2054 u32 mac_id_word; 2055 u32 avail_words; 2056 u32 head_tail_ptr; 2057 u32 sring_stat; 2058 u32 tail_ptr; 2059 2060 if (tag_len < sizeof(*htt_stats_buf)) 2061 return; 2062 2063 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__ring_id__arena__ep); 2064 avail_words = __le32_to_cpu(htt_stats_buf->num_avail_words__num_valid_words); 2065 head_tail_ptr = __le32_to_cpu(htt_stats_buf->head_ptr__tail_ptr); 2066 sring_stat = __le32_to_cpu(htt_stats_buf->consumer_empty__producer_full); 2067 tail_ptr = __le32_to_cpu(htt_stats_buf->prefetch_count__internal_tail_ptr); 2068 2069 len += scnprintf(buf + len, buf_len - len, "HTT_SRING_STATS_TLV:\n"); 2070 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 2071 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_MAC_ID)); 2072 len += scnprintf(buf + len, buf_len - len, "ring_id = %u\n", 2073 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_RING_ID)); 2074 len += scnprintf(buf + len, buf_len - len, "arena = %u\n", 2075 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_ARENA)); 2076 len += scnprintf(buf + len, buf_len - len, "ep = %u\n", 2077 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_EP)); 2078 len += scnprintf(buf + len, buf_len - len, "base_addr_lsb = 0x%x\n", 2079 le32_to_cpu(htt_stats_buf->base_addr_lsb)); 2080 len += scnprintf(buf + len, buf_len - len, "base_addr_msb = 0x%x\n", 2081 le32_to_cpu(htt_stats_buf->base_addr_msb)); 2082 len += scnprintf(buf + len, buf_len - len, "ring_size = %u\n", 2083 le32_to_cpu(htt_stats_buf->ring_size)); 2084 len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n", 2085 le32_to_cpu(htt_stats_buf->elem_size)); 2086 len += scnprintf(buf + len, buf_len - len, "num_avail_words = %u\n", 2087 u32_get_bits(avail_words, 2088 ATH12K_HTT_SRING_STATS_NUM_AVAIL_WORDS)); 2089 len += scnprintf(buf + len, buf_len - len, "num_valid_words = %u\n", 2090 u32_get_bits(avail_words, 2091 ATH12K_HTT_SRING_STATS_NUM_VALID_WORDS)); 2092 len += scnprintf(buf + len, buf_len - len, "head_ptr = %u\n", 2093 u32_get_bits(head_tail_ptr, ATH12K_HTT_SRING_STATS_HEAD_PTR)); 2094 len += scnprintf(buf + len, buf_len - len, "tail_ptr = %u\n", 2095 u32_get_bits(head_tail_ptr, ATH12K_HTT_SRING_STATS_TAIL_PTR)); 2096 len += scnprintf(buf + len, buf_len - len, "consumer_empty = %u\n", 2097 u32_get_bits(sring_stat, 2098 ATH12K_HTT_SRING_STATS_CONSUMER_EMPTY)); 2099 len += scnprintf(buf + len, buf_len - len, "producer_full = %u\n", 2100 u32_get_bits(head_tail_ptr, 2101 ATH12K_HTT_SRING_STATS_PRODUCER_FULL)); 2102 len += scnprintf(buf + len, buf_len - len, "prefetch_count = %u\n", 2103 u32_get_bits(tail_ptr, ATH12K_HTT_SRING_STATS_PREFETCH_COUNT)); 2104 len += scnprintf(buf + len, buf_len - len, "internal_tail_ptr = %u\n\n", 2105 u32_get_bits(tail_ptr, 2106 ATH12K_HTT_SRING_STATS_INTERNAL_TAIL_PTR)); 2107 2108 stats_req->buf_len = len; 2109} 2110 2111static void 2112ath12k_htt_print_sfm_cmn_tlv(const void *tag_buf, u16 tag_len, 2113 struct debug_htt_stats_req *stats_req) 2114{ 2115 const struct ath12k_htt_sfm_cmn_tlv *htt_stats_buf = tag_buf; 2116 u8 *buf = stats_req->buf; 2117 u32 len = stats_req->buf_len; 2118 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2119 u32 mac_id_word; 2120 2121 if (tag_len < sizeof(*htt_stats_buf)) 2122 return; 2123 2124 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 2125 2126 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CMN_TLV:\n"); 2127 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 2128 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 2129 len += scnprintf(buf + len, buf_len - len, "buf_total = %u\n", 2130 le32_to_cpu(htt_stats_buf->buf_total)); 2131 len += scnprintf(buf + len, buf_len - len, "mem_empty = %u\n", 2132 le32_to_cpu(htt_stats_buf->mem_empty)); 2133 len += scnprintf(buf + len, buf_len - len, "deallocate_bufs = %u\n", 2134 le32_to_cpu(htt_stats_buf->deallocate_bufs)); 2135 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n", 2136 le32_to_cpu(htt_stats_buf->num_records)); 2137 2138 stats_req->buf_len = len; 2139} 2140 2141static void 2142ath12k_htt_print_sfm_client_tlv(const void *tag_buf, u16 tag_len, 2143 struct debug_htt_stats_req *stats_req) 2144{ 2145 const struct ath12k_htt_sfm_client_tlv *htt_stats_buf = tag_buf; 2146 u8 *buf = stats_req->buf; 2147 u32 len = stats_req->buf_len; 2148 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2149 2150 if (tag_len < sizeof(*htt_stats_buf)) 2151 return; 2152 2153 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_TLV:\n"); 2154 len += scnprintf(buf + len, buf_len - len, "client_id = %u\n", 2155 le32_to_cpu(htt_stats_buf->client_id)); 2156 len += scnprintf(buf + len, buf_len - len, "buf_min = %u\n", 2157 le32_to_cpu(htt_stats_buf->buf_min)); 2158 len += scnprintf(buf + len, buf_len - len, "buf_max = %u\n", 2159 le32_to_cpu(htt_stats_buf->buf_max)); 2160 len += scnprintf(buf + len, buf_len - len, "buf_busy = %u\n", 2161 le32_to_cpu(htt_stats_buf->buf_busy)); 2162 len += scnprintf(buf + len, buf_len - len, "buf_alloc = %u\n", 2163 le32_to_cpu(htt_stats_buf->buf_alloc)); 2164 len += scnprintf(buf + len, buf_len - len, "buf_avail = %u\n", 2165 le32_to_cpu(htt_stats_buf->buf_avail)); 2166 len += scnprintf(buf + len, buf_len - len, "num_users = %u\n\n", 2167 le32_to_cpu(htt_stats_buf->num_users)); 2168 2169 stats_req->buf_len = len; 2170} 2171 2172static void 2173ath12k_htt_print_sfm_client_user_tlv(const void *tag_buf, u16 tag_len, 2174 struct debug_htt_stats_req *stats_req) 2175{ 2176 const struct ath12k_htt_sfm_client_user_tlv *htt_stats_buf = tag_buf; 2177 u8 *buf = stats_req->buf; 2178 u32 len = stats_req->buf_len; 2179 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2180 u16 num_elems = tag_len >> 2; 2181 2182 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_USER_TLV:\n"); 2183 len += print_array_to_buf(buf, len, "dwords_used_by_user_n", 2184 htt_stats_buf->dwords_used_by_user_n, 2185 num_elems, "\n\n"); 2186 2187 stats_req->buf_len = len; 2188} 2189 2190static void 2191ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(const void *tag_buf, u16 tag_len, 2192 struct debug_htt_stats_req *stats_req) 2193{ 2194 const struct ath12k_htt_tx_pdev_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf; 2195 u8 *buf = stats_req->buf; 2196 u32 len = stats_req->buf_len; 2197 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2198 u8 i; 2199 2200 if (tag_len < sizeof(*htt_stats_buf)) 2201 return; 2202 2203 len += scnprintf(buf + len, buf_len - len, 2204 "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n"); 2205 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n", 2206 le32_to_cpu(htt_stats_buf->mu_mimo_sch_posted)); 2207 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n", 2208 le32_to_cpu(htt_stats_buf->mu_mimo_sch_failed)); 2209 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n", 2210 le32_to_cpu(htt_stats_buf->mu_mimo_ppdu_posted)); 2211 len += scnprintf(buf + len, buf_len - len, 2212 "\nac_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0, 2213 le32_to_cpu(htt_stats_buf->ac_mu_mimo_per_grp_sz[0])); 2214 for (i = 1; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) { 2215 len += scnprintf(buf + len, buf_len - len, 2216 "ac_mu_mimo_sch_posted_per_group_index %u ", i); 2217 len += scnprintf(buf + len, buf_len - len, 2218 "(TOTAL STREAMS = %u) = %u\n", i + 1, 2219 le32_to_cpu(htt_stats_buf->ac_mu_mimo_per_grp_sz[i])); 2220 } 2221 2222 for (i = 0; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) { 2223 len += scnprintf(buf + len, buf_len - len, 2224 "ac_mu_mimo_sch_posted_per_group_index %u ", 2225 i + ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS); 2226 len += scnprintf(buf + len, buf_len - len, 2227 "(TOTAL STREAMS = %u) = %u\n", 2228 i + ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS + 1, 2229 le32_to_cpu(htt_stats_buf->ac_mu_mimo_grp_sz_ext[i])); 2230 } 2231 2232 len += scnprintf(buf + len, buf_len - len, 2233 "\nax_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0, 2234 le32_to_cpu(htt_stats_buf->ax_mu_mimo_per_grp_sz[0])); 2235 for (i = 1; i < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; i++) { 2236 len += scnprintf(buf + len, buf_len - len, 2237 "ax_mu_mimo_sch_posted_per_group_index %u ", i); 2238 len += scnprintf(buf + len, buf_len - len, 2239 "(TOTAL STREAMS = %u) = %u\n", i + 1, 2240 le32_to_cpu(htt_stats_buf->ax_mu_mimo_per_grp_sz[i])); 2241 } 2242 2243 len += scnprintf(buf + len, buf_len - len, 2244 "\nbe_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0, 2245 le32_to_cpu(htt_stats_buf->be_mu_mimo_per_grp_sz[0])); 2246 for (i = 1; i < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; i++) { 2247 len += scnprintf(buf + len, buf_len - len, 2248 "be_mu_mimo_sch_posted_per_group_index %u ", i); 2249 len += scnprintf(buf + len, buf_len - len, 2250 "(TOTAL STREAMS = %u) = %u\n", i + 1, 2251 le32_to_cpu(htt_stats_buf->be_mu_mimo_per_grp_sz[i])); 2252 } 2253 2254 len += scnprintf(buf + len, buf_len - len, "\n11ac MU_MIMO SCH STATS:\n"); 2255 for (i = 0; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) { 2256 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_sch_nusers_"); 2257 len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i, 2258 le32_to_cpu(htt_stats_buf->ac_mu_mimo_sch_nusers[i])); 2259 } 2260 2261 len += scnprintf(buf + len, buf_len - len, "\n11ax MU_MIMO SCH STATS:\n"); 2262 for (i = 0; i < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; i++) { 2263 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_sch_nusers_"); 2264 len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i, 2265 le32_to_cpu(htt_stats_buf->ax_mu_mimo_sch_nusers[i])); 2266 } 2267 2268 len += scnprintf(buf + len, buf_len - len, "\n11be MU_MIMO SCH STATS:\n"); 2269 for (i = 0; i < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; i++) { 2270 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_sch_nusers_"); 2271 len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i, 2272 le32_to_cpu(htt_stats_buf->be_mu_mimo_sch_nusers[i])); 2273 } 2274 2275 len += scnprintf(buf + len, buf_len - len, "\n11ax OFDMA SCH STATS:\n"); 2276 for (i = 0; i < ATH12K_HTT_TX_NUM_OFDMA_USER_STATS; i++) { 2277 len += scnprintf(buf + len, buf_len - len, 2278 "ax_ofdma_sch_nusers_%u = %u\n", i, 2279 le32_to_cpu(htt_stats_buf->ax_ofdma_sch_nusers[i])); 2280 len += scnprintf(buf + len, buf_len - len, 2281 "ax_ul_ofdma_basic_sch_nusers_%u = %u\n", i, 2282 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_nusers[i])); 2283 len += scnprintf(buf + len, buf_len - len, 2284 "ax_ul_ofdma_bsr_sch_nusers_%u = %u\n", i, 2285 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_bsr_nusers[i])); 2286 len += scnprintf(buf + len, buf_len - len, 2287 "ax_ul_ofdma_bar_sch_nusers_%u = %u\n", i, 2288 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_bar_nusers[i])); 2289 len += scnprintf(buf + len, buf_len - len, 2290 "ax_ul_ofdma_brp_sch_nusers_%u = %u\n\n", i, 2291 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_brp_nusers[i])); 2292 } 2293 2294 len += scnprintf(buf + len, buf_len - len, "11ax UL MUMIMO SCH STATS:\n"); 2295 for (i = 0; i < ATH12K_HTT_TX_NUM_UL_MUMIMO_USER_STATS; i++) { 2296 len += scnprintf(buf + len, buf_len - len, 2297 "ax_ul_mumimo_basic_sch_nusers_%u = %u\n", i, 2298 le32_to_cpu(htt_stats_buf->ax_ul_mumimo_nusers[i])); 2299 len += scnprintf(buf + len, buf_len - len, 2300 "ax_ul_mumimo_brp_sch_nusers_%u = %u\n\n", i, 2301 le32_to_cpu(htt_stats_buf->ax_ul_mumimo_brp_nusers[i])); 2302 } 2303 2304 stats_req->buf_len = len; 2305} 2306 2307static void 2308ath12k_htt_print_tx_pdev_mumimo_grp_stats_tlv(const void *tag_buf, u16 tag_len, 2309 struct debug_htt_stats_req *stats_req) 2310{ 2311 const struct ath12k_htt_tx_pdev_mumimo_grp_stats_tlv *htt_stats_buf = tag_buf; 2312 u8 *buf = stats_req->buf; 2313 u32 len = stats_req->buf_len; 2314 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2315 int j; 2316 2317 if (tag_len < sizeof(*htt_stats_buf)) 2318 return; 2319 2320 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_MUMIMO_GRP_STATS:\n"); 2321 len += print_array_to_buf(buf, len, 2322 "dl_mumimo_grp_tputs_observed (per bin = 300 mbps)", 2323 htt_stats_buf->dl_mumimo_grp_tputs, 2324 ATH12K_HTT_STATS_MUMIMO_TPUT_NUM_BINS, "\n"); 2325 len += print_array_to_buf(buf, len, "dl_mumimo_grp eligible", 2326 htt_stats_buf->dl_mumimo_grp_eligible, 2327 ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n"); 2328 len += print_array_to_buf(buf, len, "dl_mumimo_grp_ineligible", 2329 htt_stats_buf->dl_mumimo_grp_ineligible, 2330 ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n"); 2331 len += scnprintf(buf + len, buf_len - len, "dl_mumimo_grp_invalid:\n"); 2332 for (j = 0; j < ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ; j++) { 2333 len += scnprintf(buf + len, buf_len - len, "grp_id = %u", j); 2334 len += print_array_to_buf(buf, len, "", 2335 htt_stats_buf->dl_mumimo_grp_invalid, 2336 ATH12K_HTT_STATS_MAX_INVALID_REASON_CODE, 2337 "\n"); 2338 } 2339 2340 len += print_array_to_buf(buf, len, "ul_mumimo_grp_best_grp_size", 2341 htt_stats_buf->ul_mumimo_grp_best_grp_size, 2342 ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n"); 2343 len += print_array_to_buf(buf, len, "ul_mumimo_grp_best_num_usrs = ", 2344 htt_stats_buf->ul_mumimo_grp_best_usrs, 2345 ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS, "\n"); 2346 len += print_array_to_buf(buf, len, 2347 "ul_mumimo_grp_tputs_observed (per bin = 300 mbps)", 2348 htt_stats_buf->ul_mumimo_grp_tputs, 2349 ATH12K_HTT_STATS_MUMIMO_TPUT_NUM_BINS, "\n\n"); 2350 2351 stats_req->buf_len = len; 2352} 2353 2354static void 2355ath12k_htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 2356 struct debug_htt_stats_req *stats_req) 2357{ 2358 const struct ath12k_htt_tx_pdev_mpdu_stats_tlv *htt_stats_buf = tag_buf; 2359 u8 *buf = stats_req->buf; 2360 u32 len = stats_req->buf_len; 2361 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2362 u32 user_index; 2363 u32 tx_sched_mode; 2364 2365 if (tag_len < sizeof(*htt_stats_buf)) 2366 return; 2367 2368 user_index = __le32_to_cpu(htt_stats_buf->user_index); 2369 tx_sched_mode = __le32_to_cpu(htt_stats_buf->tx_sched_mode); 2370 2371 if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_MIMO_AC) { 2372 if (!user_index) 2373 len += scnprintf(buf + len, buf_len - len, 2374 "HTT_TX_PDEV_MU_MIMO_AC_MPDU_STATS:\n"); 2375 2376 if (user_index < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS) { 2377 len += scnprintf(buf + len, buf_len - len, 2378 "ac_mu_mimo_mpdus_queued_usr_%u = %u\n", 2379 user_index, 2380 le32_to_cpu(htt_stats_buf->mpdus_queued_usr)); 2381 len += scnprintf(buf + len, buf_len - len, 2382 "ac_mu_mimo_mpdus_tried_usr_%u = %u\n", 2383 user_index, 2384 le32_to_cpu(htt_stats_buf->mpdus_tried_usr)); 2385 len += scnprintf(buf + len, buf_len - len, 2386 "ac_mu_mimo_mpdus_failed_usr_%u = %u\n", 2387 user_index, 2388 le32_to_cpu(htt_stats_buf->mpdus_failed_usr)); 2389 len += scnprintf(buf + len, buf_len - len, 2390 "ac_mu_mimo_mpdus_requeued_usr_%u = %u\n", 2391 user_index, 2392 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr)); 2393 len += scnprintf(buf + len, buf_len - len, 2394 "ac_mu_mimo_err_no_ba_usr_%u = %u\n", 2395 user_index, 2396 le32_to_cpu(htt_stats_buf->err_no_ba_usr)); 2397 len += scnprintf(buf + len, buf_len - len, 2398 "ac_mu_mimo_mpdu_underrun_usr_%u = %u\n", 2399 user_index, 2400 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr)); 2401 len += scnprintf(buf + len, buf_len - len, 2402 "ac_mu_mimo_ampdu_underrun_usr_%u = %u\n\n", 2403 user_index, 2404 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr)); 2405 } 2406 } 2407 2408 if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_MIMO_AX) { 2409 if (!user_index) 2410 len += scnprintf(buf + len, buf_len - len, 2411 "HTT_TX_PDEV_MU_MIMO_AX_MPDU_STATS:\n"); 2412 2413 if (user_index < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS) { 2414 len += scnprintf(buf + len, buf_len - len, 2415 "ax_mu_mimo_mpdus_queued_usr_%u = %u\n", 2416 user_index, 2417 le32_to_cpu(htt_stats_buf->mpdus_queued_usr)); 2418 len += scnprintf(buf + len, buf_len - len, 2419 "ax_mu_mimo_mpdus_tried_usr_%u = %u\n", 2420 user_index, 2421 le32_to_cpu(htt_stats_buf->mpdus_tried_usr)); 2422 len += scnprintf(buf + len, buf_len - len, 2423 "ax_mu_mimo_mpdus_failed_usr_%u = %u\n", 2424 user_index, 2425 le32_to_cpu(htt_stats_buf->mpdus_failed_usr)); 2426 len += scnprintf(buf + len, buf_len - len, 2427 "ax_mu_mimo_mpdus_requeued_usr_%u = %u\n", 2428 user_index, 2429 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr)); 2430 len += scnprintf(buf + len, buf_len - len, 2431 "ax_mu_mimo_err_no_ba_usr_%u = %u\n", 2432 user_index, 2433 le32_to_cpu(htt_stats_buf->err_no_ba_usr)); 2434 len += scnprintf(buf + len, buf_len - len, 2435 "ax_mu_mimo_mpdu_underrun_usr_%u = %u\n", 2436 user_index, 2437 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr)); 2438 len += scnprintf(buf + len, buf_len - len, 2439 "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n\n", 2440 user_index, 2441 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr)); 2442 } 2443 } 2444 2445 if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_OFDMA_AX) { 2446 if (!user_index) 2447 len += scnprintf(buf + len, buf_len - len, 2448 "HTT_TX_PDEV_AX_MU_OFDMA_MPDU_STATS:\n"); 2449 2450 if (user_index < ATH12K_HTT_TX_NUM_OFDMA_USER_STATS) { 2451 len += scnprintf(buf + len, buf_len - len, 2452 "ax_mu_ofdma_mpdus_queued_usr_%u = %u\n", 2453 user_index, 2454 le32_to_cpu(htt_stats_buf->mpdus_queued_usr)); 2455 len += scnprintf(buf + len, buf_len - len, 2456 "ax_mu_ofdma_mpdus_tried_usr_%u = %u\n", 2457 user_index, 2458 le32_to_cpu(htt_stats_buf->mpdus_tried_usr)); 2459 len += scnprintf(buf + len, buf_len - len, 2460 "ax_mu_ofdma_mpdus_failed_usr_%u = %u\n", 2461 user_index, 2462 le32_to_cpu(htt_stats_buf->mpdus_failed_usr)); 2463 len += scnprintf(buf + len, buf_len - len, 2464 "ax_mu_ofdma_mpdus_requeued_usr_%u = %u\n", 2465 user_index, 2466 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr)); 2467 len += scnprintf(buf + len, buf_len - len, 2468 "ax_mu_ofdma_err_no_ba_usr_%u = %u\n", 2469 user_index, 2470 le32_to_cpu(htt_stats_buf->err_no_ba_usr)); 2471 len += scnprintf(buf + len, buf_len - len, 2472 "ax_mu_ofdma_mpdu_underrun_usr_%u = %u\n", 2473 user_index, 2474 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr)); 2475 len += scnprintf(buf + len, buf_len - len, 2476 "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n\n", 2477 user_index, 2478 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr)); 2479 } 2480 } 2481 2482 stats_req->buf_len = len; 2483} 2484 2485static void 2486ath12k_htt_print_pdev_cca_stats_hist_tlv(const void *tag_buf, u16 tag_len, 2487 struct debug_htt_stats_req *stats_req) 2488{ 2489 const struct ath12k_htt_pdev_cca_stats_hist_v1_tlv *htt_stats_buf = tag_buf; 2490 u8 *buf = stats_req->buf; 2491 u32 len = stats_req->buf_len; 2492 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2493 2494 if (tag_len < sizeof(*htt_stats_buf)) 2495 return; 2496 2497 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_CCA_STATS_HIST_TLV :\n"); 2498 len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n", 2499 le32_to_cpu(htt_stats_buf->chan_num)); 2500 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n", 2501 le32_to_cpu(htt_stats_buf->num_records)); 2502 len += scnprintf(buf + len, buf_len - len, "valid_cca_counters_bitmap = 0x%x\n", 2503 le32_to_cpu(htt_stats_buf->valid_cca_counters_bitmap)); 2504 len += scnprintf(buf + len, buf_len - len, "collection_interval = %u\n\n", 2505 le32_to_cpu(htt_stats_buf->collection_interval)); 2506 2507 stats_req->buf_len = len; 2508} 2509 2510static void 2511ath12k_htt_print_pdev_stats_cca_counters_tlv(const void *tag_buf, u16 tag_len, 2512 struct debug_htt_stats_req *stats_req) 2513{ 2514 const struct ath12k_htt_pdev_stats_cca_counters_tlv *htt_stats_buf = tag_buf; 2515 u8 *buf = stats_req->buf; 2516 u32 len = stats_req->buf_len; 2517 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2518 2519 if (tag_len < sizeof(*htt_stats_buf)) 2520 return; 2521 2522 len += scnprintf(buf + len, buf_len - len, 2523 "HTT_PDEV_STATS_CCA_COUNTERS_TLV:(in usec)\n"); 2524 len += scnprintf(buf + len, buf_len - len, "tx_frame_usec = %u\n", 2525 le32_to_cpu(htt_stats_buf->tx_frame_usec)); 2526 len += scnprintf(buf + len, buf_len - len, "rx_frame_usec = %u\n", 2527 le32_to_cpu(htt_stats_buf->rx_frame_usec)); 2528 len += scnprintf(buf + len, buf_len - len, "rx_clear_usec = %u\n", 2529 le32_to_cpu(htt_stats_buf->rx_clear_usec)); 2530 len += scnprintf(buf + len, buf_len - len, "my_rx_frame_usec = %u\n", 2531 le32_to_cpu(htt_stats_buf->my_rx_frame_usec)); 2532 len += scnprintf(buf + len, buf_len - len, "usec_cnt = %u\n", 2533 le32_to_cpu(htt_stats_buf->usec_cnt)); 2534 len += scnprintf(buf + len, buf_len - len, "med_rx_idle_usec = %u\n", 2535 le32_to_cpu(htt_stats_buf->med_rx_idle_usec)); 2536 len += scnprintf(buf + len, buf_len - len, "med_tx_idle_global_usec = %u\n", 2537 le32_to_cpu(htt_stats_buf->med_tx_idle_global_usec)); 2538 len += scnprintf(buf + len, buf_len - len, "cca_obss_usec = %u\n\n", 2539 le32_to_cpu(htt_stats_buf->cca_obss_usec)); 2540 2541 stats_req->buf_len = len; 2542} 2543 2544static void 2545ath12k_htt_print_tx_sounding_stats_tlv(const void *tag_buf, u16 tag_len, 2546 struct debug_htt_stats_req *stats_req) 2547{ 2548 const struct ath12k_htt_tx_sounding_stats_tlv *htt_stats_buf = tag_buf; 2549 const __le32 *cbf_20, *cbf_40, *cbf_80, *cbf_160, *cbf_320; 2550 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2551 u32 len = stats_req->buf_len; 2552 u8 *buf = stats_req->buf; 2553 u32 tx_sounding_mode; 2554 u8 i, u; 2555 2556 if (tag_len < sizeof(*htt_stats_buf)) 2557 return; 2558 2559 cbf_20 = htt_stats_buf->cbf_20; 2560 cbf_40 = htt_stats_buf->cbf_40; 2561 cbf_80 = htt_stats_buf->cbf_80; 2562 cbf_160 = htt_stats_buf->cbf_160; 2563 cbf_320 = htt_stats_buf->cbf_320; 2564 tx_sounding_mode = le32_to_cpu(htt_stats_buf->tx_sounding_mode); 2565 2566 if (tx_sounding_mode == ATH12K_HTT_TX_AC_SOUNDING_MODE) { 2567 len += scnprintf(buf + len, buf_len - len, 2568 "HTT_TX_AC_SOUNDING_STATS_TLV:\n"); 2569 len += scnprintf(buf + len, buf_len - len, 2570 "ac_cbf_20 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2571 le32_to_cpu(cbf_20[ATH12K_HTT_IMPL_STEER_STATS]), 2572 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2573 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2574 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2575 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2576 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2577 len += scnprintf(buf + len, buf_len - len, 2578 "ac_cbf_40 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2579 le32_to_cpu(cbf_40[ATH12K_HTT_IMPL_STEER_STATS]), 2580 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2581 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2582 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2583 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2584 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2585 len += scnprintf(buf + len, buf_len - len, 2586 "ac_cbf_80 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2587 le32_to_cpu(cbf_80[ATH12K_HTT_IMPL_STEER_STATS]), 2588 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2589 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2590 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2591 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2592 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2593 len += scnprintf(buf + len, buf_len - len, 2594 "ac_cbf_160 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2595 le32_to_cpu(cbf_160[ATH12K_HTT_IMPL_STEER_STATS]), 2596 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2597 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2598 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2599 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2600 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2601 2602 for (u = 0, i = 0; u < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; u++) { 2603 len += scnprintf(buf + len, buf_len - len, 2604 "Sounding User_%u = 20MHz: %u, ", u, 2605 le32_to_cpu(htt_stats_buf->sounding[i++])); 2606 len += scnprintf(buf + len, buf_len - len, "40MHz: %u, ", 2607 le32_to_cpu(htt_stats_buf->sounding[i++])); 2608 len += scnprintf(buf + len, buf_len - len, "80MHz: %u, ", 2609 le32_to_cpu(htt_stats_buf->sounding[i++])); 2610 len += scnprintf(buf + len, buf_len - len, "160MHz: %u\n", 2611 le32_to_cpu(htt_stats_buf->sounding[i++])); 2612 } 2613 } else if (tx_sounding_mode == ATH12K_HTT_TX_AX_SOUNDING_MODE) { 2614 len += scnprintf(buf + len, buf_len - len, 2615 "\nHTT_TX_AX_SOUNDING_STATS_TLV:\n"); 2616 len += scnprintf(buf + len, buf_len - len, 2617 "ax_cbf_20 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2618 le32_to_cpu(cbf_20[ATH12K_HTT_IMPL_STEER_STATS]), 2619 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2620 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2621 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2622 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2623 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2624 len += scnprintf(buf + len, buf_len - len, 2625 "ax_cbf_40 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2626 le32_to_cpu(cbf_40[ATH12K_HTT_IMPL_STEER_STATS]), 2627 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2628 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2629 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2630 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2631 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2632 len += scnprintf(buf + len, buf_len - len, 2633 "ax_cbf_80 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2634 le32_to_cpu(cbf_80[ATH12K_HTT_IMPL_STEER_STATS]), 2635 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2636 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2637 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2638 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2639 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2640 len += scnprintf(buf + len, buf_len - len, 2641 "ax_cbf_160 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2642 le32_to_cpu(cbf_160[ATH12K_HTT_IMPL_STEER_STATS]), 2643 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2644 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2645 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2646 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2647 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2648 2649 for (u = 0, i = 0; u < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; u++) { 2650 len += scnprintf(buf + len, buf_len - len, 2651 "Sounding User_%u = 20MHz: %u, ", u, 2652 le32_to_cpu(htt_stats_buf->sounding[i++])); 2653 len += scnprintf(buf + len, buf_len - len, "40MHz: %u, ", 2654 le32_to_cpu(htt_stats_buf->sounding[i++])); 2655 len += scnprintf(buf + len, buf_len - len, "80MHz: %u, ", 2656 le32_to_cpu(htt_stats_buf->sounding[i++])); 2657 len += scnprintf(buf + len, buf_len - len, "160MHz: %u\n", 2658 le32_to_cpu(htt_stats_buf->sounding[i++])); 2659 } 2660 } else if (tx_sounding_mode == ATH12K_HTT_TX_BE_SOUNDING_MODE) { 2661 len += scnprintf(buf + len, buf_len - len, 2662 "\nHTT_TX_BE_SOUNDING_STATS_TLV:\n"); 2663 len += scnprintf(buf + len, buf_len - len, 2664 "be_cbf_20 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2665 le32_to_cpu(cbf_20[ATH12K_HTT_IMPL_STEER_STATS]), 2666 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2667 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2668 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2669 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2670 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2671 len += scnprintf(buf + len, buf_len - len, 2672 "be_cbf_40 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2673 le32_to_cpu(cbf_40[ATH12K_HTT_IMPL_STEER_STATS]), 2674 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2675 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2676 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2677 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2678 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2679 len += scnprintf(buf + len, buf_len - len, 2680 "be_cbf_80 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2681 le32_to_cpu(cbf_80[ATH12K_HTT_IMPL_STEER_STATS]), 2682 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2683 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2684 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2685 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2686 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2687 len += scnprintf(buf + len, buf_len - len, 2688 "be_cbf_160 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2689 le32_to_cpu(cbf_160[ATH12K_HTT_IMPL_STEER_STATS]), 2690 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2691 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2692 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2693 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2694 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2695 len += scnprintf(buf + len, buf_len - len, 2696 "be_cbf_320 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ", 2697 le32_to_cpu(cbf_320[ATH12K_HTT_IMPL_STEER_STATS]), 2698 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]), 2699 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_SURBO_STEER_STATS])); 2700 len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n", 2701 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]), 2702 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_MURBO_STEER_STATS])); 2703 for (u = 0, i = 0; u < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; u++) { 2704 len += scnprintf(buf + len, buf_len - len, 2705 "Sounding User_%u = 20MHz: %u, ", u, 2706 le32_to_cpu(htt_stats_buf->sounding[i++])); 2707 len += scnprintf(buf + len, buf_len - len, "40MHz: %u, ", 2708 le32_to_cpu(htt_stats_buf->sounding[i++])); 2709 len += scnprintf(buf + len, buf_len - len, "80MHz: %u, ", 2710 le32_to_cpu(htt_stats_buf->sounding[i++])); 2711 len += scnprintf(buf + len, buf_len - len, 2712 "160MHz: %u, 320MHz: %u\n", 2713 le32_to_cpu(htt_stats_buf->sounding[i++]), 2714 le32_to_cpu(htt_stats_buf->sounding_320[u])); 2715 } 2716 } else if (tx_sounding_mode == ATH12K_HTT_TX_CMN_SOUNDING_MODE) { 2717 len += scnprintf(buf + len, buf_len - len, 2718 "\nCV UPLOAD HANDLER STATS:\n"); 2719 len += scnprintf(buf + len, buf_len - len, "cv_nc_mismatch_err = %u\n", 2720 le32_to_cpu(htt_stats_buf->cv_nc_mismatch_err)); 2721 len += scnprintf(buf + len, buf_len - len, "cv_fcs_err = %u\n", 2722 le32_to_cpu(htt_stats_buf->cv_fcs_err)); 2723 len += scnprintf(buf + len, buf_len - len, "cv_frag_idx_mismatch = %u\n", 2724 le32_to_cpu(htt_stats_buf->cv_frag_idx_mismatch)); 2725 len += scnprintf(buf + len, buf_len - len, "cv_invalid_peer_id = %u\n", 2726 le32_to_cpu(htt_stats_buf->cv_invalid_peer_id)); 2727 len += scnprintf(buf + len, buf_len - len, "cv_no_txbf_setup = %u\n", 2728 le32_to_cpu(htt_stats_buf->cv_no_txbf_setup)); 2729 len += scnprintf(buf + len, buf_len - len, "cv_expiry_in_update = %u\n", 2730 le32_to_cpu(htt_stats_buf->cv_expiry_in_update)); 2731 len += scnprintf(buf + len, buf_len - len, "cv_pkt_bw_exceed = %u\n", 2732 le32_to_cpu(htt_stats_buf->cv_pkt_bw_exceed)); 2733 len += scnprintf(buf + len, buf_len - len, "cv_dma_not_done_err = %u\n", 2734 le32_to_cpu(htt_stats_buf->cv_dma_not_done_err)); 2735 len += scnprintf(buf + len, buf_len - len, "cv_update_failed = %u\n", 2736 le32_to_cpu(htt_stats_buf->cv_update_failed)); 2737 len += scnprintf(buf + len, buf_len - len, "cv_dma_timeout_error = %u\n", 2738 le32_to_cpu(htt_stats_buf->cv_dma_timeout_error)); 2739 len += scnprintf(buf + len, buf_len - len, "cv_buf_ibf_uploads = %u\n", 2740 le32_to_cpu(htt_stats_buf->cv_buf_ibf_uploads)); 2741 len += scnprintf(buf + len, buf_len - len, "cv_buf_ebf_uploads = %u\n", 2742 le32_to_cpu(htt_stats_buf->cv_buf_ebf_uploads)); 2743 len += scnprintf(buf + len, buf_len - len, "cv_buf_received = %u\n", 2744 le32_to_cpu(htt_stats_buf->cv_buf_received)); 2745 len += scnprintf(buf + len, buf_len - len, "cv_buf_fed_back = %u\n\n", 2746 le32_to_cpu(htt_stats_buf->cv_buf_fed_back)); 2747 2748 len += scnprintf(buf + len, buf_len - len, "CV QUERY STATS:\n"); 2749 len += scnprintf(buf + len, buf_len - len, "cv_total_query = %u\n", 2750 le32_to_cpu(htt_stats_buf->cv_total_query)); 2751 len += scnprintf(buf + len, buf_len - len, 2752 "cv_total_pattern_query = %u\n", 2753 le32_to_cpu(htt_stats_buf->cv_total_pattern_query)); 2754 len += scnprintf(buf + len, buf_len - len, "cv_total_bw_query = %u\n", 2755 le32_to_cpu(htt_stats_buf->cv_total_bw_query)); 2756 len += scnprintf(buf + len, buf_len - len, "cv_invalid_bw_coding = %u\n", 2757 le32_to_cpu(htt_stats_buf->cv_invalid_bw_coding)); 2758 len += scnprintf(buf + len, buf_len - len, "cv_forced_sounding = %u\n", 2759 le32_to_cpu(htt_stats_buf->cv_forced_sounding)); 2760 len += scnprintf(buf + len, buf_len - len, 2761 "cv_standalone_sounding = %u\n", 2762 le32_to_cpu(htt_stats_buf->cv_standalone_sounding)); 2763 len += scnprintf(buf + len, buf_len - len, "cv_nc_mismatch = %u\n", 2764 le32_to_cpu(htt_stats_buf->cv_nc_mismatch)); 2765 len += scnprintf(buf + len, buf_len - len, "cv_fb_type_mismatch = %u\n", 2766 le32_to_cpu(htt_stats_buf->cv_fb_type_mismatch)); 2767 len += scnprintf(buf + len, buf_len - len, "cv_ofdma_bw_mismatch = %u\n", 2768 le32_to_cpu(htt_stats_buf->cv_ofdma_bw_mismatch)); 2769 len += scnprintf(buf + len, buf_len - len, "cv_bw_mismatch = %u\n", 2770 le32_to_cpu(htt_stats_buf->cv_bw_mismatch)); 2771 len += scnprintf(buf + len, buf_len - len, "cv_pattern_mismatch = %u\n", 2772 le32_to_cpu(htt_stats_buf->cv_pattern_mismatch)); 2773 len += scnprintf(buf + len, buf_len - len, "cv_preamble_mismatch = %u\n", 2774 le32_to_cpu(htt_stats_buf->cv_preamble_mismatch)); 2775 len += scnprintf(buf + len, buf_len - len, "cv_nr_mismatch = %u\n", 2776 le32_to_cpu(htt_stats_buf->cv_nr_mismatch)); 2777 len += scnprintf(buf + len, buf_len - len, 2778 "cv_in_use_cnt_exceeded = %u\n", 2779 le32_to_cpu(htt_stats_buf->cv_in_use_cnt_exceeded)); 2780 len += scnprintf(buf + len, buf_len - len, "cv_ntbr_sounding = %u\n", 2781 le32_to_cpu(htt_stats_buf->cv_ntbr_sounding)); 2782 len += scnprintf(buf + len, buf_len - len, 2783 "cv_found_upload_in_progress = %u\n", 2784 le32_to_cpu(htt_stats_buf->cv_found_upload_in_progress)); 2785 len += scnprintf(buf + len, buf_len - len, 2786 "cv_expired_during_query = %u\n", 2787 le32_to_cpu(htt_stats_buf->cv_expired_during_query)); 2788 len += scnprintf(buf + len, buf_len - len, "cv_found = %u\n", 2789 le32_to_cpu(htt_stats_buf->cv_found)); 2790 len += scnprintf(buf + len, buf_len - len, "cv_not_found = %u\n", 2791 le32_to_cpu(htt_stats_buf->cv_not_found)); 2792 len += scnprintf(buf + len, buf_len - len, "cv_total_query_ibf = %u\n", 2793 le32_to_cpu(htt_stats_buf->cv_total_query_ibf)); 2794 len += scnprintf(buf + len, buf_len - len, "cv_found_ibf = %u\n", 2795 le32_to_cpu(htt_stats_buf->cv_found_ibf)); 2796 len += scnprintf(buf + len, buf_len - len, "cv_not_found_ibf = %u\n", 2797 le32_to_cpu(htt_stats_buf->cv_not_found_ibf)); 2798 len += scnprintf(buf + len, buf_len - len, 2799 "cv_expired_during_query_ibf = %u\n\n", 2800 le32_to_cpu(htt_stats_buf->cv_expired_during_query_ibf)); 2801 } 2802 2803 stats_req->buf_len = len; 2804} 2805 2806static void 2807ath12k_htt_print_pdev_obss_pd_stats_tlv(const void *tag_buf, u16 tag_len, 2808 struct debug_htt_stats_req *stats_req) 2809{ 2810 const struct ath12k_htt_pdev_obss_pd_stats_tlv *htt_stats_buf = tag_buf; 2811 u8 *buf = stats_req->buf; 2812 u32 len = stats_req->buf_len; 2813 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2814 u8 i; 2815 static const char *access_cat_names[ATH12K_HTT_NUM_AC_WMM] = {"best effort", 2816 "background", 2817 "video", "voice"}; 2818 2819 if (tag_len < sizeof(*htt_stats_buf)) 2820 return; 2821 2822 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_STATS_TLV:\n"); 2823 len += scnprintf(buf + len, buf_len - len, "num_spatial_reuse_tx = %u\n", 2824 le32_to_cpu(htt_stats_buf->num_sr_tx_transmissions)); 2825 len += scnprintf(buf + len, buf_len - len, 2826 "num_spatial_reuse_opportunities = %u\n", 2827 le32_to_cpu(htt_stats_buf->num_spatial_reuse_opportunities)); 2828 len += scnprintf(buf + len, buf_len - len, "num_non_srg_opportunities = %u\n", 2829 le32_to_cpu(htt_stats_buf->num_non_srg_opportunities)); 2830 len += scnprintf(buf + len, buf_len - len, "num_non_srg_ppdu_tried = %u\n", 2831 le32_to_cpu(htt_stats_buf->num_non_srg_ppdu_tried)); 2832 len += scnprintf(buf + len, buf_len - len, "num_non_srg_ppdu_success = %u\n", 2833 le32_to_cpu(htt_stats_buf->num_non_srg_ppdu_success)); 2834 len += scnprintf(buf + len, buf_len - len, "num_srg_opportunities = %u\n", 2835 le32_to_cpu(htt_stats_buf->num_srg_opportunities)); 2836 len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_tried = %u\n", 2837 le32_to_cpu(htt_stats_buf->num_srg_ppdu_tried)); 2838 len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_success = %u\n", 2839 le32_to_cpu(htt_stats_buf->num_srg_ppdu_success)); 2840 len += scnprintf(buf + len, buf_len - len, "num_psr_opportunities = %u\n", 2841 le32_to_cpu(htt_stats_buf->num_psr_opportunities)); 2842 len += scnprintf(buf + len, buf_len - len, "num_psr_ppdu_tried = %u\n", 2843 le32_to_cpu(htt_stats_buf->num_psr_ppdu_tried)); 2844 len += scnprintf(buf + len, buf_len - len, "num_psr_ppdu_success = %u\n", 2845 le32_to_cpu(htt_stats_buf->num_psr_ppdu_success)); 2846 len += scnprintf(buf + len, buf_len - len, "min_duration_check_flush_cnt = %u\n", 2847 le32_to_cpu(htt_stats_buf->num_obss_min_dur_check_flush_cnt)); 2848 len += scnprintf(buf + len, buf_len - len, "sr_ppdu_abort_flush_cnt = %u\n\n", 2849 le32_to_cpu(htt_stats_buf->num_sr_ppdu_abort_flush_cnt)); 2850 2851 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_PER_AC_STATS:\n"); 2852 for (i = 0; i < ATH12K_HTT_NUM_AC_WMM; i++) { 2853 len += scnprintf(buf + len, buf_len - len, "Access Category %u (%s)\n", 2854 i, access_cat_names[i]); 2855 len += scnprintf(buf + len, buf_len - len, 2856 "num_non_srg_ppdu_tried = %u\n", 2857 le32_to_cpu(htt_stats_buf->num_non_srg_tried_per_ac[i])); 2858 len += scnprintf(buf + len, buf_len - len, 2859 "num_non_srg_ppdu_success = %u\n", 2860 le32_to_cpu(htt_stats_buf->num_non_srg_success_ac[i])); 2861 len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_tried = %u\n", 2862 le32_to_cpu(htt_stats_buf->num_srg_tried_per_ac[i])); 2863 len += scnprintf(buf + len, buf_len - len, 2864 "num_srg_ppdu_success = %u\n\n", 2865 le32_to_cpu(htt_stats_buf->num_srg_success_per_ac[i])); 2866 } 2867 2868 stats_req->buf_len = len; 2869} 2870 2871static void 2872ath12k_htt_print_latency_prof_ctx_tlv(const void *tag_buf, u16 tag_len, 2873 struct debug_htt_stats_req *stats_req) 2874{ 2875 const struct ath12k_htt_latency_prof_ctx_tlv *htt_stats_buf = tag_buf; 2876 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2877 u32 len = stats_req->buf_len; 2878 u8 *buf = stats_req->buf; 2879 2880 if (tag_len < sizeof(*htt_stats_buf)) 2881 return; 2882 2883 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_LATENCY_CTX_TLV:\n"); 2884 len += scnprintf(buf + len, buf_len - len, "duration = %u\n", 2885 le32_to_cpu(htt_stats_buf->duration)); 2886 len += scnprintf(buf + len, buf_len - len, "tx_msdu_cnt = %u\n", 2887 le32_to_cpu(htt_stats_buf->tx_msdu_cnt)); 2888 len += scnprintf(buf + len, buf_len - len, "tx_mpdu_cnt = %u\n", 2889 le32_to_cpu(htt_stats_buf->tx_mpdu_cnt)); 2890 len += scnprintf(buf + len, buf_len - len, "rx_msdu_cnt = %u\n", 2891 le32_to_cpu(htt_stats_buf->rx_msdu_cnt)); 2892 len += scnprintf(buf + len, buf_len - len, "rx_mpdu_cnt = %u\n\n", 2893 le32_to_cpu(htt_stats_buf->rx_mpdu_cnt)); 2894 2895 stats_req->buf_len = len; 2896} 2897 2898static void 2899ath12k_htt_print_latency_prof_cnt(const void *tag_buf, u16 tag_len, 2900 struct debug_htt_stats_req *stats_req) 2901{ 2902 const struct ath12k_htt_latency_prof_cnt_tlv *htt_stats_buf = tag_buf; 2903 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2904 u32 len = stats_req->buf_len; 2905 u8 *buf = stats_req->buf; 2906 2907 if (tag_len < sizeof(*htt_stats_buf)) 2908 return; 2909 2910 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_LATENCY_CNT_TLV:\n"); 2911 len += scnprintf(buf + len, buf_len - len, "prof_enable_cnt = %u\n\n", 2912 le32_to_cpu(htt_stats_buf->prof_enable_cnt)); 2913 2914 stats_req->buf_len = len; 2915} 2916 2917static void 2918ath12k_htt_print_latency_prof_stats_tlv(const void *tag_buf, u16 tag_len, 2919 struct debug_htt_stats_req *stats_req) 2920{ 2921 const struct ath12k_htt_latency_prof_stats_tlv *htt_stats_buf = tag_buf; 2922 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2923 u32 len = stats_req->buf_len; 2924 u8 *buf = stats_req->buf; 2925 2926 if (tag_len < sizeof(*htt_stats_buf)) 2927 return; 2928 2929 if (le32_to_cpu(htt_stats_buf->print_header) == 1) { 2930 len += scnprintf(buf + len, buf_len - len, 2931 "HTT_STATS_LATENCY_PROF_TLV:\n"); 2932 } 2933 2934 len += scnprintf(buf + len, buf_len - len, "Latency name = %s\n", 2935 htt_stats_buf->latency_prof_name); 2936 len += scnprintf(buf + len, buf_len - len, "count = %u\n", 2937 le32_to_cpu(htt_stats_buf->cnt)); 2938 len += scnprintf(buf + len, buf_len - len, "minimum = %u\n", 2939 le32_to_cpu(htt_stats_buf->min)); 2940 len += scnprintf(buf + len, buf_len - len, "maximum = %u\n", 2941 le32_to_cpu(htt_stats_buf->max)); 2942 len += scnprintf(buf + len, buf_len - len, "last = %u\n", 2943 le32_to_cpu(htt_stats_buf->last)); 2944 len += scnprintf(buf + len, buf_len - len, "total = %u\n", 2945 le32_to_cpu(htt_stats_buf->tot)); 2946 len += scnprintf(buf + len, buf_len - len, "average = %u\n", 2947 le32_to_cpu(htt_stats_buf->avg)); 2948 len += scnprintf(buf + len, buf_len - len, "histogram interval = %u\n", 2949 le32_to_cpu(htt_stats_buf->hist_intvl)); 2950 len += print_array_to_buf(buf, len, "histogram", htt_stats_buf->hist, 2951 ATH12K_HTT_LATENCY_PROFILE_NUM_MAX_HIST, "\n\n"); 2952 2953 stats_req->buf_len = len; 2954} 2955 2956static void 2957ath12k_htt_print_ul_ofdma_trigger_stats(const void *tag_buf, u16 tag_len, 2958 struct debug_htt_stats_req *stats_req) 2959{ 2960 const struct ath12k_htt_rx_pdev_ul_trigger_stats_tlv *htt_stats_buf = tag_buf; 2961 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2962 u32 len = stats_req->buf_len; 2963 u8 *buf = stats_req->buf; 2964 u32 mac_id; 2965 u8 j; 2966 2967 if (tag_len < sizeof(*htt_stats_buf)) 2968 return; 2969 2970 mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word); 2971 2972 len += scnprintf(buf + len, buf_len - len, 2973 "HTT_RX_PDEV_UL_TRIGGER_STATS_TLV:\n"); 2974 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 2975 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID)); 2976 len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_ofdma = %u\n", 2977 le32_to_cpu(htt_stats_buf->rx_11ax_ul_ofdma)); 2978 len += print_array_to_buf(buf, len, "ul_ofdma_rx_mcs", 2979 htt_stats_buf->ul_ofdma_rx_mcs, 2980 ATH12K_HTT_RX_NUM_MCS_CNTRS, "\n"); 2981 for (j = 0; j < ATH12K_HTT_RX_NUM_GI_CNTRS; j++) { 2982 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_gi[%u]", j); 2983 len += print_array_to_buf(buf, len, "", 2984 htt_stats_buf->ul_ofdma_rx_gi[j], 2985 ATH12K_HTT_RX_NUM_MCS_CNTRS, "\n"); 2986 } 2987 2988 len += print_array_to_buf_index(buf, len, "ul_ofdma_rx_nss", 1, 2989 htt_stats_buf->ul_ofdma_rx_nss, 2990 ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n"); 2991 len += print_array_to_buf(buf, len, "ul_ofdma_rx_bw", 2992 htt_stats_buf->ul_ofdma_rx_bw, 2993 ATH12K_HTT_RX_NUM_BW_CNTRS, "\n"); 2994 2995 for (j = 0; j < ATH12K_HTT_RX_NUM_REDUCED_CHAN_TYPES; j++) { 2996 len += scnprintf(buf + len, buf_len - len, j == 0 ? 2997 "half_ul_ofdma_rx_bw" : 2998 "quarter_ul_ofdma_rx_bw"); 2999 len += print_array_to_buf(buf, len, "", htt_stats_buf->red_bw[j], 3000 ATH12K_HTT_RX_NUM_BW_CNTRS, "\n"); 3001 } 3002 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_stbc = %u\n", 3003 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_stbc)); 3004 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_ldpc = %u\n", 3005 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_ldpc)); 3006 3007 len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_data_ru_size_ppdu = "); 3008 for (j = 0; j < ATH12K_HTT_RX_NUM_RU_SIZE_CNTRS; j++) 3009 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3010 ath12k_htt_ax_tx_rx_ru_size_to_str(j), 3011 le32_to_cpu(htt_stats_buf->data_ru_size_ppdu[j])); 3012 len += scnprintf(buf + len, buf_len - len, "\n"); 3013 3014 len += scnprintf(buf + len, buf_len - len, 3015 "rx_ulofdma_non_data_ru_size_ppdu = "); 3016 for (j = 0; j < ATH12K_HTT_RX_NUM_RU_SIZE_CNTRS; j++) 3017 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3018 ath12k_htt_ax_tx_rx_ru_size_to_str(j), 3019 le32_to_cpu(htt_stats_buf->non_data_ru_size_ppdu[j])); 3020 len += scnprintf(buf + len, buf_len - len, "\n"); 3021 3022 len += print_array_to_buf(buf, len, "rx_rssi_track_sta_aid", 3023 htt_stats_buf->uplink_sta_aid, 3024 ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n"); 3025 len += print_array_to_buf(buf, len, "rx_sta_target_rssi", 3026 htt_stats_buf->uplink_sta_target_rssi, 3027 ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n"); 3028 len += print_array_to_buf(buf, len, "rx_sta_fd_rssi", 3029 htt_stats_buf->uplink_sta_fd_rssi, 3030 ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n"); 3031 len += print_array_to_buf(buf, len, "rx_sta_power_headroom", 3032 htt_stats_buf->uplink_sta_power_headroom, 3033 ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n"); 3034 len += scnprintf(buf + len, buf_len - len, 3035 "ul_ofdma_basic_trigger_rx_qos_null_only = %u\n\n", 3036 le32_to_cpu(htt_stats_buf->ul_ofdma_bsc_trig_rx_qos_null_only)); 3037 3038 stats_req->buf_len = len; 3039} 3040 3041static void 3042ath12k_htt_print_ul_ofdma_user_stats(const void *tag_buf, u16 tag_len, 3043 struct debug_htt_stats_req *stats_req) 3044{ 3045 const struct ath12k_htt_rx_pdev_ul_ofdma_user_stats_tlv *htt_stats_buf = tag_buf; 3046 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3047 u32 len = stats_req->buf_len; 3048 u8 *buf = stats_req->buf; 3049 u32 user_index; 3050 3051 if (tag_len < sizeof(*htt_stats_buf)) 3052 return; 3053 3054 user_index = __le32_to_cpu(htt_stats_buf->user_index); 3055 3056 if (!user_index) 3057 len += scnprintf(buf + len, buf_len - len, 3058 "HTT_RX_PDEV_UL_OFDMA_USER_STAS_TLV:\n"); 3059 len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_non_data_ppdu_%u = %u\n", 3060 user_index, 3061 le32_to_cpu(htt_stats_buf->rx_ulofdma_non_data_ppdu)); 3062 len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_data_ppdu_%u = %u\n", 3063 user_index, 3064 le32_to_cpu(htt_stats_buf->rx_ulofdma_data_ppdu)); 3065 len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_mpdu_ok_%u = %u\n", 3066 user_index, 3067 le32_to_cpu(htt_stats_buf->rx_ulofdma_mpdu_ok)); 3068 len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_mpdu_fail_%u = %u\n", 3069 user_index, 3070 le32_to_cpu(htt_stats_buf->rx_ulofdma_mpdu_fail)); 3071 len += scnprintf(buf + len, buf_len - len, 3072 "rx_ulofdma_non_data_nusers_%u = %u\n", user_index, 3073 le32_to_cpu(htt_stats_buf->rx_ulofdma_non_data_nusers)); 3074 len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_data_nusers_%u = %u\n\n", 3075 user_index, 3076 le32_to_cpu(htt_stats_buf->rx_ulofdma_data_nusers)); 3077 3078 stats_req->buf_len = len; 3079} 3080 3081static void 3082ath12k_htt_print_ul_mumimo_trig_stats(const void *tag_buf, u16 tag_len, 3083 struct debug_htt_stats_req *stats_req) 3084{ 3085 const struct ath12k_htt_rx_ul_mumimo_trig_stats_tlv *htt_stats_buf = tag_buf; 3086 char str_buf[ATH12K_HTT_MAX_STRING_LEN] = {}; 3087 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3088 u32 len = stats_req->buf_len; 3089 u8 *buf = stats_req->buf; 3090 u32 mac_id; 3091 u16 index; 3092 u8 i, j; 3093 3094 if (tag_len < sizeof(*htt_stats_buf)) 3095 return; 3096 3097 mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word); 3098 3099 len += scnprintf(buf + len, buf_len - len, 3100 "HTT_RX_PDEV_UL_MUMIMO_TRIG_STATS_TLV:\n"); 3101 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 3102 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID)); 3103 len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_mumimo = %u\n", 3104 le32_to_cpu(htt_stats_buf->rx_11ax_ul_mumimo)); 3105 index = 0; 3106 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 3107 for (i = 0; i < ATH12K_HTT_RX_NUM_MCS_CNTRS; i++) 3108 index += scnprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index, 3109 " %u:%u,", i, 3110 le32_to_cpu(htt_stats_buf->ul_mumimo_rx_mcs[i])); 3111 3112 for (i = 0; i < ATH12K_HTT_RX_NUM_EXTRA_MCS_CNTRS; i++) 3113 index += scnprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index, 3114 " %u:%u,", i + ATH12K_HTT_RX_NUM_MCS_CNTRS, 3115 le32_to_cpu(htt_stats_buf->ul_mumimo_rx_mcs_ext[i])); 3116 str_buf[--index] = '\0'; 3117 len += scnprintf(buf + len, buf_len - len, "ul_mumimo_rx_mcs = %s\n", str_buf); 3118 3119 for (j = 0; j < ATH12K_HTT_RX_NUM_GI_CNTRS; j++) { 3120 index = 0; 3121 memset(&str_buf[index], 0x0, ATH12K_HTT_MAX_STRING_LEN); 3122 for (i = 0; i < ATH12K_HTT_RX_NUM_MCS_CNTRS; i++) 3123 index += scnprintf(&str_buf[index], 3124 ATH12K_HTT_MAX_STRING_LEN - index, 3125 " %u:%u,", i, 3126 le32_to_cpu(htt_stats_buf->ul_rx_gi[j][i])); 3127 3128 for (i = 0; i < ATH12K_HTT_RX_NUM_EXTRA_MCS_CNTRS; i++) 3129 index += scnprintf(&str_buf[index], 3130 ATH12K_HTT_MAX_STRING_LEN - index, 3131 " %u:%u,", i + ATH12K_HTT_RX_NUM_MCS_CNTRS, 3132 le32_to_cpu(htt_stats_buf->ul_gi_ext[j][i])); 3133 str_buf[--index] = '\0'; 3134 len += scnprintf(buf + len, buf_len - len, 3135 "ul_mumimo_rx_gi_%u = %s\n", j, str_buf); 3136 } 3137 3138 index = 0; 3139 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 3140 len += print_array_to_buf_index(buf, len, "ul_mumimo_rx_nss", 1, 3141 htt_stats_buf->ul_mumimo_rx_nss, 3142 ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n"); 3143 3144 len += print_array_to_buf(buf, len, "ul_mumimo_rx_bw", 3145 htt_stats_buf->ul_mumimo_rx_bw, 3146 ATH12K_HTT_RX_NUM_BW_CNTRS, "\n"); 3147 for (i = 0; i < ATH12K_HTT_RX_NUM_REDUCED_CHAN_TYPES; i++) { 3148 index = 0; 3149 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 3150 for (j = 0; j < ATH12K_HTT_RX_NUM_BW_CNTRS; j++) 3151 index += scnprintf(&str_buf[index], 3152 ATH12K_HTT_MAX_STRING_LEN - index, 3153 " %u:%u,", j, 3154 le32_to_cpu(htt_stats_buf->red_bw[i][j])); 3155 str_buf[--index] = '\0'; 3156 len += scnprintf(buf + len, buf_len - len, "%s = %s\n", 3157 i == 0 ? "half_ul_mumimo_rx_bw" : 3158 "quarter_ul_mumimo_rx_bw", str_buf); 3159 } 3160 3161 len += scnprintf(buf + len, buf_len - len, "ul_mumimo_rx_stbc = %u\n", 3162 le32_to_cpu(htt_stats_buf->ul_mumimo_rx_stbc)); 3163 len += scnprintf(buf + len, buf_len - len, "ul_mumimo_rx_ldpc = %u\n", 3164 le32_to_cpu(htt_stats_buf->ul_mumimo_rx_ldpc)); 3165 3166 for (j = 0; j < ATH12K_HTT_RX_NUM_SPATIAL_STREAMS; j++) { 3167 len += scnprintf(buf + len, buf_len - len, 3168 "rx_ul_mumimo_rssi_in_dbm: chain%u ", j); 3169 len += print_array_to_buf_s8(buf, len, "", 0, 3170 htt_stats_buf->ul_rssi[j], 3171 ATH12K_HTT_RX_NUM_BW_CNTRS, "\n"); 3172 } 3173 3174 for (j = 0; j < ATH12K_HTT_TX_UL_MUMIMO_USER_STATS; j++) { 3175 len += scnprintf(buf + len, buf_len - len, 3176 "rx_ul_mumimo_target_rssi: user_%u ", j); 3177 len += print_array_to_buf_s8(buf, len, "", 0, 3178 htt_stats_buf->tgt_rssi[j], 3179 ATH12K_HTT_RX_NUM_BW_CNTRS, "\n"); 3180 } 3181 3182 for (j = 0; j < ATH12K_HTT_TX_UL_MUMIMO_USER_STATS; j++) { 3183 len += scnprintf(buf + len, buf_len - len, 3184 "rx_ul_mumimo_fd_rssi: user_%u ", j); 3185 len += print_array_to_buf_s8(buf, len, "", 0, 3186 htt_stats_buf->fd[j], 3187 ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n"); 3188 } 3189 3190 for (j = 0; j < ATH12K_HTT_TX_UL_MUMIMO_USER_STATS; j++) { 3191 len += scnprintf(buf + len, buf_len - len, 3192 "rx_ulmumimo_pilot_evm_db_mean: user_%u ", j); 3193 len += print_array_to_buf_s8(buf, len, "", 0, 3194 htt_stats_buf->db[j], 3195 ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n"); 3196 } 3197 3198 len += scnprintf(buf + len, buf_len - len, 3199 "ul_mumimo_basic_trigger_rx_qos_null_only = %u\n\n", 3200 le32_to_cpu(htt_stats_buf->mumimo_bsc_trig_rx_qos_null_only)); 3201 3202 stats_req->buf_len = len; 3203} 3204 3205static void 3206ath12k_htt_print_rx_fse_stats_tlv(const void *tag_buf, u16 tag_len, 3207 struct debug_htt_stats_req *stats_req) 3208{ 3209 const struct ath12k_htt_rx_fse_stats_tlv *htt_stats_buf = tag_buf; 3210 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3211 u32 len = stats_req->buf_len; 3212 u8 *buf = stats_req->buf; 3213 3214 if (tag_len < sizeof(*htt_stats_buf)) 3215 return; 3216 3217 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_RX_FSE_STATS_TLV:\n"); 3218 len += scnprintf(buf + len, buf_len - len, "=== Software RX FSE STATS ===\n"); 3219 len += scnprintf(buf + len, buf_len - len, "Enable count = %u\n", 3220 le32_to_cpu(htt_stats_buf->fse_enable_cnt)); 3221 len += scnprintf(buf + len, buf_len - len, "Disable count = %u\n", 3222 le32_to_cpu(htt_stats_buf->fse_disable_cnt)); 3223 len += scnprintf(buf + len, buf_len - len, "Cache invalidate entry count = %u\n", 3224 le32_to_cpu(htt_stats_buf->fse_cache_invalidate_entry_cnt)); 3225 len += scnprintf(buf + len, buf_len - len, "Full cache invalidate count = %u\n", 3226 le32_to_cpu(htt_stats_buf->fse_full_cache_invalidate_cnt)); 3227 3228 len += scnprintf(buf + len, buf_len - len, "\n=== Hardware RX FSE STATS ===\n"); 3229 len += scnprintf(buf + len, buf_len - len, "Cache hits count = %u\n", 3230 le32_to_cpu(htt_stats_buf->fse_num_cache_hits_cnt)); 3231 len += scnprintf(buf + len, buf_len - len, "Cache no. of searches = %u\n", 3232 le32_to_cpu(htt_stats_buf->fse_num_searches_cnt)); 3233 len += scnprintf(buf + len, buf_len - len, "Cache occupancy peak count:\n"); 3234 len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-16] = %u [17-32] = %u ", 3235 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[0]), 3236 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[1]), 3237 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[2])); 3238 len += scnprintf(buf + len, buf_len - len, "[33-48] = %u [49-64] = %u ", 3239 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[3]), 3240 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[4])); 3241 len += scnprintf(buf + len, buf_len - len, "[65-80] = %u [81-96] = %u ", 3242 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[5]), 3243 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[6])); 3244 len += scnprintf(buf + len, buf_len - len, "[97-112] = %u [113-127] = %u ", 3245 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[7]), 3246 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[8])); 3247 len += scnprintf(buf + len, buf_len - len, "[128] = %u\n", 3248 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[9])); 3249 len += scnprintf(buf + len, buf_len - len, "Cache occupancy current count:\n"); 3250 len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-16] = %u [17-32] = %u ", 3251 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[0]), 3252 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[1]), 3253 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[2])); 3254 len += scnprintf(buf + len, buf_len - len, "[33-48] = %u [49-64] = %u ", 3255 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[3]), 3256 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[4])); 3257 len += scnprintf(buf + len, buf_len - len, "[65-80] = %u [81-96] = %u ", 3258 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[5]), 3259 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[6])); 3260 len += scnprintf(buf + len, buf_len - len, "[97-112] = %u [113-127] = %u ", 3261 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[7]), 3262 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[8])); 3263 len += scnprintf(buf + len, buf_len - len, "[128] = %u\n", 3264 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[9])); 3265 len += scnprintf(buf + len, buf_len - len, "Cache search square count:\n"); 3266 len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-50] = %u [51-100] = %u ", 3267 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[0]), 3268 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[1]), 3269 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[2])); 3270 len += scnprintf(buf + len, buf_len - len, "[101-200] = %u [201-255] = %u ", 3271 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[3]), 3272 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[4])); 3273 len += scnprintf(buf + len, buf_len - len, "[256] = %u\n", 3274 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[5])); 3275 len += scnprintf(buf + len, buf_len - len, "Cache search peak pending count:\n"); 3276 len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-2] = %u [3-4] = %u ", 3277 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[0]), 3278 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[1]), 3279 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[2])); 3280 len += scnprintf(buf + len, buf_len - len, "[Greater/Equal to 5] = %u\n", 3281 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[3])); 3282 len += scnprintf(buf + len, buf_len - len, "Cache search tot pending count:\n"); 3283 len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-2] = %u [3-4] = %u ", 3284 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[0]), 3285 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[1]), 3286 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[2])); 3287 len += scnprintf(buf + len, buf_len - len, "[Greater/Equal to 5] = %u\n\n", 3288 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[3])); 3289 3290 stats_req->buf_len = len; 3291} 3292 3293static void 3294ath12k_htt_print_pdev_tx_rate_txbf_stats_tlv(const void *tag_buf, u16 tag_len, 3295 struct debug_htt_stats_req *stats_req) 3296{ 3297 const struct ath12k_htt_pdev_txrate_txbf_stats_tlv *htt_stats_buf = tag_buf; 3298 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3299 u32 len = stats_req->buf_len; 3300 u8 *buf = stats_req->buf; 3301 u8 i; 3302 3303 if (tag_len < sizeof(*htt_stats_buf)) 3304 return; 3305 3306 len += scnprintf(buf + len, buf_len - len, 3307 "HTT_STATS_PDEV_TX_RATE_TXBF_STATS:\n"); 3308 len += scnprintf(buf + len, buf_len - len, "Legacy OFDM Rates: 6 Mbps: %u, ", 3309 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[0])); 3310 len += scnprintf(buf + len, buf_len - len, "9 Mbps: %u, 12 Mbps: %u, ", 3311 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[1]), 3312 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[2])); 3313 len += scnprintf(buf + len, buf_len - len, "18 Mbps: %u\n", 3314 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[3])); 3315 len += scnprintf(buf + len, buf_len - len, "24 Mbps: %u, 36 Mbps: %u, ", 3316 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[4]), 3317 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[5])); 3318 len += scnprintf(buf + len, buf_len - len, "48 Mbps: %u, 54 Mbps: %u\n", 3319 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[6]), 3320 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[7])); 3321 3322 len += print_array_to_buf(buf, len, "tx_ol_mcs", htt_stats_buf->tx_su_ol_mcs, 3323 ATH12K_HTT_TX_BF_RATE_STATS_NUM_MCS_COUNTERS, "\n"); 3324 len += print_array_to_buf(buf, len, "tx_ibf_mcs", htt_stats_buf->tx_su_ibf_mcs, 3325 ATH12K_HTT_TX_BF_RATE_STATS_NUM_MCS_COUNTERS, "\n"); 3326 len += print_array_to_buf(buf, len, "tx_txbf_mcs", htt_stats_buf->tx_su_txbf_mcs, 3327 ATH12K_HTT_TX_BF_RATE_STATS_NUM_MCS_COUNTERS, "\n"); 3328 len += print_array_to_buf_index(buf, len, "tx_ol_nss", 1, 3329 htt_stats_buf->tx_su_ol_nss, 3330 ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, 3331 "\n"); 3332 len += print_array_to_buf_index(buf, len, "tx_ibf_nss", 1, 3333 htt_stats_buf->tx_su_ibf_nss, 3334 ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, 3335 "\n"); 3336 len += print_array_to_buf_index(buf, len, "tx_txbf_nss", 1, 3337 htt_stats_buf->tx_su_txbf_nss, 3338 ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, 3339 "\n"); 3340 len += print_array_to_buf(buf, len, "tx_ol_bw", htt_stats_buf->tx_su_ol_bw, 3341 ATH12K_HTT_TXBF_NUM_BW_CNTRS, "\n"); 3342 for (i = 0; i < ATH12K_HTT_TXBF_NUM_REDUCED_CHAN_TYPES; i++) 3343 len += print_array_to_buf(buf, len, i ? "quarter_tx_ol_bw" : 3344 "half_tx_ol_bw", 3345 htt_stats_buf->ol[i], 3346 ATH12K_HTT_TXBF_NUM_BW_CNTRS, 3347 "\n"); 3348 3349 len += print_array_to_buf(buf, len, "tx_ibf_bw", htt_stats_buf->tx_su_ibf_bw, 3350 ATH12K_HTT_TXBF_NUM_BW_CNTRS, "\n"); 3351 for (i = 0; i < ATH12K_HTT_TXBF_NUM_REDUCED_CHAN_TYPES; i++) 3352 len += print_array_to_buf(buf, len, i ? "quarter_tx_ibf_bw" : 3353 "half_tx_ibf_bw", 3354 htt_stats_buf->ibf[i], 3355 ATH12K_HTT_TXBF_NUM_BW_CNTRS, 3356 "\n"); 3357 3358 len += print_array_to_buf(buf, len, "tx_txbf_bw", htt_stats_buf->tx_su_txbf_bw, 3359 ATH12K_HTT_TXBF_NUM_BW_CNTRS, "\n"); 3360 for (i = 0; i < ATH12K_HTT_TXBF_NUM_REDUCED_CHAN_TYPES; i++) 3361 len += print_array_to_buf(buf, len, i ? "quarter_tx_txbf_bw" : 3362 "half_tx_txbf_bw", 3363 htt_stats_buf->txbf[i], 3364 ATH12K_HTT_TXBF_NUM_BW_CNTRS, 3365 "\n"); 3366 len += scnprintf(buf + len, buf_len - len, "\n"); 3367 3368 len += scnprintf(buf + len, buf_len - len, 3369 "HTT_STATS_PDEV_TXBF_FLAG_RETURN_STATS:\n"); 3370 len += scnprintf(buf + len, buf_len - len, "TXBF_reason_code_stats: 0:%u, 1:%u,", 3371 le32_to_cpu(htt_stats_buf->txbf_flag_set_mu_mode), 3372 le32_to_cpu(htt_stats_buf->txbf_flag_set_final_status)); 3373 len += scnprintf(buf + len, buf_len - len, " 2:%u, 3:%u, 4:%u, 5:%u, ", 3374 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_verified_txbf_mode), 3375 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_disable_p2p_access), 3376 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_max_nss_in_he160), 3377 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_disable_uldlofdma)); 3378 len += scnprintf(buf + len, buf_len - len, "6:%u, 7:%u\n\n", 3379 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_mcs_threshold_val), 3380 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_final_status)); 3381 3382 stats_req->buf_len = len; 3383} 3384 3385static void 3386ath12k_htt_print_txbf_ofdma_ax_ndpa_stats_tlv(const void *tag_buf, u16 tag_len, 3387 struct debug_htt_stats_req *stats_req) 3388{ 3389 const struct ath12k_htt_txbf_ofdma_ax_ndpa_stats_tlv *stats_buf = tag_buf; 3390 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3391 u32 len = stats_req->buf_len; 3392 u8 *buf = stats_req->buf; 3393 u32 num_elements; 3394 u8 i; 3395 3396 if (tag_len < sizeof(*stats_buf)) 3397 return; 3398 3399 num_elements = le32_to_cpu(stats_buf->num_elems_ax_ndpa_arr); 3400 3401 len += scnprintf(buf + len, buf_len - len, "HTT_TXBF_OFDMA_AX_NDPA_STATS_TLV:\n"); 3402 len += scnprintf(buf + len, buf_len - len, "ax_ofdma_ndpa_queued ="); 3403 for (i = 0; i < num_elements; i++) 3404 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3405 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_queued)); 3406 len--; 3407 *(buf + len) = '\0'; 3408 3409 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndpa_tried ="); 3410 for (i = 0; i < num_elements; i++) 3411 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3412 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_tried)); 3413 len--; 3414 *(buf + len) = '\0'; 3415 3416 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndpa_flushed ="); 3417 for (i = 0; i < num_elements; i++) 3418 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3419 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_flush)); 3420 len--; 3421 *(buf + len) = '\0'; 3422 3423 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndpa_err ="); 3424 for (i = 0; i < num_elements; i++) 3425 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3426 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_err)); 3427 len--; 3428 *(buf + len) = '\0'; 3429 3430 len += scnprintf(buf + len, buf_len - len, "\n\n"); 3431 3432 stats_req->buf_len = len; 3433} 3434 3435static void 3436ath12k_htt_print_txbf_ofdma_ax_ndp_stats_tlv(const void *tag_buf, u16 tag_len, 3437 struct debug_htt_stats_req *stats_req) 3438{ 3439 const struct ath12k_htt_txbf_ofdma_ax_ndp_stats_tlv *stats_buf = tag_buf; 3440 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3441 u32 len = stats_req->buf_len; 3442 u8 *buf = stats_req->buf; 3443 u32 num_elements; 3444 u8 i; 3445 3446 if (tag_len < sizeof(*stats_buf)) 3447 return; 3448 3449 num_elements = le32_to_cpu(stats_buf->num_elems_ax_ndp_arr); 3450 3451 len += scnprintf(buf + len, buf_len - len, "HTT_TXBF_OFDMA_AX_NDP_STATS_TLV:\n"); 3452 len += scnprintf(buf + len, buf_len - len, "ax_ofdma_ndp_queued ="); 3453 for (i = 0; i < num_elements; i++) 3454 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3455 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_queued)); 3456 len--; 3457 *(buf + len) = '\0'; 3458 3459 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndp_tried ="); 3460 for (i = 0; i < num_elements; i++) 3461 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3462 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_tried)); 3463 len--; 3464 *(buf + len) = '\0'; 3465 3466 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndp_flushed ="); 3467 for (i = 0; i < num_elements; i++) 3468 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3469 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_flush)); 3470 len--; 3471 *(buf + len) = '\0'; 3472 3473 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndp_err ="); 3474 for (i = 0; i < num_elements; i++) 3475 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3476 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_err)); 3477 len--; 3478 *(buf + len) = '\0'; 3479 3480 len += scnprintf(buf + len, buf_len - len, "\n\n"); 3481 3482 stats_req->buf_len = len; 3483} 3484 3485static void 3486ath12k_htt_print_txbf_ofdma_ax_brp_stats_tlv(const void *tag_buf, u16 tag_len, 3487 struct debug_htt_stats_req *stats_req) 3488{ 3489 const struct ath12k_htt_txbf_ofdma_ax_brp_stats_tlv *stats_buf = tag_buf; 3490 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3491 u32 len = stats_req->buf_len; 3492 u8 *buf = stats_req->buf; 3493 u32 num_elements; 3494 u8 i; 3495 3496 if (tag_len < sizeof(*stats_buf)) 3497 return; 3498 3499 num_elements = le32_to_cpu(stats_buf->num_elems_ax_brp_arr); 3500 3501 len += scnprintf(buf + len, buf_len - len, "HTT_TXBF_OFDMA_AX_BRP_STATS_TLV:\n"); 3502 len += scnprintf(buf + len, buf_len - len, "ax_ofdma_brpoll_queued ="); 3503 for (i = 0; i < num_elements; i++) 3504 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3505 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_queued)); 3506 len--; 3507 *(buf + len) = '\0'; 3508 3509 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brpoll_tied ="); 3510 for (i = 0; i < num_elements; i++) 3511 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3512 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_tried)); 3513 len--; 3514 *(buf + len) = '\0'; 3515 3516 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brpoll_flushed ="); 3517 for (i = 0; i < num_elements; i++) 3518 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3519 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_flushed)); 3520 len--; 3521 *(buf + len) = '\0'; 3522 3523 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brp_err ="); 3524 for (i = 0; i < num_elements; i++) 3525 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3526 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_err)); 3527 len--; 3528 *(buf + len) = '\0'; 3529 3530 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brp_err_num_cbf_rcvd ="); 3531 for (i = 0; i < num_elements; i++) 3532 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3533 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_num_cbf_rcvd)); 3534 len--; 3535 *(buf + len) = '\0'; 3536 3537 len += scnprintf(buf + len, buf_len - len, "\n\n"); 3538 3539 stats_req->buf_len = len; 3540} 3541 3542static void 3543ath12k_htt_print_txbf_ofdma_ax_steer_stats_tlv(const void *tag_buf, u16 tag_len, 3544 struct debug_htt_stats_req *stats_req) 3545{ 3546 const struct ath12k_htt_txbf_ofdma_ax_steer_stats_tlv *stats_buf = tag_buf; 3547 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3548 u32 len = stats_req->buf_len; 3549 u8 *buf = stats_req->buf; 3550 u32 num_elements; 3551 u8 i; 3552 3553 if (tag_len < sizeof(*stats_buf)) 3554 return; 3555 3556 num_elements = le32_to_cpu(stats_buf->num_elems_ax_steer_arr); 3557 3558 len += scnprintf(buf + len, buf_len - len, 3559 "HTT_TXBF_OFDMA_AX_STEER_STATS_TLV:\n"); 3560 len += scnprintf(buf + len, buf_len - len, "ax_ofdma_num_ppdu_steer ="); 3561 for (i = 0; i < num_elements; i++) 3562 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3563 le32_to_cpu(stats_buf->ax_steer[i].num_ppdu_steer)); 3564 len--; 3565 *(buf + len) = '\0'; 3566 3567 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_num_usrs_prefetch ="); 3568 for (i = 0; i < num_elements; i++) 3569 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3570 le32_to_cpu(stats_buf->ax_steer[i].num_usr_prefetch)); 3571 len--; 3572 *(buf + len) = '\0'; 3573 3574 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_num_usrs_sound ="); 3575 for (i = 0; i < num_elements; i++) 3576 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3577 le32_to_cpu(stats_buf->ax_steer[i].num_usr_sound)); 3578 len--; 3579 *(buf + len) = '\0'; 3580 3581 len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_num_usrs_force_sound ="); 3582 for (i = 0; i < num_elements; i++) 3583 len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1, 3584 le32_to_cpu(stats_buf->ax_steer[i].num_usr_force_sound)); 3585 len--; 3586 *(buf + len) = '\0'; 3587 3588 len += scnprintf(buf + len, buf_len - len, "\n\n"); 3589 3590 stats_req->buf_len = len; 3591} 3592 3593static void 3594ath12k_htt_print_txbf_ofdma_ax_steer_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 3595 struct debug_htt_stats_req *stats_req) 3596{ 3597 const struct ath12k_htt_txbf_ofdma_ax_steer_mpdu_stats_tlv *stats_buf = tag_buf; 3598 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3599 u32 len = stats_req->buf_len; 3600 u8 *buf = stats_req->buf; 3601 3602 if (tag_len < sizeof(*stats_buf)) 3603 return; 3604 3605 len += scnprintf(buf + len, buf_len - len, 3606 "HTT_TXBF_OFDMA_AX_STEER_MPDU_STATS_TLV:\n"); 3607 len += scnprintf(buf + len, buf_len - len, "rbo_steer_mpdus_tried = %u\n", 3608 le32_to_cpu(stats_buf->ax_ofdma_rbo_steer_mpdus_tried)); 3609 len += scnprintf(buf + len, buf_len - len, "rbo_steer_mpdus_failed = %u\n", 3610 le32_to_cpu(stats_buf->ax_ofdma_rbo_steer_mpdus_failed)); 3611 len += scnprintf(buf + len, buf_len - len, "sifs_steer_mpdus_tried = %u\n", 3612 le32_to_cpu(stats_buf->ax_ofdma_sifs_steer_mpdus_tried)); 3613 len += scnprintf(buf + len, buf_len - len, "sifs_steer_mpdus_failed = %u\n\n", 3614 le32_to_cpu(stats_buf->ax_ofdma_sifs_steer_mpdus_failed)); 3615 3616 stats_req->buf_len = len; 3617} 3618 3619static void ath12k_htt_print_dlpager_entry(const struct ath12k_htt_pgs_info *pg_info, 3620 int idx, char *str_buf) 3621{ 3622 u64 page_timestamp; 3623 u16 index = 0; 3624 3625 page_timestamp = ath12k_le32hilo_to_u64(pg_info->ts_msb, pg_info->ts_lsb); 3626 3627 index += snprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index, 3628 "Index - %u ; Page Number - %u ; ", 3629 idx, le32_to_cpu(pg_info->page_num)); 3630 index += snprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index, 3631 "Num of pages - %u ; Timestamp - %lluus\n", 3632 le32_to_cpu(pg_info->num_pgs), page_timestamp); 3633} 3634 3635static void 3636ath12k_htt_print_dlpager_stats_tlv(const void *tag_buf, u16 tag_len, 3637 struct debug_htt_stats_req *stats_req) 3638{ 3639 const struct ath12k_htt_dl_pager_stats_tlv *stat_buf = tag_buf; 3640 u32 len = stats_req->buf_len; 3641 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3642 u32 dword_lock, dword_unlock; 3643 int i; 3644 u8 *buf = stats_req->buf; 3645 u8 pg_locked; 3646 u8 pg_unlock; 3647 char str_buf[ATH12K_HTT_MAX_STRING_LEN] = {}; 3648 3649 if (tag_len < sizeof(*stat_buf)) 3650 return; 3651 3652 dword_lock = le32_get_bits(stat_buf->info2, 3653 ATH12K_HTT_DLPAGER_TOTAL_LOCK_PAGES_INFO2); 3654 dword_unlock = le32_get_bits(stat_buf->info2, 3655 ATH12K_HTT_DLPAGER_TOTAL_FREE_PAGES_INFO2); 3656 3657 pg_locked = ATH12K_HTT_STATS_PAGE_LOCKED; 3658 pg_unlock = ATH12K_HTT_STATS_PAGE_UNLOCKED; 3659 3660 len += scnprintf(buf + len, buf_len - len, "HTT_DLPAGER_STATS_TLV:\n"); 3661 len += scnprintf(buf + len, buf_len - len, "ASYNC locked pages = %u\n", 3662 le32_get_bits(stat_buf->info0, 3663 ATH12K_HTT_DLPAGER_ASYNC_LOCK_PG_CNT_INFO0)); 3664 len += scnprintf(buf + len, buf_len - len, "SYNC locked pages = %u\n", 3665 le32_get_bits(stat_buf->info0, 3666 ATH12K_HTT_DLPAGER_SYNC_LOCK_PG_CNT_INFO0)); 3667 len += scnprintf(buf + len, buf_len - len, "Total locked pages = %u\n", 3668 le32_get_bits(stat_buf->info1, 3669 ATH12K_HTT_DLPAGER_TOTAL_LOCK_PAGES_INFO1)); 3670 len += scnprintf(buf + len, buf_len - len, "Total free pages = %u\n", 3671 le32_get_bits(stat_buf->info1, 3672 ATH12K_HTT_DLPAGER_TOTAL_FREE_PAGES_INFO1)); 3673 3674 len += scnprintf(buf + len, buf_len - len, "\nLOCKED PAGES HISTORY\n"); 3675 len += scnprintf(buf + len, buf_len - len, "last_locked_page_idx = %u\n", 3676 dword_lock ? dword_lock - 1 : (ATH12K_PAGER_MAX - 1)); 3677 3678 for (i = 0; i < ATH12K_PAGER_MAX; i++) { 3679 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 3680 ath12k_htt_print_dlpager_entry(&stat_buf->pgs_info[pg_locked][i], 3681 i, str_buf); 3682 len += scnprintf(buf + len, buf_len - len, "%s", str_buf); 3683 } 3684 3685 len += scnprintf(buf + len, buf_len - len, "\nUNLOCKED PAGES HISTORY\n"); 3686 len += scnprintf(buf + len, buf_len - len, "last_unlocked_page_idx = %u\n", 3687 dword_unlock ? dword_unlock - 1 : ATH12K_PAGER_MAX - 1); 3688 3689 for (i = 0; i < ATH12K_PAGER_MAX; i++) { 3690 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 3691 ath12k_htt_print_dlpager_entry(&stat_buf->pgs_info[pg_unlock][i], 3692 i, str_buf); 3693 len += scnprintf(buf + len, buf_len - len, "%s", str_buf); 3694 } 3695 3696 len += scnprintf(buf + len, buf_len - len, "\n"); 3697 3698 stats_req->buf_len = len; 3699} 3700 3701static void 3702ath12k_htt_print_phy_stats_tlv(const void *tag_buf, u16 tag_len, 3703 struct debug_htt_stats_req *stats_req) 3704{ 3705 const struct ath12k_htt_phy_stats_tlv *htt_stats_buf = tag_buf; 3706 u32 len = stats_req->buf_len; 3707 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3708 u8 *buf = stats_req->buf, i; 3709 3710 if (tag_len < sizeof(*htt_stats_buf)) 3711 return; 3712 3713 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_STATS_TLV:\n"); 3714 for (i = 0; i < ATH12K_HTT_STATS_MAX_CHAINS; i++) 3715 len += scnprintf(buf + len, buf_len - len, "bdf_nf_chain[%d] = %d\n", 3716 i, a_sle32_to_cpu(htt_stats_buf->nf_chain[i])); 3717 for (i = 0; i < ATH12K_HTT_STATS_MAX_CHAINS; i++) 3718 len += scnprintf(buf + len, buf_len - len, "runtime_nf_chain[%d] = %d\n", 3719 i, a_sle32_to_cpu(htt_stats_buf->runtime_nf_chain[i])); 3720 len += scnprintf(buf + len, buf_len - len, "false_radar_cnt = %u / %u (mins)\n", 3721 le32_to_cpu(htt_stats_buf->false_radar_cnt), 3722 le32_to_cpu(htt_stats_buf->fw_run_time)); 3723 len += scnprintf(buf + len, buf_len - len, "radar_cs_cnt = %u\n", 3724 le32_to_cpu(htt_stats_buf->radar_cs_cnt)); 3725 len += scnprintf(buf + len, buf_len - len, "ani_level = %d\n\n", 3726 a_sle32_to_cpu(htt_stats_buf->ani_level)); 3727 3728 stats_req->buf_len = len; 3729} 3730 3731static void 3732ath12k_htt_print_phy_counters_tlv(const void *tag_buf, u16 tag_len, 3733 struct debug_htt_stats_req *stats_req) 3734{ 3735 const struct ath12k_htt_phy_counters_tlv *htt_stats_buf = tag_buf; 3736 u32 len = stats_req->buf_len; 3737 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3738 u8 *buf = stats_req->buf; 3739 3740 if (tag_len < sizeof(*htt_stats_buf)) 3741 return; 3742 3743 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_COUNTERS_TLV:\n"); 3744 len += scnprintf(buf + len, buf_len - len, "rx_ofdma_timing_err_cnt = %u\n", 3745 le32_to_cpu(htt_stats_buf->rx_ofdma_timing_err_cnt)); 3746 len += scnprintf(buf + len, buf_len - len, "rx_cck_fail_cnt = %u\n", 3747 le32_to_cpu(htt_stats_buf->rx_cck_fail_cnt)); 3748 len += scnprintf(buf + len, buf_len - len, "mactx_abort_cnt = %u\n", 3749 le32_to_cpu(htt_stats_buf->mactx_abort_cnt)); 3750 len += scnprintf(buf + len, buf_len - len, "macrx_abort_cnt = %u\n", 3751 le32_to_cpu(htt_stats_buf->macrx_abort_cnt)); 3752 len += scnprintf(buf + len, buf_len - len, "phytx_abort_cnt = %u\n", 3753 le32_to_cpu(htt_stats_buf->phytx_abort_cnt)); 3754 len += scnprintf(buf + len, buf_len - len, "phyrx_abort_cnt = %u\n", 3755 le32_to_cpu(htt_stats_buf->phyrx_abort_cnt)); 3756 len += scnprintf(buf + len, buf_len - len, "phyrx_defer_abort_cnt = %u\n", 3757 le32_to_cpu(htt_stats_buf->phyrx_defer_abort_cnt)); 3758 len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_lstf_event_cnt = %u\n", 3759 le32_to_cpu(htt_stats_buf->rx_gain_adj_lstf_event_cnt)); 3760 len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_non_legacy_cnt = %u\n", 3761 le32_to_cpu(htt_stats_buf->rx_gain_adj_non_legacy_cnt)); 3762 len += print_array_to_buf(buf, len, "rx_pkt_cnt", htt_stats_buf->rx_pkt_cnt, 3763 ATH12K_HTT_MAX_RX_PKT_CNT, "\n"); 3764 len += print_array_to_buf(buf, len, "rx_pkt_crc_pass_cnt", 3765 htt_stats_buf->rx_pkt_crc_pass_cnt, 3766 ATH12K_HTT_MAX_RX_PKT_CRC_PASS_CNT, "\n"); 3767 len += print_array_to_buf(buf, len, "per_blk_err_cnt", 3768 htt_stats_buf->per_blk_err_cnt, 3769 ATH12K_HTT_MAX_PER_BLK_ERR_CNT, "\n"); 3770 len += print_array_to_buf(buf, len, "rx_ota_err_cnt", 3771 htt_stats_buf->rx_ota_err_cnt, 3772 ATH12K_HTT_MAX_RX_OTA_ERR_CNT, "\n\n"); 3773 3774 stats_req->buf_len = len; 3775} 3776 3777static void 3778ath12k_htt_print_phy_reset_stats_tlv(const void *tag_buf, u16 tag_len, 3779 struct debug_htt_stats_req *stats_req) 3780{ 3781 const struct ath12k_htt_phy_reset_stats_tlv *htt_stats_buf = tag_buf; 3782 u32 len = stats_req->buf_len; 3783 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3784 u8 *buf = stats_req->buf; 3785 3786 if (tag_len < sizeof(*htt_stats_buf)) 3787 return; 3788 3789 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_STATS_TLV:\n"); 3790 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 3791 le32_to_cpu(htt_stats_buf->pdev_id)); 3792 len += scnprintf(buf + len, buf_len - len, "chan_mhz = %u\n", 3793 le32_to_cpu(htt_stats_buf->chan_mhz)); 3794 len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq1 = %u\n", 3795 le32_to_cpu(htt_stats_buf->chan_band_center_freq1)); 3796 len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq2 = %u\n", 3797 le32_to_cpu(htt_stats_buf->chan_band_center_freq2)); 3798 len += scnprintf(buf + len, buf_len - len, "chan_phy_mode = %u\n", 3799 le32_to_cpu(htt_stats_buf->chan_phy_mode)); 3800 len += scnprintf(buf + len, buf_len - len, "chan_flags = 0x%0x\n", 3801 le32_to_cpu(htt_stats_buf->chan_flags)); 3802 len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n", 3803 le32_to_cpu(htt_stats_buf->chan_num)); 3804 len += scnprintf(buf + len, buf_len - len, "reset_cause = 0x%0x\n", 3805 le32_to_cpu(htt_stats_buf->reset_cause)); 3806 len += scnprintf(buf + len, buf_len - len, "prev_reset_cause = 0x%0x\n", 3807 le32_to_cpu(htt_stats_buf->prev_reset_cause)); 3808 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_src = 0x%0x\n", 3809 le32_to_cpu(htt_stats_buf->phy_warm_reset_src)); 3810 len += scnprintf(buf + len, buf_len - len, "rx_gain_tbl_mode = %d\n", 3811 le32_to_cpu(htt_stats_buf->rx_gain_tbl_mode)); 3812 len += scnprintf(buf + len, buf_len - len, "xbar_val = 0x%0x\n", 3813 le32_to_cpu(htt_stats_buf->xbar_val)); 3814 len += scnprintf(buf + len, buf_len - len, "force_calibration = %u\n", 3815 le32_to_cpu(htt_stats_buf->force_calibration)); 3816 len += scnprintf(buf + len, buf_len - len, "phyrf_mode = %u\n", 3817 le32_to_cpu(htt_stats_buf->phyrf_mode)); 3818 len += scnprintf(buf + len, buf_len - len, "phy_homechan = %u\n", 3819 le32_to_cpu(htt_stats_buf->phy_homechan)); 3820 len += scnprintf(buf + len, buf_len - len, "phy_tx_ch_mask = 0x%0x\n", 3821 le32_to_cpu(htt_stats_buf->phy_tx_ch_mask)); 3822 len += scnprintf(buf + len, buf_len - len, "phy_rx_ch_mask = 0x%0x\n", 3823 le32_to_cpu(htt_stats_buf->phy_rx_ch_mask)); 3824 len += scnprintf(buf + len, buf_len - len, "phybb_ini_mask = 0x%0x\n", 3825 le32_to_cpu(htt_stats_buf->phybb_ini_mask)); 3826 len += scnprintf(buf + len, buf_len - len, "phyrf_ini_mask = 0x%0x\n", 3827 le32_to_cpu(htt_stats_buf->phyrf_ini_mask)); 3828 len += scnprintf(buf + len, buf_len - len, "phy_dfs_en_mask = 0x%0x\n", 3829 le32_to_cpu(htt_stats_buf->phy_dfs_en_mask)); 3830 len += scnprintf(buf + len, buf_len - len, "phy_sscan_en_mask = 0x%0x\n", 3831 le32_to_cpu(htt_stats_buf->phy_sscan_en_mask)); 3832 len += scnprintf(buf + len, buf_len - len, "phy_synth_sel_mask = 0x%0x\n", 3833 le32_to_cpu(htt_stats_buf->phy_synth_sel_mask)); 3834 len += scnprintf(buf + len, buf_len - len, "phy_adfs_freq = %u\n", 3835 le32_to_cpu(htt_stats_buf->phy_adfs_freq)); 3836 len += scnprintf(buf + len, buf_len - len, "cck_fir_settings = 0x%0x\n", 3837 le32_to_cpu(htt_stats_buf->cck_fir_settings)); 3838 len += scnprintf(buf + len, buf_len - len, "phy_dyn_pri_chan = %u\n", 3839 le32_to_cpu(htt_stats_buf->phy_dyn_pri_chan)); 3840 len += scnprintf(buf + len, buf_len - len, "cca_thresh = 0x%0x\n", 3841 le32_to_cpu(htt_stats_buf->cca_thresh)); 3842 len += scnprintf(buf + len, buf_len - len, "dyn_cca_status = %u\n", 3843 le32_to_cpu(htt_stats_buf->dyn_cca_status)); 3844 len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_hw = 0x%x\n", 3845 le32_to_cpu(htt_stats_buf->rxdesense_thresh_hw)); 3846 len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_sw = 0x%x\n\n", 3847 le32_to_cpu(htt_stats_buf->rxdesense_thresh_sw)); 3848 3849 stats_req->buf_len = len; 3850} 3851 3852static void 3853ath12k_htt_print_phy_reset_counters_tlv(const void *tag_buf, u16 tag_len, 3854 struct debug_htt_stats_req *stats_req) 3855{ 3856 const struct ath12k_htt_phy_reset_counters_tlv *htt_stats_buf = tag_buf; 3857 u32 len = stats_req->buf_len; 3858 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3859 u8 *buf = stats_req->buf; 3860 3861 if (tag_len < sizeof(*htt_stats_buf)) 3862 return; 3863 3864 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_COUNTERS_TLV:\n"); 3865 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 3866 le32_to_cpu(htt_stats_buf->pdev_id)); 3867 len += scnprintf(buf + len, buf_len - len, "cf_active_low_fail_cnt = %u\n", 3868 le32_to_cpu(htt_stats_buf->cf_active_low_fail_cnt)); 3869 len += scnprintf(buf + len, buf_len - len, "cf_active_low_pass_cnt = %u\n", 3870 le32_to_cpu(htt_stats_buf->cf_active_low_pass_cnt)); 3871 len += scnprintf(buf + len, buf_len - len, "phy_off_through_vreg_cnt = %u\n", 3872 le32_to_cpu(htt_stats_buf->phy_off_through_vreg_cnt)); 3873 len += scnprintf(buf + len, buf_len - len, "force_calibration_cnt = %u\n", 3874 le32_to_cpu(htt_stats_buf->force_calibration_cnt)); 3875 len += scnprintf(buf + len, buf_len - len, "rf_mode_switch_phy_off_cnt = %u\n", 3876 le32_to_cpu(htt_stats_buf->rf_mode_switch_phy_off_cnt)); 3877 len += scnprintf(buf + len, buf_len - len, "temperature_recal_cnt = %u\n\n", 3878 le32_to_cpu(htt_stats_buf->temperature_recal_cnt)); 3879 3880 stats_req->buf_len = len; 3881} 3882 3883static void 3884ath12k_htt_print_phy_tpc_stats_tlv(const void *tag_buf, u16 tag_len, 3885 struct debug_htt_stats_req *stats_req) 3886{ 3887 const struct ath12k_htt_phy_tpc_stats_tlv *htt_stats_buf = tag_buf; 3888 u32 len = stats_req->buf_len; 3889 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3890 u8 *buf = stats_req->buf; 3891 3892 if (tag_len < sizeof(*htt_stats_buf)) 3893 return; 3894 3895 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_TPC_STATS_TLV:\n"); 3896 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 3897 le32_to_cpu(htt_stats_buf->pdev_id)); 3898 len += scnprintf(buf + len, buf_len - len, "tx_power_scale = %u\n", 3899 le32_to_cpu(htt_stats_buf->tx_power_scale)); 3900 len += scnprintf(buf + len, buf_len - len, "tx_power_scale_db = %u\n", 3901 le32_to_cpu(htt_stats_buf->tx_power_scale_db)); 3902 len += scnprintf(buf + len, buf_len - len, "min_negative_tx_power = %d\n", 3903 le32_to_cpu(htt_stats_buf->min_negative_tx_power)); 3904 len += scnprintf(buf + len, buf_len - len, "reg_ctl_domain = %u\n", 3905 le32_to_cpu(htt_stats_buf->reg_ctl_domain)); 3906 len += scnprintf(buf + len, buf_len - len, "twice_max_rd_power = %u\n", 3907 le32_to_cpu(htt_stats_buf->twice_max_rd_power)); 3908 len += scnprintf(buf + len, buf_len - len, "max_tx_power = %u\n", 3909 le32_to_cpu(htt_stats_buf->max_tx_power)); 3910 len += scnprintf(buf + len, buf_len - len, "home_max_tx_power = %u\n", 3911 le32_to_cpu(htt_stats_buf->home_max_tx_power)); 3912 len += scnprintf(buf + len, buf_len - len, "psd_power = %d\n", 3913 le32_to_cpu(htt_stats_buf->psd_power)); 3914 len += scnprintf(buf + len, buf_len - len, "eirp_power = %u\n", 3915 le32_to_cpu(htt_stats_buf->eirp_power)); 3916 len += scnprintf(buf + len, buf_len - len, "power_type_6ghz = %u\n", 3917 le32_to_cpu(htt_stats_buf->power_type_6ghz)); 3918 len += print_array_to_buf(buf, len, "max_reg_allowed_power", 3919 htt_stats_buf->max_reg_allowed_power, 3920 ATH12K_HTT_STATS_MAX_CHAINS, "\n"); 3921 len += print_array_to_buf(buf, len, "max_reg_allowed_power_6ghz", 3922 htt_stats_buf->max_reg_allowed_power_6ghz, 3923 ATH12K_HTT_STATS_MAX_CHAINS, "\n"); 3924 len += print_array_to_buf(buf, len, "sub_band_cfreq", 3925 htt_stats_buf->sub_band_cfreq, 3926 ATH12K_HTT_MAX_CH_PWR_INFO_SIZE, "\n"); 3927 len += print_array_to_buf(buf, len, "sub_band_txpower", 3928 htt_stats_buf->sub_band_txpower, 3929 ATH12K_HTT_MAX_CH_PWR_INFO_SIZE, "\n\n"); 3930 3931 stats_req->buf_len = len; 3932} 3933 3934static void 3935ath12k_htt_print_soc_txrx_stats_common_tlv(const void *tag_buf, u16 tag_len, 3936 struct debug_htt_stats_req *stats_req) 3937{ 3938 const struct ath12k_htt_t2h_soc_txrx_stats_common_tlv *htt_stats_buf = tag_buf; 3939 u64 drop_count; 3940 u32 len = stats_req->buf_len; 3941 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3942 u8 *buf = stats_req->buf; 3943 3944 if (tag_len < sizeof(*htt_stats_buf)) 3945 return; 3946 3947 drop_count = ath12k_le32hilo_to_u64(htt_stats_buf->inv_peers_msdu_drop_count_hi, 3948 htt_stats_buf->inv_peers_msdu_drop_count_lo); 3949 3950 len += scnprintf(buf + len, buf_len - len, "HTT_SOC_COMMON_STATS_TLV:\n"); 3951 len += scnprintf(buf + len, buf_len - len, "soc_drop_count = %llu\n\n", 3952 drop_count); 3953 3954 stats_req->buf_len = len; 3955} 3956 3957static void 3958ath12k_htt_print_tx_per_rate_stats_tlv(const void *tag_buf, u16 tag_len, 3959 struct debug_htt_stats_req *stats_req) 3960{ 3961 const struct ath12k_htt_tx_per_rate_stats_tlv *stats_buf = tag_buf; 3962 u32 len = stats_req->buf_len; 3963 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3964 u32 ru_size_cnt = 0; 3965 u32 rc_mode, ru_type; 3966 u8 *buf = stats_req->buf, i; 3967 const char *mode_prefix; 3968 3969 if (tag_len < sizeof(*stats_buf)) 3970 return; 3971 3972 rc_mode = le32_to_cpu(stats_buf->rc_mode); 3973 ru_type = le32_to_cpu(stats_buf->ru_type); 3974 3975 switch (rc_mode) { 3976 case ATH12K_HTT_STATS_RC_MODE_DLSU: 3977 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PER_STATS:\n"); 3978 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_SU:\n"); 3979 mode_prefix = "su"; 3980 break; 3981 case ATH12K_HTT_STATS_RC_MODE_DLMUMIMO: 3982 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_DL_MUMIMO:\n"); 3983 mode_prefix = "mu"; 3984 break; 3985 case ATH12K_HTT_STATS_RC_MODE_DLOFDMA: 3986 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_DL_OFDMA:\n"); 3987 mode_prefix = "ofdma"; 3988 if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY) 3989 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_STATS_NUM_AX_RU_SIZE_CNTRS; 3990 else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU) 3991 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; 3992 break; 3993 case ATH12K_HTT_STATS_RC_MODE_ULMUMIMO: 3994 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PER_STATS:\n"); 3995 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_UL_MUMIMO:\n"); 3996 mode_prefix = "ulmu"; 3997 break; 3998 case ATH12K_HTT_STATS_RC_MODE_ULOFDMA: 3999 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_UL_OFDMA:\n"); 4000 mode_prefix = "ulofdma"; 4001 if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY) 4002 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_STATS_NUM_AX_RU_SIZE_CNTRS; 4003 else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU) 4004 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; 4005 break; 4006 default: 4007 return; 4008 } 4009 4010 len += scnprintf(buf + len, buf_len - len, "\nPER per BW:\n"); 4011 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 4012 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 4013 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 4014 mode_prefix); 4015 else 4016 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 4017 mode_prefix); 4018 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 4019 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4020 le32_to_cpu(stats_buf->per_bw[i].ppdus_tried)); 4021 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 4022 le32_to_cpu(stats_buf->per_bw320.ppdus_tried)); 4023 4024 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 4025 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 4026 len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ", 4027 mode_prefix); 4028 else 4029 len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ", 4030 mode_prefix); 4031 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 4032 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4033 le32_to_cpu(stats_buf->per_bw[i].ppdus_ack_failed)); 4034 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 4035 le32_to_cpu(stats_buf->per_bw320.ppdus_ack_failed)); 4036 4037 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix); 4038 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 4039 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4040 le32_to_cpu(stats_buf->per_bw[i].mpdus_tried)); 4041 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 4042 le32_to_cpu(stats_buf->per_bw320.mpdus_tried)); 4043 4044 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix); 4045 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 4046 len += scnprintf(buf + len, buf_len - len, " %u:%u", i, 4047 le32_to_cpu(stats_buf->per_bw[i].mpdus_failed)); 4048 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 4049 le32_to_cpu(stats_buf->per_bw320.mpdus_failed)); 4050 4051 len += scnprintf(buf + len, buf_len - len, "\nPER per NSS:\n"); 4052 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 4053 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 4054 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 4055 mode_prefix); 4056 else 4057 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 4058 mode_prefix); 4059 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 4060 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 4061 le32_to_cpu(stats_buf->per_nss[i].ppdus_tried)); 4062 len += scnprintf(buf + len, buf_len - len, "\n"); 4063 4064 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 4065 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 4066 len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ", 4067 mode_prefix); 4068 else 4069 len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ", 4070 mode_prefix); 4071 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 4072 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 4073 le32_to_cpu(stats_buf->per_nss[i].ppdus_ack_failed)); 4074 len += scnprintf(buf + len, buf_len - len, "\n"); 4075 4076 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix); 4077 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 4078 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 4079 le32_to_cpu(stats_buf->per_nss[i].mpdus_tried)); 4080 len += scnprintf(buf + len, buf_len - len, "\n"); 4081 4082 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix); 4083 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 4084 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 4085 le32_to_cpu(stats_buf->per_nss[i].mpdus_failed)); 4086 len += scnprintf(buf + len, buf_len - len, "\n"); 4087 4088 len += scnprintf(buf + len, buf_len - len, "\nPER per MCS:\n"); 4089 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 4090 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 4091 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 4092 mode_prefix); 4093 else 4094 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 4095 mode_prefix); 4096 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 4097 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4098 le32_to_cpu(stats_buf->per_mcs[i].ppdus_tried)); 4099 len += scnprintf(buf + len, buf_len - len, "\n"); 4100 4101 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 4102 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 4103 len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ", 4104 mode_prefix); 4105 else 4106 len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ", 4107 mode_prefix); 4108 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 4109 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4110 le32_to_cpu(stats_buf->per_mcs[i].ppdus_ack_failed)); 4111 len += scnprintf(buf + len, buf_len - len, "\n"); 4112 4113 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix); 4114 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 4115 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4116 le32_to_cpu(stats_buf->per_mcs[i].mpdus_tried)); 4117 len += scnprintf(buf + len, buf_len - len, "\n"); 4118 4119 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix); 4120 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 4121 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 4122 le32_to_cpu(stats_buf->per_mcs[i].mpdus_failed)); 4123 len += scnprintf(buf + len, buf_len - len, "\n"); 4124 4125 if ((rc_mode == ATH12K_HTT_STATS_RC_MODE_DLOFDMA || 4126 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) && 4127 ru_type != ATH12K_HTT_STATS_RU_TYPE_INVALID) { 4128 len += scnprintf(buf + len, buf_len - len, "\nPER per RU:\n"); 4129 4130 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) 4131 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 4132 mode_prefix); 4133 else 4134 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 4135 mode_prefix); 4136 for (i = 0; i < ru_size_cnt; i++) 4137 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 4138 ath12k_tx_ru_size_to_str(ru_type, i), 4139 le32_to_cpu(stats_buf->ru[i].ppdus_tried)); 4140 len += scnprintf(buf + len, buf_len - len, "\n"); 4141 4142 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) 4143 len += scnprintf(buf + len, buf_len - len, 4144 "non_data_ppdus_%s = ", mode_prefix); 4145 else 4146 len += scnprintf(buf + len, buf_len - len, 4147 "ppdus_ack_failed_%s = ", mode_prefix); 4148 for (i = 0; i < ru_size_cnt; i++) 4149 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 4150 ath12k_tx_ru_size_to_str(ru_type, i), 4151 le32_to_cpu(stats_buf->ru[i].ppdus_ack_failed)); 4152 len += scnprintf(buf + len, buf_len - len, "\n"); 4153 4154 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", 4155 mode_prefix); 4156 for (i = 0; i < ru_size_cnt; i++) 4157 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 4158 ath12k_tx_ru_size_to_str(ru_type, i), 4159 le32_to_cpu(stats_buf->ru[i].mpdus_tried)); 4160 len += scnprintf(buf + len, buf_len - len, "\n"); 4161 4162 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", 4163 mode_prefix); 4164 for (i = 0; i < ru_size_cnt; i++) 4165 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 4166 ath12k_tx_ru_size_to_str(ru_type, i), 4167 le32_to_cpu(stats_buf->ru[i].mpdus_failed)); 4168 len += scnprintf(buf + len, buf_len - len, "\n\n"); 4169 } 4170 4171 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_DLMUMIMO) { 4172 len += scnprintf(buf + len, buf_len - len, "\nlast_probed_bw = %u\n", 4173 le32_to_cpu(stats_buf->last_probed_bw)); 4174 len += scnprintf(buf + len, buf_len - len, "last_probed_nss = %u\n", 4175 le32_to_cpu(stats_buf->last_probed_nss)); 4176 len += scnprintf(buf + len, buf_len - len, "last_probed_mcs = %u\n", 4177 le32_to_cpu(stats_buf->last_probed_mcs)); 4178 len += print_array_to_buf(buf, len, "MU Probe count per RC MODE", 4179 stats_buf->probe_cnt, 4180 ATH12K_HTT_RC_MODE_2D_COUNT, "\n\n"); 4181 } 4182 4183 stats_req->buf_len = len; 4184} 4185 4186static void 4187ath12k_htt_print_ast_entry_tlv(const void *tag_buf, u16 tag_len, 4188 struct debug_htt_stats_req *stats_req) 4189{ 4190 const struct ath12k_htt_ast_entry_tlv *htt_stats_buf = tag_buf; 4191 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4192 u32 len = stats_req->buf_len; 4193 u8 *buf = stats_req->buf; 4194 u32 mac_addr_l32; 4195 u32 mac_addr_h16; 4196 u32 ast_info; 4197 4198 if (tag_len < sizeof(*htt_stats_buf)) 4199 return; 4200 4201 mac_addr_l32 = le32_to_cpu(htt_stats_buf->mac_addr.mac_addr_l32); 4202 mac_addr_h16 = le32_to_cpu(htt_stats_buf->mac_addr.mac_addr_h16); 4203 ast_info = le32_to_cpu(htt_stats_buf->info); 4204 4205 len += scnprintf(buf + len, buf_len - len, "HTT_AST_ENTRY_TLV:\n"); 4206 len += scnprintf(buf + len, buf_len - len, "ast_index = %u\n", 4207 le32_to_cpu(htt_stats_buf->ast_index)); 4208 len += scnprintf(buf + len, buf_len - len, 4209 "mac_addr = %02x:%02x:%02x:%02x:%02x:%02x\n", 4210 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_0), 4211 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_1), 4212 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_2), 4213 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_3), 4214 u32_get_bits(mac_addr_h16, ATH12K_HTT_MAC_ADDR_H16_0), 4215 u32_get_bits(mac_addr_h16, ATH12K_HTT_MAC_ADDR_H16_1)); 4216 4217 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n", 4218 le32_to_cpu(htt_stats_buf->sw_peer_id)); 4219 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 4220 u32_get_bits(ast_info, ATH12K_HTT_AST_PDEV_ID_INFO)); 4221 len += scnprintf(buf + len, buf_len - len, "vdev_id = %u\n", 4222 u32_get_bits(ast_info, ATH12K_HTT_AST_VDEV_ID_INFO)); 4223 len += scnprintf(buf + len, buf_len - len, "next_hop = %u\n", 4224 u32_get_bits(ast_info, ATH12K_HTT_AST_NEXT_HOP_INFO)); 4225 len += scnprintf(buf + len, buf_len - len, "mcast = %u\n", 4226 u32_get_bits(ast_info, ATH12K_HTT_AST_MCAST_INFO)); 4227 len += scnprintf(buf + len, buf_len - len, "monitor_direct = %u\n", 4228 u32_get_bits(ast_info, ATH12K_HTT_AST_MONITOR_DIRECT_INFO)); 4229 len += scnprintf(buf + len, buf_len - len, "mesh_sta = %u\n", 4230 u32_get_bits(ast_info, ATH12K_HTT_AST_MESH_STA_INFO)); 4231 len += scnprintf(buf + len, buf_len - len, "mec = %u\n", 4232 u32_get_bits(ast_info, ATH12K_HTT_AST_MEC_INFO)); 4233 len += scnprintf(buf + len, buf_len - len, "intra_bss = %u\n\n", 4234 u32_get_bits(ast_info, ATH12K_HTT_AST_INTRA_BSS_INFO)); 4235 4236 stats_req->buf_len = len; 4237} 4238 4239static const char* 4240ath12k_htt_get_punct_dir_type_str(enum ath12k_htt_stats_direction direction) 4241{ 4242 switch (direction) { 4243 case ATH12K_HTT_STATS_DIRECTION_TX: 4244 return "tx"; 4245 case ATH12K_HTT_STATS_DIRECTION_RX: 4246 return "rx"; 4247 default: 4248 return "unknown"; 4249 } 4250} 4251 4252static const char* 4253ath12k_htt_get_punct_ppdu_type_str(enum ath12k_htt_stats_ppdu_type ppdu_type) 4254{ 4255 switch (ppdu_type) { 4256 case ATH12K_HTT_STATS_PPDU_TYPE_MODE_SU: 4257 return "su"; 4258 case ATH12K_HTT_STATS_PPDU_TYPE_DL_MU_MIMO: 4259 return "dl_mu_mimo"; 4260 case ATH12K_HTT_STATS_PPDU_TYPE_UL_MU_MIMO: 4261 return "ul_mu_mimo"; 4262 case ATH12K_HTT_STATS_PPDU_TYPE_DL_MU_OFDMA: 4263 return "dl_mu_ofdma"; 4264 case ATH12K_HTT_STATS_PPDU_TYPE_UL_MU_OFDMA: 4265 return "ul_mu_ofdma"; 4266 default: 4267 return "unknown"; 4268 } 4269} 4270 4271static const char* 4272ath12k_htt_get_punct_pream_type_str(enum ath12k_htt_stats_param_type pream_type) 4273{ 4274 switch (pream_type) { 4275 case ATH12K_HTT_STATS_PREAM_OFDM: 4276 return "ofdm"; 4277 case ATH12K_HTT_STATS_PREAM_CCK: 4278 return "cck"; 4279 case ATH12K_HTT_STATS_PREAM_HT: 4280 return "ht"; 4281 case ATH12K_HTT_STATS_PREAM_VHT: 4282 return "ac"; 4283 case ATH12K_HTT_STATS_PREAM_HE: 4284 return "ax"; 4285 case ATH12K_HTT_STATS_PREAM_EHT: 4286 return "be"; 4287 default: 4288 return "unknown"; 4289 } 4290} 4291 4292static void 4293ath12k_htt_print_puncture_stats_tlv(const void *tag_buf, u16 tag_len, 4294 struct debug_htt_stats_req *stats_req) 4295{ 4296 const struct ath12k_htt_pdev_puncture_stats_tlv *stats_buf = tag_buf; 4297 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4298 u32 len = stats_req->buf_len; 4299 u8 *buf = stats_req->buf; 4300 const char *direction; 4301 const char *ppdu_type; 4302 const char *preamble; 4303 u32 mac_id__word; 4304 u32 subband_limit; 4305 u8 i; 4306 4307 if (tag_len < sizeof(*stats_buf)) 4308 return; 4309 4310 mac_id__word = le32_to_cpu(stats_buf->mac_id__word); 4311 subband_limit = min(le32_to_cpu(stats_buf->subband_cnt), 4312 ATH12K_HTT_PUNCT_STATS_MAX_SUBBAND_CNT); 4313 4314 direction = ath12k_htt_get_punct_dir_type_str(le32_to_cpu(stats_buf->direction)); 4315 ppdu_type = ath12k_htt_get_punct_ppdu_type_str(le32_to_cpu(stats_buf->ppdu_type)); 4316 preamble = ath12k_htt_get_punct_pream_type_str(le32_to_cpu(stats_buf->preamble)); 4317 4318 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_PUNCTURE_STATS_TLV:\n"); 4319 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 4320 u32_get_bits(mac_id__word, ATH12K_HTT_STATS_MAC_ID)); 4321 len += scnprintf(buf + len, buf_len - len, 4322 "%s_%s_%s_last_used_pattern_mask = 0x%08x\n", 4323 direction, preamble, ppdu_type, 4324 le32_to_cpu(stats_buf->last_used_pattern_mask)); 4325 4326 for (i = 0; i < subband_limit; i++) { 4327 len += scnprintf(buf + len, buf_len - len, 4328 "%s_%s_%s_num_subbands_used_cnt_%02d = %u\n", 4329 direction, preamble, ppdu_type, i + 1, 4330 le32_to_cpu(stats_buf->num_subbands_used_cnt[i])); 4331 } 4332 len += scnprintf(buf + len, buf_len - len, "\n"); 4333 4334 stats_req->buf_len = len; 4335} 4336 4337static void 4338ath12k_htt_print_dmac_reset_stats_tlv(const void *tag_buf, u16 tag_len, 4339 struct debug_htt_stats_req *stats_req) 4340{ 4341 const struct ath12k_htt_dmac_reset_stats_tlv *htt_stats_buf = tag_buf; 4342 u8 *buf = stats_req->buf; 4343 u32 len = stats_req->buf_len; 4344 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4345 u64 time; 4346 4347 if (tag_len < sizeof(*htt_stats_buf)) 4348 return; 4349 4350 len += scnprintf(buf + len, buf_len - len, "HTT_DMAC_RESET_STATS_TLV:\n"); 4351 len += scnprintf(buf + len, buf_len - len, "reset_count = %u\n", 4352 le32_to_cpu(htt_stats_buf->reset_count)); 4353 time = ath12k_le32hilo_to_u64(htt_stats_buf->reset_time_hi_ms, 4354 htt_stats_buf->reset_time_lo_ms); 4355 len += scnprintf(buf + len, buf_len - len, "reset_time_ms = %llu\n", time); 4356 time = ath12k_le32hilo_to_u64(htt_stats_buf->disengage_time_hi_ms, 4357 htt_stats_buf->disengage_time_lo_ms); 4358 len += scnprintf(buf + len, buf_len - len, "disengage_time_ms = %llu\n", time); 4359 4360 time = ath12k_le32hilo_to_u64(htt_stats_buf->engage_time_hi_ms, 4361 htt_stats_buf->engage_time_lo_ms); 4362 len += scnprintf(buf + len, buf_len - len, "engage_time_ms = %llu\n", time); 4363 4364 len += scnprintf(buf + len, buf_len - len, "disengage_count = %u\n", 4365 le32_to_cpu(htt_stats_buf->disengage_count)); 4366 len += scnprintf(buf + len, buf_len - len, "engage_count = %u\n", 4367 le32_to_cpu(htt_stats_buf->engage_count)); 4368 len += scnprintf(buf + len, buf_len - len, "drain_dest_ring_mask = 0x%x\n\n", 4369 le32_to_cpu(htt_stats_buf->drain_dest_ring_mask)); 4370 4371 stats_req->buf_len = len; 4372} 4373 4374static void 4375ath12k_htt_print_pdev_sched_algo_ofdma_stats_tlv(const void *tag_buf, u16 tag_len, 4376 struct debug_htt_stats_req *stats_req) 4377{ 4378 const struct ath12k_htt_pdev_sched_algo_ofdma_stats_tlv *htt_stats_buf = tag_buf; 4379 u8 *buf = stats_req->buf; 4380 u32 len = stats_req->buf_len; 4381 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4382 u32 mac_id_word; 4383 4384 if (tag_len < sizeof(*htt_stats_buf)) 4385 return; 4386 4387 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 4388 4389 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_SCHED_ALGO_TLV:\n"); 4390 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 4391 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 4392 len += print_array_to_buf(buf, len, "rate_based_dlofdma_enabled_count", 4393 htt_stats_buf->rate_based_dlofdma_enabled_cnt, 4394 ATH12K_HTT_NUM_AC_WMM, "\n"); 4395 len += print_array_to_buf(buf, len, "rate_based_dlofdma_disabled_count", 4396 htt_stats_buf->rate_based_dlofdma_disabled_cnt, 4397 ATH12K_HTT_NUM_AC_WMM, "\n"); 4398 len += print_array_to_buf(buf, len, "rate_based_dlofdma_probing_count", 4399 htt_stats_buf->rate_based_dlofdma_disabled_cnt, 4400 ATH12K_HTT_NUM_AC_WMM, "\n"); 4401 len += print_array_to_buf(buf, len, "rate_based_dlofdma_monitoring_count", 4402 htt_stats_buf->rate_based_dlofdma_monitor_cnt, 4403 ATH12K_HTT_NUM_AC_WMM, "\n"); 4404 len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_enabled_count", 4405 htt_stats_buf->chan_acc_lat_based_dlofdma_enabled_cnt, 4406 ATH12K_HTT_NUM_AC_WMM, "\n"); 4407 len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_disabled_count", 4408 htt_stats_buf->chan_acc_lat_based_dlofdma_disabled_cnt, 4409 ATH12K_HTT_NUM_AC_WMM, "\n"); 4410 len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_monitoring_count", 4411 htt_stats_buf->chan_acc_lat_based_dlofdma_monitor_cnt, 4412 ATH12K_HTT_NUM_AC_WMM, "\n"); 4413 len += print_array_to_buf(buf, len, "downgrade_to_dl_su_ru_alloc_fail", 4414 htt_stats_buf->downgrade_to_dl_su_ru_alloc_fail, 4415 ATH12K_HTT_NUM_AC_WMM, "\n"); 4416 len += print_array_to_buf(buf, len, "candidate_list_single_user_disable_ofdma", 4417 htt_stats_buf->candidate_list_single_user_disable_ofdma, 4418 ATH12K_HTT_NUM_AC_WMM, "\n"); 4419 len += print_array_to_buf(buf, len, "dl_cand_list_dropped_high_ul_qos_weight", 4420 htt_stats_buf->dl_cand_list_dropped_high_ul_qos_weight, 4421 ATH12K_HTT_NUM_AC_WMM, "\n"); 4422 len += print_array_to_buf(buf, len, "ax_dlofdma_disabled_due_to_pipelining", 4423 htt_stats_buf->ax_dlofdma_disabled_due_to_pipelining, 4424 ATH12K_HTT_NUM_AC_WMM, "\n"); 4425 len += print_array_to_buf(buf, len, "dlofdma_disabled_su_only_eligible", 4426 htt_stats_buf->dlofdma_disabled_su_only_eligible, 4427 ATH12K_HTT_NUM_AC_WMM, "\n"); 4428 len += print_array_to_buf(buf, len, "dlofdma_disabled_consec_no_mpdus_tried", 4429 htt_stats_buf->dlofdma_disabled_consec_no_mpdus_tried, 4430 ATH12K_HTT_NUM_AC_WMM, "\n"); 4431 len += print_array_to_buf(buf, len, "dlofdma_disabled_consec_no_mpdus_success", 4432 htt_stats_buf->dlofdma_disabled_consec_no_mpdus_success, 4433 ATH12K_HTT_NUM_AC_WMM, "\n\n"); 4434 4435 stats_req->buf_len = len; 4436} 4437 4438static void 4439ath12k_htt_print_tx_pdev_rate_stats_be_ofdma_tlv(const void *tag_buf, u16 tag_len, 4440 struct debug_htt_stats_req *stats_req) 4441{ 4442 const struct ath12k_htt_tx_pdev_rate_stats_be_ofdma_tlv *htt_stats_buf = tag_buf; 4443 u8 *buf = stats_req->buf; 4444 u32 len = stats_req->buf_len; 4445 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4446 u32 mac_id_word; 4447 u8 i; 4448 4449 if (tag_len < sizeof(*htt_stats_buf)) 4450 return; 4451 4452 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 4453 4454 len += scnprintf(buf + len, buf_len - len, 4455 "HTT_TX_PDEV_RATE_STATS_BE_OFDMA_TLV:\n"); 4456 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 4457 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 4458 len += scnprintf(buf + len, buf_len - len, "be_ofdma_tx_ldpc = %u\n", 4459 le32_to_cpu(htt_stats_buf->be_ofdma_tx_ldpc)); 4460 len += print_array_to_buf(buf, len, "be_ofdma_tx_mcs", 4461 htt_stats_buf->be_ofdma_tx_mcs, 4462 ATH12K_HTT_TX_PDEV_NUM_BE_MCS_CNTRS, "\n"); 4463 len += print_array_to_buf(buf, len, "be_ofdma_eht_sig_mcs", 4464 htt_stats_buf->be_ofdma_eht_sig_mcs, 4465 ATH12K_HTT_TX_PDEV_NUM_EHT_SIG_MCS_CNTRS, "\n"); 4466 len += scnprintf(buf + len, buf_len - len, "be_ofdma_tx_ru_size = "); 4467 for (i = 0; i < ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; i++) 4468 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 4469 ath12k_htt_be_tx_rx_ru_size_to_str(i), 4470 le32_to_cpu(htt_stats_buf->be_ofdma_tx_ru_size[i])); 4471 len += scnprintf(buf + len, buf_len - len, "\n"); 4472 len += print_array_to_buf_index(buf, len, "be_ofdma_tx_nss = ", 1, 4473 htt_stats_buf->be_ofdma_tx_nss, 4474 ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS, 4475 "\n"); 4476 len += print_array_to_buf(buf, len, "be_ofdma_tx_bw", 4477 htt_stats_buf->be_ofdma_tx_bw, 4478 ATH12K_HTT_TX_PDEV_NUM_BE_BW_CNTRS, "\n"); 4479 for (i = 0; i < ATH12K_HTT_TX_PDEV_NUM_GI_CNTRS; i++) { 4480 len += scnprintf(buf + len, buf_len - len, 4481 "be_ofdma_tx_gi[%u]", i); 4482 len += print_array_to_buf(buf, len, "", htt_stats_buf->gi[i], 4483 ATH12K_HTT_TX_PDEV_NUM_BE_MCS_CNTRS, "\n"); 4484 } 4485 len += scnprintf(buf + len, buf_len - len, "\n"); 4486 4487 stats_req->buf_len = len; 4488} 4489 4490static void 4491ath12k_htt_print_pdev_mbssid_ctrl_frame_stats_tlv(const void *tag_buf, u16 tag_len, 4492 struct debug_htt_stats_req *stats_req) 4493{ 4494 const struct ath12k_htt_pdev_mbssid_ctrl_frame_tlv *htt_stats_buf = tag_buf; 4495 u8 *buf = stats_req->buf; 4496 u32 len = stats_req->buf_len; 4497 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4498 u32 mac_id_word; 4499 4500 if (tag_len < sizeof(*htt_stats_buf)) 4501 return; 4502 4503 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 4504 4505 len += scnprintf(buf + len, buf_len - len, "HTT_MBSSID_CTRL_FRAME_STATS_TLV:\n"); 4506 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 4507 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 4508 len += scnprintf(buf + len, buf_len - len, "basic_trigger_across_bss = %u\n", 4509 le32_to_cpu(htt_stats_buf->basic_trigger_across_bss)); 4510 len += scnprintf(buf + len, buf_len - len, "basic_trigger_within_bss = %u\n", 4511 le32_to_cpu(htt_stats_buf->basic_trigger_within_bss)); 4512 len += scnprintf(buf + len, buf_len - len, "bsr_trigger_across_bss = %u\n", 4513 le32_to_cpu(htt_stats_buf->bsr_trigger_across_bss)); 4514 len += scnprintf(buf + len, buf_len - len, "bsr_trigger_within_bss = %u\n", 4515 le32_to_cpu(htt_stats_buf->bsr_trigger_within_bss)); 4516 len += scnprintf(buf + len, buf_len - len, "mu_rts_across_bss = %u\n", 4517 le32_to_cpu(htt_stats_buf->mu_rts_across_bss)); 4518 len += scnprintf(buf + len, buf_len - len, "mu_rts_within_bss = %u\n", 4519 le32_to_cpu(htt_stats_buf->mu_rts_within_bss)); 4520 len += scnprintf(buf + len, buf_len - len, "ul_mumimo_trigger_across_bss = %u\n", 4521 le32_to_cpu(htt_stats_buf->ul_mumimo_trigger_across_bss)); 4522 len += scnprintf(buf + len, buf_len - len, 4523 "ul_mumimo_trigger_within_bss = %u\n\n", 4524 le32_to_cpu(htt_stats_buf->ul_mumimo_trigger_within_bss)); 4525 4526 stats_req->buf_len = len; 4527} 4528 4529static inline void 4530ath12k_htt_print_tx_pdev_rate_stats_tlv(const void *tag_buf, u16 tag_len, 4531 struct debug_htt_stats_req *stats_req) 4532{ 4533 const struct ath12k_htt_tx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf; 4534 u8 *buf = stats_req->buf; 4535 u32 len = stats_req->buf_len; 4536 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4537 u8 i, j; 4538 u32 mac_id_word; 4539 4540 if (tag_len < sizeof(*htt_stats_buf)) 4541 return; 4542 4543 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id_word); 4544 4545 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_RATE_STATS_TLV:\n"); 4546 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 4547 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 4548 len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n", 4549 le32_to_cpu(htt_stats_buf->tx_ldpc)); 4550 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_tx_ldpc = %u\n", 4551 le32_to_cpu(htt_stats_buf->ac_mu_mimo_tx_ldpc)); 4552 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_tx_ldpc = %u\n", 4553 le32_to_cpu(htt_stats_buf->ax_mu_mimo_tx_ldpc)); 4554 len += scnprintf(buf + len, buf_len - len, "ofdma_tx_ldpc = %u\n", 4555 le32_to_cpu(htt_stats_buf->ofdma_tx_ldpc)); 4556 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n", 4557 le32_to_cpu(htt_stats_buf->rts_cnt)); 4558 len += scnprintf(buf + len, buf_len - len, "rts_success = %u\n", 4559 le32_to_cpu(htt_stats_buf->rts_success)); 4560 len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n", 4561 le32_to_cpu(htt_stats_buf->ack_rssi)); 4562 len += scnprintf(buf + len, buf_len - len, 4563 "Legacy CCK Rates: 1 Mbps: %u, 2 Mbps: %u, 5.5 Mbps: %u, 12 Mbps: %u\n", 4564 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[0]), 4565 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[1]), 4566 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[2]), 4567 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[3])); 4568 len += scnprintf(buf + len, buf_len - len, 4569 "Legacy OFDM Rates: 6 Mbps: %u, 9 Mbps: %u, 12 Mbps: %u, 18 Mbps: %u\n" 4570 " 24 Mbps: %u, 36 Mbps: %u, 48 Mbps: %u, 54 Mbps: %u\n", 4571 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[0]), 4572 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[1]), 4573 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[2]), 4574 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[3]), 4575 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[4]), 4576 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[5]), 4577 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[6]), 4578 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[7])); 4579 len += scnprintf(buf + len, buf_len - len, "HE LTF: 1x: %u, 2x: %u, 4x: %u\n", 4580 le32_to_cpu(htt_stats_buf->tx_he_ltf[1]), 4581 le32_to_cpu(htt_stats_buf->tx_he_ltf[2]), 4582 le32_to_cpu(htt_stats_buf->tx_he_ltf[3])); 4583 4584 len += print_array_to_buf(buf, len, "tx_mcs", htt_stats_buf->tx_mcs, 4585 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL); 4586 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++) 4587 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4588 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4589 le32_to_cpu(htt_stats_buf->tx_mcs_ext[j])); 4590 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA2_MCS_COUNTERS; j++) 4591 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4592 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS + 4593 ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA2_MCS_COUNTERS, 4594 le32_to_cpu(htt_stats_buf->tx_mcs_ext_2[j])); 4595 len += scnprintf(buf + len, buf_len - len, "\n"); 4596 4597 len += print_array_to_buf(buf, len, "ax_mu_mimo_tx_mcs", 4598 htt_stats_buf->ax_mu_mimo_tx_mcs, 4599 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL); 4600 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++) 4601 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4602 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4603 le32_to_cpu(htt_stats_buf->ax_mu_mimo_tx_mcs_ext[j])); 4604 len += scnprintf(buf + len, buf_len - len, "\n"); 4605 4606 len += print_array_to_buf(buf, len, "ofdma_tx_mcs", 4607 htt_stats_buf->ofdma_tx_mcs, 4608 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL); 4609 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++) 4610 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4611 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4612 le32_to_cpu(htt_stats_buf->ofdma_tx_mcs_ext[j])); 4613 len += scnprintf(buf + len, buf_len - len, "\n"); 4614 4615 len += scnprintf(buf + len, buf_len - len, "tx_nss ="); 4616 for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) 4617 len += scnprintf(buf + len, buf_len - len, " %u:%u,", 4618 j, le32_to_cpu(htt_stats_buf->tx_nss[j - 1])); 4619 len--; 4620 len += scnprintf(buf + len, buf_len - len, "\n"); 4621 4622 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_tx_nss ="); 4623 for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) 4624 len += scnprintf(buf + len, buf_len - len, " %u:%u,", 4625 j, le32_to_cpu(htt_stats_buf->ac_mu_mimo_tx_nss[j - 1])); 4626 len--; 4627 len += scnprintf(buf + len, buf_len - len, "\n"); 4628 4629 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_tx_nss ="); 4630 for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) 4631 len += scnprintf(buf + len, buf_len - len, " %u:%u,", 4632 j, le32_to_cpu(htt_stats_buf->ax_mu_mimo_tx_nss[j - 1])); 4633 len--; 4634 len += scnprintf(buf + len, buf_len - len, "\n"); 4635 4636 len += scnprintf(buf + len, buf_len - len, "ofdma_tx_nss ="); 4637 for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) 4638 len += scnprintf(buf + len, buf_len - len, " %u:%u,", 4639 j, le32_to_cpu(htt_stats_buf->ofdma_tx_nss[j - 1])); 4640 len--; 4641 len += scnprintf(buf + len, buf_len - len, "\n"); 4642 4643 len += print_array_to_buf(buf, len, "tx_bw", htt_stats_buf->tx_bw, 4644 ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, NULL); 4645 len += scnprintf(buf + len, buf_len - len, ", %u:%u\n", 4646 ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, 4647 le32_to_cpu(htt_stats_buf->tx_bw_320mhz)); 4648 4649 len += print_array_to_buf(buf, len, "tx_stbc", 4650 htt_stats_buf->tx_stbc, 4651 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL); 4652 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++) 4653 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4654 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4655 le32_to_cpu(htt_stats_buf->tx_stbc_ext[j])); 4656 len += scnprintf(buf + len, buf_len - len, "\n"); 4657 4658 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 4659 len += scnprintf(buf + len, (buf_len - len), 4660 "tx_gi[%u] =", j); 4661 len += print_array_to_buf(buf, len, NULL, htt_stats_buf->tx_gi[j], 4662 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4663 NULL); 4664 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; i++) 4665 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4666 i + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4667 le32_to_cpu(htt_stats_buf->tx_gi_ext[j][i])); 4668 len += scnprintf(buf + len, buf_len - len, "\n"); 4669 } 4670 4671 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 4672 len += scnprintf(buf + len, (buf_len - len), 4673 "ac_mu_mimo_tx_gi[%u] =", j); 4674 len += print_array_to_buf(buf, len, NULL, 4675 htt_stats_buf->ac_mu_mimo_tx_gi[j], 4676 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4677 "\n"); 4678 } 4679 4680 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 4681 len += scnprintf(buf + len, (buf_len - len), 4682 "ax_mu_mimo_tx_gi[%u] =", j); 4683 len += print_array_to_buf(buf, len, NULL, htt_stats_buf->ax_mimo_tx_gi[j], 4684 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4685 NULL); 4686 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; i++) 4687 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4688 i + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4689 le32_to_cpu(htt_stats_buf->ax_tx_gi_ext[j][i])); 4690 len += scnprintf(buf + len, buf_len - len, "\n"); 4691 } 4692 4693 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 4694 len += scnprintf(buf + len, (buf_len - len), 4695 "ofdma_tx_gi[%u] = ", j); 4696 len += print_array_to_buf(buf, len, NULL, htt_stats_buf->ofdma_tx_gi[j], 4697 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4698 NULL); 4699 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; i++) 4700 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4701 i + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, 4702 le32_to_cpu(htt_stats_buf->ofd_tx_gi_ext[j][i])); 4703 len += scnprintf(buf + len, buf_len - len, "\n"); 4704 } 4705 4706 len += print_array_to_buf(buf, len, "tx_su_mcs", htt_stats_buf->tx_su_mcs, 4707 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4708 len += print_array_to_buf(buf, len, "tx_mu_mcs", htt_stats_buf->tx_mu_mcs, 4709 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4710 len += print_array_to_buf(buf, len, "ac_mu_mimo_tx_mcs", 4711 htt_stats_buf->ac_mu_mimo_tx_mcs, 4712 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4713 len += print_array_to_buf(buf, len, "ac_mu_mimo_tx_bw", 4714 htt_stats_buf->ac_mu_mimo_tx_bw, 4715 ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 4716 len += print_array_to_buf(buf, len, "ax_mu_mimo_tx_bw", 4717 htt_stats_buf->ax_mu_mimo_tx_bw, 4718 ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 4719 len += print_array_to_buf(buf, len, "ofdma_tx_bw", 4720 htt_stats_buf->ofdma_tx_bw, 4721 ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 4722 len += print_array_to_buf(buf, len, "tx_pream", htt_stats_buf->tx_pream, 4723 ATH12K_HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n"); 4724 len += print_array_to_buf(buf, len, "tx_dcm", htt_stats_buf->tx_dcm, 4725 ATH12K_HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\n"); 4726 4727 stats_req->buf_len = len; 4728} 4729 4730static void 4731ath12k_htt_print_histogram_stats_tlv(const void *tag_buf, u16 tag_len, 4732 struct debug_htt_stats_req *stats_req) 4733{ 4734 const struct ath12k_htt_tx_histogram_stats_tlv *stats_buf = tag_buf; 4735 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4736 u32 len = stats_req->buf_len; 4737 u8 *buf = stats_req->buf; 4738 4739 if (tag_len < sizeof(*stats_buf)) 4740 return; 4741 4742 len += scnprintf(buf + len, buf_len - len, "low_latency_rate_cnt = %u\n", 4743 le32_to_cpu(stats_buf->low_latency_rate_cnt)); 4744 len += scnprintf(buf + len, buf_len - len, "su_burst_rate_drop_cnt = %u\n", 4745 le32_to_cpu(stats_buf->su_burst_rate_drop_cnt)); 4746 len += scnprintf(buf + len, buf_len - len, "su_burst_rate_drop_fail_cnt = %u\n", 4747 le32_to_cpu(stats_buf->su_burst_rate_drop_fail_cnt)); 4748 len += scnprintf(buf + len, buf_len - len, "rate_retry_mcs_drop_cnt = %u\n", 4749 le32_to_cpu(stats_buf->rate_retry_mcs_drop_cnt)); 4750 4751 len += scnprintf(buf + len, buf_len - len, "\nPER_HISTOGRAM_STATS\n"); 4752 len += print_array_to_buf(buf, len, "mcs_drop_rate", stats_buf->mcs_drop_rate, 4753 ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_DROP_COUNTERS, "\n"); 4754 len += print_array_to_buf(buf, len, "per_histogram_count", 4755 stats_buf->per_histogram_cnt, 4756 ATH12K_HTT_TX_PDEV_STATS_NUM_PER_COUNTERS, "\n\n"); 4757 4758 stats_req->buf_len = len; 4759} 4760 4761static inline void 4762ath12k_htt_print_rx_pdev_rate_stats_tlv(const void *tag_buf, u16 tag_len, 4763 struct debug_htt_stats_req *stats_req) 4764{ 4765 const struct ath12k_htt_rx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf; 4766 u8 *buf = stats_req->buf; 4767 u32 len = stats_req->buf_len; 4768 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4769 u8 i, j; 4770 u32 mac_id_word; 4771 4772 if (tag_len < sizeof(*htt_stats_buf)) 4773 return; 4774 4775 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id_word); 4776 4777 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_STATS_TLV:\n"); 4778 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 4779 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 4780 len += scnprintf(buf + len, buf_len - len, "nsts = %u\n", 4781 le32_to_cpu(htt_stats_buf->nsts)); 4782 len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n", 4783 le32_to_cpu(htt_stats_buf->rx_ldpc)); 4784 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n", 4785 le32_to_cpu(htt_stats_buf->rts_cnt)); 4786 len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n", 4787 le32_to_cpu(htt_stats_buf->rssi_mgmt)); 4788 len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n", 4789 le32_to_cpu(htt_stats_buf->rssi_data)); 4790 len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n", 4791 le32_to_cpu(htt_stats_buf->rssi_comb)); 4792 len += scnprintf(buf + len, buf_len - len, "rssi_in_dbm = %d\n", 4793 le32_to_cpu(htt_stats_buf->rssi_in_dbm)); 4794 len += scnprintf(buf + len, buf_len - len, "rx_evm_nss_count = %u\n", 4795 le32_to_cpu(htt_stats_buf->nss_count)); 4796 len += scnprintf(buf + len, buf_len - len, "rx_evm_pilot_count = %u\n", 4797 le32_to_cpu(htt_stats_buf->pilot_count)); 4798 len += scnprintf(buf + len, buf_len - len, "rx_11ax_su_ext = %u\n", 4799 le32_to_cpu(htt_stats_buf->rx_11ax_su_ext)); 4800 len += scnprintf(buf + len, buf_len - len, "rx_11ac_mumimo = %u\n", 4801 le32_to_cpu(htt_stats_buf->rx_11ac_mumimo)); 4802 len += scnprintf(buf + len, buf_len - len, "rx_11ax_mumimo = %u\n", 4803 le32_to_cpu(htt_stats_buf->rx_11ax_mumimo)); 4804 len += scnprintf(buf + len, buf_len - len, "rx_11ax_ofdma = %u\n", 4805 le32_to_cpu(htt_stats_buf->rx_11ax_ofdma)); 4806 len += scnprintf(buf + len, buf_len - len, "txbf = %u\n", 4807 le32_to_cpu(htt_stats_buf->txbf)); 4808 len += scnprintf(buf + len, buf_len - len, "rx_su_ndpa = %u\n", 4809 le32_to_cpu(htt_stats_buf->rx_su_ndpa)); 4810 len += scnprintf(buf + len, buf_len - len, "rx_mu_ndpa = %u\n", 4811 le32_to_cpu(htt_stats_buf->rx_mu_ndpa)); 4812 len += scnprintf(buf + len, buf_len - len, "rx_br_poll = %u\n", 4813 le32_to_cpu(htt_stats_buf->rx_br_poll)); 4814 len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_low = %u\n", 4815 le32_to_cpu(htt_stats_buf->rx_active_dur_us_low)); 4816 len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_high = %u\n", 4817 le32_to_cpu(htt_stats_buf->rx_active_dur_us_high)); 4818 len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_ofdma = %u\n", 4819 le32_to_cpu(htt_stats_buf->rx_11ax_ul_ofdma)); 4820 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_stbc = %u\n", 4821 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_stbc)); 4822 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_ldpc = %u\n", 4823 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_ldpc)); 4824 len += scnprintf(buf + len, buf_len - len, "per_chain_rssi_pkt_type = %#x\n", 4825 le32_to_cpu(htt_stats_buf->per_chain_rssi_pkt_type)); 4826 4827 len += print_array_to_buf(buf, len, "rx_nss", htt_stats_buf->rx_nss, 4828 ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 4829 len += print_array_to_buf(buf, len, "rx_dcm", htt_stats_buf->rx_dcm, 4830 ATH12K_HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n"); 4831 len += print_array_to_buf(buf, len, "rx_stbc", htt_stats_buf->rx_stbc, 4832 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4833 len += print_array_to_buf(buf, len, "rx_bw", htt_stats_buf->rx_bw, 4834 ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 4835 len += print_array_to_buf(buf, len, "rx_pream", htt_stats_buf->rx_pream, 4836 ATH12K_HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n"); 4837 len += print_array_to_buf(buf, len, "rx_11ax_su_txbf_mcs", 4838 htt_stats_buf->rx_11ax_su_txbf_mcs, 4839 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4840 len += print_array_to_buf(buf, len, "rx_11ax_mu_txbf_mcs", 4841 htt_stats_buf->rx_11ax_mu_txbf_mcs, 4842 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4843 len += print_array_to_buf(buf, len, "rx_legacy_cck_rate", 4844 htt_stats_buf->rx_legacy_cck_rate, 4845 ATH12K_HTT_RX_PDEV_STATS_NUM_LEGACY_CCK_STATS, "\n"); 4846 len += print_array_to_buf(buf, len, "rx_legacy_ofdm_rate", 4847 htt_stats_buf->rx_legacy_ofdm_rate, 4848 ATH12K_HTT_RX_PDEV_STATS_NUM_LEGACY_OFDM_STATS, "\n"); 4849 len += print_array_to_buf(buf, len, "ul_ofdma_rx_mcs", 4850 htt_stats_buf->ul_ofdma_rx_mcs, 4851 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4852 len += print_array_to_buf(buf, len, "ul_ofdma_rx_nss", 4853 htt_stats_buf->ul_ofdma_rx_nss, 4854 ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 4855 len += print_array_to_buf(buf, len, "ul_ofdma_rx_bw", 4856 htt_stats_buf->ul_ofdma_rx_bw, 4857 ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 4858 len += print_array_to_buf(buf, len, "rx_ulofdma_non_data_ppdu", 4859 htt_stats_buf->rx_ulofdma_non_data_ppdu, 4860 ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 4861 len += print_array_to_buf(buf, len, "rx_ulofdma_data_ppdu", 4862 htt_stats_buf->rx_ulofdma_data_ppdu, 4863 ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 4864 len += print_array_to_buf(buf, len, "rx_ulofdma_mpdu_ok", 4865 htt_stats_buf->rx_ulofdma_mpdu_ok, 4866 ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 4867 len += print_array_to_buf(buf, len, "rx_ulofdma_mpdu_fail", 4868 htt_stats_buf->rx_ulofdma_mpdu_fail, 4869 ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 4870 len += print_array_to_buf(buf, len, "rx_ulofdma_non_data_nusers", 4871 htt_stats_buf->rx_ulofdma_non_data_nusers, 4872 ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 4873 len += print_array_to_buf(buf, len, "rx_ulofdma_data_nusers", 4874 htt_stats_buf->rx_ulofdma_data_nusers, 4875 ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 4876 len += print_array_to_buf(buf, len, "rx_11ax_dl_ofdma_mcs", 4877 htt_stats_buf->rx_11ax_dl_ofdma_mcs, 4878 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 4879 len += print_array_to_buf(buf, len, "rx_11ax_dl_ofdma_ru", 4880 htt_stats_buf->rx_11ax_dl_ofdma_ru, 4881 ATH12K_HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS, "\n"); 4882 len += print_array_to_buf(buf, len, "rx_ulmumimo_non_data_ppdu", 4883 htt_stats_buf->rx_ulmumimo_non_data_ppdu, 4884 ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n"); 4885 len += print_array_to_buf(buf, len, "rx_ulmumimo_data_ppdu", 4886 htt_stats_buf->rx_ulmumimo_data_ppdu, 4887 ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n"); 4888 len += print_array_to_buf(buf, len, "rx_ulmumimo_mpdu_ok", 4889 htt_stats_buf->rx_ulmumimo_mpdu_ok, 4890 ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n"); 4891 len += print_array_to_buf(buf, len, "rx_ulmumimo_mpdu_fail", 4892 htt_stats_buf->rx_ulmumimo_mpdu_fail, 4893 ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n"); 4894 4895 len += print_array_to_buf(buf, len, "rx_mcs", 4896 htt_stats_buf->rx_mcs, 4897 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, NULL); 4898 for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++) 4899 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 4900 j + ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, 4901 le32_to_cpu(htt_stats_buf->rx_mcs_ext[j])); 4902 len += scnprintf(buf + len, buf_len - len, "\n"); 4903 4904 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 4905 len += scnprintf(buf + len, buf_len - len, 4906 "pilot_evm_db[%u] =", j); 4907 len += print_array_to_buf(buf, len, NULL, 4908 htt_stats_buf->rx_pil_evm_db[j], 4909 ATH12K_HTT_RX_PDEV_STATS_RXEVM_MAX_PILOTS_NSS, 4910 "\n"); 4911 } 4912 4913 len += scnprintf(buf + len, buf_len - len, "pilot_evm_db_mean ="); 4914 for (i = 0; i < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++) 4915 len += scnprintf(buf + len, 4916 buf_len - len, 4917 " %u:%d,", i, 4918 le32_to_cpu(htt_stats_buf->rx_pilot_evm_db_mean[i])); 4919 len--; 4920 len += scnprintf(buf + len, buf_len - len, "\n"); 4921 4922 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 4923 len += scnprintf(buf + len, buf_len - len, 4924 "rssi_chain_in_db[%u] = ", j); 4925 for (i = 0; i < ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++) 4926 len += scnprintf(buf + len, 4927 buf_len - len, 4928 " %u: %d,", i, 4929 htt_stats_buf->rssi_chain_in_db[j][i]); 4930 len--; 4931 len += scnprintf(buf + len, buf_len - len, "\n"); 4932 } 4933 4934 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 4935 len += scnprintf(buf + len, buf_len - len, 4936 "rx_gi[%u] = ", j); 4937 len += print_array_to_buf(buf, len, NULL, 4938 htt_stats_buf->rx_gi[j], 4939 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, 4940 "\n"); 4941 } 4942 4943 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 4944 len += scnprintf(buf + len, buf_len - len, 4945 "ul_ofdma_rx_gi[%u] = ", j); 4946 len += print_array_to_buf(buf, len, NULL, 4947 htt_stats_buf->ul_ofdma_rx_gi[j], 4948 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, 4949 "\n"); 4950 } 4951 4952 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 4953 len += scnprintf(buf + len, buf_len - len, 4954 "rx_ul_fd_rssi: nss[%u] = ", j); 4955 for (i = 0; i < ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER; i++) 4956 len += scnprintf(buf + len, 4957 buf_len - len, 4958 " %u:%d,", 4959 i, htt_stats_buf->rx_ul_fd_rssi[j][i]); 4960 len--; 4961 len += scnprintf(buf + len, buf_len - len, "\n"); 4962 } 4963 4964 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 4965 len += scnprintf(buf + len, buf_len - len, 4966 "rx_per_chain_rssi_in_dbm[%u] =", j); 4967 for (i = 0; i < ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++) 4968 len += scnprintf(buf + len, 4969 buf_len - len, 4970 " %u:%d,", 4971 i, 4972 htt_stats_buf->rx_per_chain_rssi_in_dbm[j][i]); 4973 len--; 4974 len += scnprintf(buf + len, buf_len - len, "\n"); 4975 } 4976 4977 stats_req->buf_len = len; 4978} 4979 4980static inline void 4981ath12k_htt_print_rx_pdev_rate_ext_stats_tlv(const void *tag_buf, u16 tag_len, 4982 struct debug_htt_stats_req *stats_req) 4983{ 4984 const struct ath12k_htt_rx_pdev_rate_ext_stats_tlv *htt_stats_buf = tag_buf; 4985 u8 *buf = stats_req->buf; 4986 u32 len = stats_req->buf_len; 4987 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 4988 u8 j; 4989 4990 if (tag_len < sizeof(*htt_stats_buf)) 4991 return; 4992 4993 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_EXT_STATS_TLV:\n"); 4994 len += scnprintf(buf + len, buf_len - len, "rssi_mgmt_in_dbm = %d\n", 4995 le32_to_cpu(htt_stats_buf->rssi_mgmt_in_dbm)); 4996 4997 len += print_array_to_buf(buf, len, "rx_stbc_ext", 4998 htt_stats_buf->rx_stbc_ext, 4999 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n"); 5000 len += print_array_to_buf(buf, len, "ul_ofdma_rx_mcs_ext", 5001 htt_stats_buf->ul_ofdma_rx_mcs_ext, 5002 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n"); 5003 len += print_array_to_buf(buf, len, "rx_11ax_su_txbf_mcs_ext", 5004 htt_stats_buf->rx_11ax_su_txbf_mcs_ext, 5005 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n"); 5006 len += print_array_to_buf(buf, len, "rx_11ax_mu_txbf_mcs_ext", 5007 htt_stats_buf->rx_11ax_mu_txbf_mcs_ext, 5008 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n"); 5009 len += print_array_to_buf(buf, len, "rx_11ax_dl_ofdma_mcs_ext", 5010 htt_stats_buf->rx_11ax_dl_ofdma_mcs_ext, 5011 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n"); 5012 len += print_array_to_buf(buf, len, "rx_bw_ext", 5013 htt_stats_buf->rx_bw_ext, 5014 ATH12K_HTT_RX_PDEV_STATS_NUM_BW_EXT2_COUNTERS, "\n"); 5015 len += print_array_to_buf(buf, len, "rx_su_punctured_mode", 5016 htt_stats_buf->rx_su_punctured_mode, 5017 ATH12K_HTT_RX_PDEV_STATS_NUM_PUNCTURED_MODE_COUNTERS, 5018 "\n"); 5019 5020 len += print_array_to_buf(buf, len, "rx_mcs_ext", 5021 htt_stats_buf->rx_mcs_ext, 5022 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, 5023 NULL); 5024 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_EXTRA2_MCS_COUNTERS; j++) 5025 len += scnprintf(buf + len, buf_len - len, ", %u:%u", 5026 j + ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, 5027 le32_to_cpu(htt_stats_buf->rx_mcs_ext_2[j])); 5028 len += scnprintf(buf + len, buf_len - len, "\n"); 5029 5030 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 5031 len += scnprintf(buf + len, buf_len - len, 5032 "rx_gi_ext[%u] = ", j); 5033 len += print_array_to_buf(buf, len, NULL, 5034 htt_stats_buf->rx_gi_ext[j], 5035 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, 5036 "\n"); 5037 } 5038 5039 for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 5040 len += scnprintf(buf + len, buf_len - len, 5041 "ul_ofdma_rx_gi_ext[%u] = ", j); 5042 len += print_array_to_buf(buf, len, NULL, 5043 htt_stats_buf->ul_ofdma_rx_gi_ext[j], 5044 ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, 5045 "\n"); 5046 } 5047 5048 stats_req->buf_len = len; 5049} 5050 5051static void 5052ath12k_htt_print_pdev_tdma_stats_tlv(const void *tag_buf, u16 tag_len, 5053 struct debug_htt_stats_req *stats_req) 5054{ 5055 const struct ath12k_htt_pdev_tdma_stats_tlv *htt_stats_buf = tag_buf; 5056 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5057 u32 len = stats_req->buf_len; 5058 u8 *buf = stats_req->buf; 5059 u32 mac_id_word; 5060 5061 if (tag_len < sizeof(*htt_stats_buf)) 5062 return; 5063 5064 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 5065 5066 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_TDMA_STATS_TLV:\n"); 5067 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 5068 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 5069 len += scnprintf(buf + len, buf_len - len, "num_tdma_active_schedules = %u\n", 5070 le32_to_cpu(htt_stats_buf->num_tdma_active_schedules)); 5071 len += scnprintf(buf + len, buf_len - len, "num_tdma_reserved_schedules = %u\n", 5072 le32_to_cpu(htt_stats_buf->num_tdma_reserved_schedules)); 5073 len += scnprintf(buf + len, buf_len - len, 5074 "num_tdma_restricted_schedules = %u\n", 5075 le32_to_cpu(htt_stats_buf->num_tdma_restricted_schedules)); 5076 len += scnprintf(buf + len, buf_len - len, 5077 "num_tdma_unconfigured_schedules = %u\n", 5078 le32_to_cpu(htt_stats_buf->num_tdma_unconfigured_schedules)); 5079 len += scnprintf(buf + len, buf_len - len, "num_tdma_slot_switches = %u\n", 5080 le32_to_cpu(htt_stats_buf->num_tdma_slot_switches)); 5081 len += scnprintf(buf + len, buf_len - len, "num_tdma_edca_switches = %u\n\n", 5082 le32_to_cpu(htt_stats_buf->num_tdma_edca_switches)); 5083 5084 stats_req->buf_len = len; 5085} 5086 5087static void 5088ath12k_htt_print_mlo_sched_stats_tlv(const void *tag_buf, u16 tag_len, 5089 struct debug_htt_stats_req *stats_req) 5090{ 5091 const struct ath12k_htt_mlo_sched_stats_tlv *stats_buf = tag_buf; 5092 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5093 u32 len = stats_req->buf_len; 5094 u8 *buf = stats_req->buf; 5095 5096 if (tag_len < sizeof(*stats_buf)) 5097 return; 5098 5099 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_MLO_SCHED_STATS:\n"); 5100 len += scnprintf(buf + len, buf_len - len, "num_sec_link_sched = %u\n", 5101 le32_to_cpu(stats_buf->pref_link_num_sec_link_sched)); 5102 len += scnprintf(buf + len, buf_len - len, "num_pref_link_timeout = %u\n", 5103 le32_to_cpu(stats_buf->pref_link_num_pref_link_timeout)); 5104 len += scnprintf(buf + len, buf_len - len, "num_pref_link_sch_delay_ipc = %u\n", 5105 le32_to_cpu(stats_buf->pref_link_num_pref_link_sch_delay_ipc)); 5106 len += scnprintf(buf + len, buf_len - len, "num_pref_link_timeout_ipc = %u\n\n", 5107 le32_to_cpu(stats_buf->pref_link_num_pref_link_timeout_ipc)); 5108 5109 stats_req->buf_len = len; 5110} 5111 5112static void 5113ath12k_htt_print_mlo_ipc_stats_tlv(const void *tag_buf, u16 tag_len, 5114 struct debug_htt_stats_req *stats_req) 5115{ 5116 const struct ath12k_htt_pdev_mlo_ipc_stats_tlv *stats_buf = tag_buf; 5117 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5118 u32 len = stats_req->buf_len; 5119 u8 *buf = stats_req->buf; 5120 u8 i, j; 5121 5122 if (tag_len < sizeof(*stats_buf)) 5123 return; 5124 5125 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_MLO_IPC_STATS:\n"); 5126 for (i = 0; i < ATH12K_HTT_HWMLO_MAX_LINKS; i++) { 5127 len += scnprintf(buf + len, buf_len - len, "src_link: %u\n", i); 5128 for (j = 0; j < ATH12K_HTT_MLO_MAX_IPC_RINGS; j++) 5129 len += scnprintf(buf + len, buf_len - len, 5130 "mlo_ipc_ring_full_cnt[%u]: %u\n", j, 5131 le32_to_cpu(stats_buf->mlo_ipc_ring_cnt[i][j])); 5132 len += scnprintf(buf + len, buf_len - len, "\n"); 5133 } 5134 5135 stats_req->buf_len = len; 5136} 5137 5138static void 5139ath12k_htt_print_pdev_rtt_resp_stats_tlv(const void *tag_buf, u16 tag_len, 5140 struct debug_htt_stats_req *stats_req) 5141{ 5142 const struct ath12k_htt_stats_pdev_rtt_resp_stats_tlv *sbuf = tag_buf; 5143 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5144 u32 len = stats_req->buf_len; 5145 u8 *buf = stats_req->buf; 5146 5147 if (tag_len < sizeof(*sbuf)) 5148 return; 5149 5150 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_RTT_RESP_STATS_TLV:\n"); 5151 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 5152 le32_to_cpu(sbuf->pdev_id)); 5153 len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftm_suc = %u\n", 5154 le32_to_cpu(sbuf->tx_11mc_ftm_suc)); 5155 len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftm_suc_retry = %u\n", 5156 le32_to_cpu(sbuf->tx_11mc_ftm_suc_retry)); 5157 len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftm_fail = %u\n", 5158 le32_to_cpu(sbuf->tx_11mc_ftm_fail)); 5159 len += scnprintf(buf + len, buf_len - len, "rx_11mc_ftmr_cnt = %u\n", 5160 le32_to_cpu(sbuf->rx_11mc_ftmr_cnt)); 5161 len += scnprintf(buf + len, buf_len - len, "rx_11mc_ftmr_dup_cnt = %u\n", 5162 le32_to_cpu(sbuf->rx_11mc_ftmr_dup_cnt)); 5163 len += scnprintf(buf + len, buf_len - len, "rx_11mc_iftmr_cnt = %u\n", 5164 le32_to_cpu(sbuf->rx_11mc_iftmr_cnt)); 5165 len += scnprintf(buf + len, buf_len - len, "rx_11mc_iftmr_dup_cnt = %u\n", 5166 le32_to_cpu(sbuf->rx_11mc_iftmr_dup_cnt)); 5167 len += scnprintf(buf + len, buf_len - len, 5168 "ftmr_drop_11mc_resp_role_not_enabled_cnt = %u\n", 5169 le32_to_cpu(sbuf->ftmr_drop_11mc_resp_role_not_enabled_cnt)); 5170 len += scnprintf(buf + len, buf_len - len, "tx_11az_ftm_successful = %u\n", 5171 le32_to_cpu(sbuf->tx_11az_ftm_successful)); 5172 len += scnprintf(buf + len, buf_len - len, "tx_11az_ftm_failed = %u\n", 5173 le32_to_cpu(sbuf->tx_11az_ftm_failed)); 5174 len += scnprintf(buf + len, buf_len - len, "rx_11az_ftmr_cnt = %u\n", 5175 le32_to_cpu(sbuf->rx_11az_ftmr_cnt)); 5176 len += scnprintf(buf + len, buf_len - len, "rx_11az_ftmr_dup_cnt = %u\n", 5177 le32_to_cpu(sbuf->rx_11az_ftmr_dup_cnt)); 5178 len += scnprintf(buf + len, buf_len - len, "rx_11az_iftmr_dup_cnt = %u\n", 5179 le32_to_cpu(sbuf->rx_11az_iftmr_dup_cnt)); 5180 len += scnprintf(buf + len, buf_len - len, 5181 "initiator_active_responder_rejected_cnt = %u\n", 5182 le32_to_cpu(sbuf->initiator_active_responder_rejected_cnt)); 5183 len += scnprintf(buf + len, buf_len - len, "malformed_ftmr = %u\n", 5184 le32_to_cpu(sbuf->malformed_ftmr)); 5185 len += scnprintf(buf + len, buf_len - len, 5186 "ftmr_drop_ntb_resp_role_not_enabled_cnt = %u\n", 5187 le32_to_cpu(sbuf->ftmr_drop_ntb_resp_role_not_enabled_cnt)); 5188 len += scnprintf(buf + len, buf_len - len, 5189 "ftmr_drop_tb_resp_role_not_enabled_cnt = %u\n", 5190 le32_to_cpu(sbuf->ftmr_drop_tb_resp_role_not_enabled_cnt)); 5191 len += scnprintf(buf + len, buf_len - len, "responder_alloc_cnt = %u\n", 5192 le32_to_cpu(sbuf->responder_alloc_cnt)); 5193 len += scnprintf(buf + len, buf_len - len, "responder_alloc_failure = %u\n", 5194 le32_to_cpu(sbuf->responder_alloc_failure)); 5195 len += scnprintf(buf + len, buf_len - len, "responder_terminate_cnt = %u\n", 5196 le32_to_cpu(sbuf->responder_terminate_cnt)); 5197 len += scnprintf(buf + len, buf_len - len, "active_rsta_open = %u\n", 5198 le32_to_cpu(sbuf->active_rsta_open)); 5199 len += scnprintf(buf + len, buf_len - len, "active_rsta_mac = %u\n", 5200 le32_to_cpu(sbuf->active_rsta_mac)); 5201 len += scnprintf(buf + len, buf_len - len, "active_rsta_mac_phy = %u\n", 5202 le32_to_cpu(sbuf->active_rsta_mac_phy)); 5203 len += scnprintf(buf + len, buf_len - len, "pn_check_failure_cnt = %u\n", 5204 le32_to_cpu(sbuf->pn_check_failure_cnt)); 5205 len += scnprintf(buf + len, buf_len - len, "num_assoc_ranging_peers = %u\n", 5206 le32_to_cpu(sbuf->num_assoc_ranging_peers)); 5207 len += scnprintf(buf + len, buf_len - len, "num_unassoc_ranging_peers = %u\n", 5208 le32_to_cpu(sbuf->num_unassoc_ranging_peers)); 5209 len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_recv_cnt = %u\n", 5210 le32_to_cpu(sbuf->pasn_m1_auth_recv_cnt)); 5211 len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_drop_cnt = %u\n", 5212 le32_to_cpu(sbuf->pasn_m1_auth_drop_cnt)); 5213 len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_recv_cnt = %u\n", 5214 le32_to_cpu(sbuf->pasn_m2_auth_recv_cnt)); 5215 len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_tx_fail_cnt = %u\n", 5216 le32_to_cpu(sbuf->pasn_m2_auth_tx_fail_cnt)); 5217 len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_recv_cnt = %u\n", 5218 le32_to_cpu(sbuf->pasn_m3_auth_recv_cnt)); 5219 len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_drop_cnt = %u\n", 5220 le32_to_cpu(sbuf->pasn_m3_auth_drop_cnt)); 5221 len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_request_cnt = %u\n", 5222 le32_to_cpu(sbuf->pasn_peer_create_request_cnt)); 5223 len += scnprintf(buf + len, buf_len - len, "pasn_peer_created_cnt = %u\n", 5224 le32_to_cpu(sbuf->pasn_peer_created_cnt)); 5225 len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_timeout_cnt = %u\n", 5226 le32_to_cpu(sbuf->pasn_peer_create_timeout_cnt)); 5227 len += scnprintf(buf + len, buf_len - len, 5228 "sec_ranging_not_supported_mfp_not_setup = %u\n", 5229 le32_to_cpu(sbuf->sec_ranging_not_supported_mfp_not_setup)); 5230 len += scnprintf(buf + len, buf_len - len, 5231 "non_sec_ranging_discarded_for_assoc_peer_with_mfpr_set = %u\n", 5232 le32_to_cpu(sbuf->non_sec_ranging_discarded_for_assoc_peer)); 5233 len += scnprintf(buf + len, buf_len - len, 5234 "open_ranging_discarded_with_URNM_MFPR_set_for_pasn_peer = %u\n", 5235 le32_to_cpu(sbuf->open_ranging_discarded_set_for_pasn_peer)); 5236 len += scnprintf(buf + len, buf_len - len, 5237 "unassoc_non_pasn_ranging_not_supported_with_URNM_MFPR = %u\n", 5238 le32_to_cpu(sbuf->unassoc_non_pasn_ranging_not_supported)); 5239 len += scnprintf(buf + len, buf_len - len, "invalid_ftm_request_params = %u\n", 5240 le32_to_cpu(sbuf->invalid_ftm_request_params)); 5241 len += scnprintf(buf + len, buf_len - len, 5242 "requested_bw_format_not_supported = %u\n", 5243 le32_to_cpu(sbuf->requested_bw_format_not_supported)); 5244 len += scnprintf(buf + len, buf_len - len, 5245 "ntb_unsec_unassoc_mode_ranging_peer_alloc_failed = %u\n", 5246 le32_to_cpu(sbuf->ntb_unsec_unassoc_ranging_peer_alloc_failed)); 5247 len += scnprintf(buf + len, buf_len - len, 5248 "tb_unassoc_unsec_mode_pasn_peer_creation_failed = %u\n", 5249 le32_to_cpu(sbuf->tb_unassoc_unsec_pasn_peer_creation_failed)); 5250 len += scnprintf(buf + len, buf_len - len, 5251 "num_ranging_sequences_processed = %u\n", 5252 le32_to_cpu(sbuf->num_ranging_sequences_processed)); 5253 len += scnprintf(buf + len, buf_len - len, "ndp_rx_cnt = %u\n", 5254 le32_to_cpu(sbuf->ndp_rx_cnt)); 5255 len += scnprintf(buf + len, buf_len - len, "num_req_bw_20_MHz = %u\n", 5256 le32_to_cpu(sbuf->num_req_bw_20_mhz)); 5257 len += scnprintf(buf + len, buf_len - len, "num_req_bw_40_MHz = %u\n", 5258 le32_to_cpu(sbuf->num_req_bw_40_mhz)); 5259 len += scnprintf(buf + len, buf_len - len, "num_req_bw_80_MHz = %u\n", 5260 le32_to_cpu(sbuf->num_req_bw_80_mhz)); 5261 len += scnprintf(buf + len, buf_len - len, "num_req_bw_160_MHz = %u\n", 5262 le32_to_cpu(sbuf->num_req_bw_160_mhz)); 5263 len += scnprintf(buf + len, buf_len - len, "ntb_tx_ndp = %u\n", 5264 le32_to_cpu(sbuf->ntb_tx_ndp)); 5265 len += scnprintf(buf + len, buf_len - len, "num_ntb_ranging_NDPAs_recv = %u\n", 5266 le32_to_cpu(sbuf->num_ntb_ranging_ndpas_recv)); 5267 len += scnprintf(buf + len, buf_len - len, "recv_lmr = %u\n", 5268 le32_to_cpu(sbuf->recv_lmr)); 5269 len += scnprintf(buf + len, buf_len - len, "invalid_ftmr_cnt = %u\n", 5270 le32_to_cpu(sbuf->invalid_ftmr_cnt)); 5271 len += scnprintf(buf + len, buf_len - len, "max_time_bw_meas_exp_cnt = %u\n\n", 5272 le32_to_cpu(sbuf->max_time_bw_meas_exp_cnt)); 5273 5274 stats_req->buf_len = len; 5275} 5276 5277static void 5278ath12k_htt_print_pdev_rtt_init_stats_tlv(const void *tag_buf, u16 tag_len, 5279 struct debug_htt_stats_req *stats_req) 5280{ 5281 const struct ath12k_htt_stats_pdev_rtt_init_stats_tlv *htt_stats_buf = tag_buf; 5282 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5283 u32 len = stats_req->buf_len; 5284 u8 *buf = stats_req->buf, i; 5285 __le32 sch_fail; 5286 5287 if (tag_len < sizeof(*htt_stats_buf)) 5288 return; 5289 5290 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_RTT_INIT_STATS_TLV:\n"); 5291 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 5292 le32_to_cpu(htt_stats_buf->pdev_id)); 5293 len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftmr_cnt = %u\n", 5294 le32_to_cpu(htt_stats_buf->tx_11mc_ftmr_cnt)); 5295 len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftmr_fail = %u\n", 5296 le32_to_cpu(htt_stats_buf->tx_11mc_ftmr_fail)); 5297 len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftmr_suc_retry = %u\n", 5298 le32_to_cpu(htt_stats_buf->tx_11mc_ftmr_suc_retry)); 5299 len += scnprintf(buf + len, buf_len - len, "rx_11mc_ftm_cnt = %u\n", 5300 le32_to_cpu(htt_stats_buf->rx_11mc_ftm_cnt)); 5301 len += scnprintf(buf + len, buf_len - len, "rx_11az_ftm_cnt = %u\n", 5302 le32_to_cpu(htt_stats_buf->rx_11az_ftm_cnt)); 5303 len += scnprintf(buf + len, buf_len - len, "initiator_terminate_cnt = %u\n", 5304 le32_to_cpu(htt_stats_buf->initiator_terminate_cnt)); 5305 len += scnprintf(buf + len, buf_len - len, "tx_meas_req_count = %u\n", 5306 le32_to_cpu(htt_stats_buf->tx_meas_req_count)); 5307 len += scnprintf(buf + len, buf_len - len, "tx_11az_ftmr_start = %u\n", 5308 le32_to_cpu(htt_stats_buf->tx_11az_ftmr_start)); 5309 len += scnprintf(buf + len, buf_len - len, "tx_11az_ftmr_stop = %u\n", 5310 le32_to_cpu(htt_stats_buf->tx_11az_ftmr_stop)); 5311 len += scnprintf(buf + len, buf_len - len, "tx_11az_ftmr_fail = %u\n", 5312 le32_to_cpu(htt_stats_buf->tx_11az_ftmr_fail)); 5313 len += scnprintf(buf + len, buf_len - len, 5314 "ftmr_tx_failed_null_11az_peer = %u\n", 5315 le32_to_cpu(htt_stats_buf->ftmr_tx_failed_null_11az_peer)); 5316 len += scnprintf(buf + len, buf_len - len, "ftmr_retry_timeout = %u\n", 5317 le32_to_cpu(htt_stats_buf->ftmr_retry_timeout)); 5318 len += scnprintf(buf + len, buf_len - len, "ftm_parse_failure = %u\n", 5319 le32_to_cpu(htt_stats_buf->ftm_parse_failure)); 5320 len += scnprintf(buf + len, buf_len - len, "incompatible_ftm_params = %u\n", 5321 le32_to_cpu(htt_stats_buf->incompatible_ftm_params)); 5322 len += scnprintf(buf + len, buf_len - len, 5323 "ranging_negotiation_successful_cnt = %u\n", 5324 le32_to_cpu(htt_stats_buf->ranging_negotiation_successful_cnt)); 5325 len += scnprintf(buf + len, buf_len - len, "active_ista = %u\n", 5326 le32_to_cpu(htt_stats_buf->active_ista)); 5327 len += scnprintf(buf + len, buf_len - len, "init_role_not_enabled = %u\n", 5328 le32_to_cpu(htt_stats_buf->init_role_not_enabled)); 5329 len += scnprintf(buf + len, buf_len - len, "invalid_preamble = %u\n", 5330 le32_to_cpu(htt_stats_buf->invalid_preamble)); 5331 len += scnprintf(buf + len, buf_len - len, "invalid_chan_bw_format = %u\n", 5332 le32_to_cpu(htt_stats_buf->invalid_chan_bw_format)); 5333 len += scnprintf(buf + len, buf_len - len, "mgmt_buff_alloc_fail_cnt = %u\n", 5334 le32_to_cpu(htt_stats_buf->mgmt_buff_alloc_fail_cnt)); 5335 len += scnprintf(buf + len, buf_len - len, "sec_ranging_req_in_open_mode = %u\n", 5336 le32_to_cpu(htt_stats_buf->sec_ranging_req_in_open_mode)); 5337 len += scnprintf(buf + len, buf_len - len, "max_time_bw_meas_exp_cnt = %u\n", 5338 le32_to_cpu(htt_stats_buf->max_time_bw_meas_exp_cnt)); 5339 len += scnprintf(buf + len, buf_len - len, "num_tb_ranging_requests = %u\n", 5340 le32_to_cpu(htt_stats_buf->num_tb_ranging_requests)); 5341 len += scnprintf(buf + len, buf_len - len, "tb_meas_duration_expiry_cnt = %u\n", 5342 le32_to_cpu(htt_stats_buf->tb_meas_duration_expiry_cnt)); 5343 len += scnprintf(buf + len, buf_len - len, "ntbr_triggered_successfully = %u\n", 5344 le32_to_cpu(htt_stats_buf->ntbr_triggered_successfully)); 5345 len += scnprintf(buf + len, buf_len - len, "ntbr_trigger_failed = %u\n", 5346 le32_to_cpu(htt_stats_buf->ntbr_trigger_failed)); 5347 len += scnprintf(buf + len, buf_len - len, "invalid_or_no_vreg_idx = %u\n", 5348 le32_to_cpu(htt_stats_buf->invalid_or_no_vreg_idx)); 5349 len += scnprintf(buf + len, buf_len - len, "set_vreg_params_failed = %u\n", 5350 le32_to_cpu(htt_stats_buf->set_vreg_params_failed)); 5351 len += scnprintf(buf + len, buf_len - len, "sac_mismatch = %u\n", 5352 le32_to_cpu(htt_stats_buf->sac_mismatch)); 5353 len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_recv_cnt = %u\n", 5354 le32_to_cpu(htt_stats_buf->pasn_m1_auth_recv_cnt)); 5355 len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_tx_fail_cnt = %u\n", 5356 le32_to_cpu(htt_stats_buf->pasn_m1_auth_tx_fail_cnt)); 5357 len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_recv_cnt = %u\n", 5358 le32_to_cpu(htt_stats_buf->pasn_m2_auth_recv_cnt)); 5359 len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_drop_cnt = %u\n", 5360 le32_to_cpu(htt_stats_buf->pasn_m2_auth_drop_cnt)); 5361 len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_recv_cnt = %u\n", 5362 le32_to_cpu(htt_stats_buf->pasn_m3_auth_recv_cnt)); 5363 len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_tx_fail_cnt = %u\n", 5364 le32_to_cpu(htt_stats_buf->pasn_m3_auth_tx_fail_cnt)); 5365 len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_request_cnt = %u\n", 5366 le32_to_cpu(htt_stats_buf->pasn_peer_create_request_cnt)); 5367 len += scnprintf(buf + len, buf_len - len, "pasn_peer_created_cnt = %u\n", 5368 le32_to_cpu(htt_stats_buf->pasn_peer_created_cnt)); 5369 len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_timeout_cnt = %u\n", 5370 le32_to_cpu(htt_stats_buf->pasn_peer_create_timeout_cnt)); 5371 len += scnprintf(buf + len, buf_len - len, "ntbr_ndpa_failed = %u\n", 5372 le32_to_cpu(htt_stats_buf->ntbr_ndpa_failed)); 5373 len += scnprintf(buf + len, buf_len - len, "ntbr_sequence_successful = %u\n", 5374 le32_to_cpu(htt_stats_buf->ntbr_sequence_successful)); 5375 len += scnprintf(buf + len, buf_len - len, "ntbr_ndp_failed = %u\n", 5376 le32_to_cpu(htt_stats_buf->ntbr_ndp_failed)); 5377 len += scnprintf(buf + len, buf_len - len, "num_tb_ranging_NDPAs_recv = %u\n", 5378 le32_to_cpu(htt_stats_buf->num_tb_ranging_ndpas_recv)); 5379 len += scnprintf(buf + len, buf_len - len, "ndp_rx_cnt = %u\n", 5380 le32_to_cpu(htt_stats_buf->ndp_rx_cnt)); 5381 len += scnprintf(buf + len, buf_len - len, "num_trigger_frames_received = %u\n", 5382 le32_to_cpu(htt_stats_buf->num_trigger_frames_received)); 5383 for (i = 0; i < (ATH12K_HTT_SCH_CMD_STATUS_CNT - 1); i++) 5384 len += scnprintf(buf + len, buf_len - len, 5385 "num_sch_cmd_status_%d = %u\n", i, 5386 le32_to_cpu(htt_stats_buf->sch_cmd_status_cnts[i])); 5387 sch_fail = htt_stats_buf->sch_cmd_status_cnts[ATH12K_HTT_SCH_CMD_STATUS_CNT - 1]; 5388 len += scnprintf(buf + len, buf_len - len, 5389 "num_sch_cmd_status_other_failure = %u\n", 5390 le32_to_cpu(sch_fail)); 5391 len += scnprintf(buf + len, buf_len - len, "lmr_timeout = %u\n", 5392 le32_to_cpu(htt_stats_buf->lmr_timeout)); 5393 len += scnprintf(buf + len, buf_len - len, "lmr_recv = %u\n\n", 5394 le32_to_cpu(htt_stats_buf->lmr_recv)); 5395 5396 stats_req->buf_len = len; 5397} 5398 5399static void 5400ath12k_htt_print_pdev_rtt_hw_stats_tlv(const void *tag_buf, u16 tag_len, 5401 struct debug_htt_stats_req *stats_req) 5402{ 5403 const struct ath12k_htt_stats_pdev_rtt_hw_stats_tlv *htt_stats_buf = tag_buf; 5404 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5405 u32 len = stats_req->buf_len; 5406 u8 *buf = stats_req->buf; 5407 5408 if (tag_len < sizeof(*htt_stats_buf)) 5409 return; 5410 5411 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_PDEV_RTT_HW_STATS_TAG:\n"); 5412 len += scnprintf(buf + len, buf_len - len, "ista_ranging_ndpa_cnt = %u\n", 5413 le32_to_cpu(htt_stats_buf->ista_ranging_ndpa_cnt)); 5414 len += scnprintf(buf + len, buf_len - len, "ista_ranging_ndp_cnt = %u\n", 5415 le32_to_cpu(htt_stats_buf->ista_ranging_ndp_cnt)); 5416 len += scnprintf(buf + len, buf_len - len, "ista_ranging_i2r_lmr_cnt = %u\n", 5417 le32_to_cpu(htt_stats_buf->ista_ranging_i2r_lmr_cnt)); 5418 len += scnprintf(buf + len, buf_len - len, "rtsa_ranging_resp_cnt = %u\n", 5419 le32_to_cpu(htt_stats_buf->rtsa_ranging_resp_cnt)); 5420 len += scnprintf(buf + len, buf_len - len, "rtsa_ranging_ndp_cnt = %u\n", 5421 le32_to_cpu(htt_stats_buf->rtsa_ranging_ndp_cnt)); 5422 len += scnprintf(buf + len, buf_len - len, "rsta_ranging_lmr_cnt = %u\n", 5423 le32_to_cpu(htt_stats_buf->rsta_ranging_lmr_cnt)); 5424 len += scnprintf(buf + len, buf_len - len, "tb_ranging_cts2s_rcvd_cnt = %u\n", 5425 le32_to_cpu(htt_stats_buf->tb_ranging_cts2s_rcvd_cnt)); 5426 len += scnprintf(buf + len, buf_len - len, "tb_ranging_ndp_rcvd_cnt = %u\n", 5427 le32_to_cpu(htt_stats_buf->tb_ranging_ndp_rcvd_cnt)); 5428 len += scnprintf(buf + len, buf_len - len, "tb_ranging_lmr_rcvd_cnt = %u\n", 5429 le32_to_cpu(htt_stats_buf->tb_ranging_lmr_rcvd_cnt)); 5430 len += scnprintf(buf + len, buf_len - len, 5431 "tb_ranging_tf_poll_resp_sent_cnt = %u\n", 5432 le32_to_cpu(htt_stats_buf->tb_ranging_tf_poll_resp_sent_cnt)); 5433 len += scnprintf(buf + len, buf_len - len, 5434 "tb_ranging_tf_sound_resp_sent_cnt = %u\n", 5435 le32_to_cpu(htt_stats_buf->tb_ranging_tf_sound_resp_sent_cnt)); 5436 len += scnprintf(buf + len, buf_len - len, 5437 "tb_ranging_tf_report_resp_sent_cnt = %u\n\n", 5438 le32_to_cpu(htt_stats_buf->tb_ranging_tf_report_resp_sent_cnt)); 5439 5440 stats_req->buf_len = len; 5441} 5442 5443static void 5444ath12k_htt_print_pdev_rtt_tbr_selfgen_queued_stats_tlv(const void *tag_buf, u16 tag_len, 5445 struct debug_htt_stats_req *req) 5446{ 5447 const struct ath12k_htt_stats_pdev_rtt_tbr_tlv *sbuf = tag_buf; 5448 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5449 u32 len = req->buf_len; 5450 u8 *buf = req->buf; 5451 5452 if (tag_len < sizeof(*sbuf)) 5453 return; 5454 5455 len += scnprintf(buf + len, buf_len - len, 5456 "HTT_STATS_PDEV_RTT_TBR_SELFGEN_QUEUED_STATS_TAG:\n"); 5457 len += scnprintf(buf + len, buf_len - len, "SU poll = %u\n", 5458 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TF_POLL])); 5459 len += scnprintf(buf + len, buf_len - len, "SU sound = %u\n", 5460 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TF_SOUND])); 5461 len += scnprintf(buf + len, buf_len - len, "SU NDPA = %u\n", 5462 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TBR_NDPA])); 5463 len += scnprintf(buf + len, buf_len - len, "SU NDP = %u\n", 5464 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TBR_NDP])); 5465 len += scnprintf(buf + len, buf_len - len, "SU LMR = %u\n", 5466 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TBR_LMR])); 5467 len += scnprintf(buf + len, buf_len - len, "SU TF_REPORT = %u\n", 5468 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TF_RPRT])); 5469 len += scnprintf(buf + len, buf_len - len, "MU poll = %u\n", 5470 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TF_POLL])); 5471 len += scnprintf(buf + len, buf_len - len, "MU sound = %u\n", 5472 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TF_SOUND])); 5473 len += scnprintf(buf + len, buf_len - len, "MU NDPA = %u\n", 5474 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TBR_NDPA])); 5475 len += scnprintf(buf + len, buf_len - len, "MU NDP = %u\n", 5476 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TBR_NDP])); 5477 len += scnprintf(buf + len, buf_len - len, "MU LMR = %u\n", 5478 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TBR_LMR])); 5479 len += scnprintf(buf + len, buf_len - len, "MU TF_REPORT = %u\n\n", 5480 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TF_RPRT])); 5481 5482 req->buf_len = len; 5483} 5484 5485static void 5486ath12k_htt_print_pdev_rtt_tbr_cmd_res_stats_tlv(const void *tag_buf, u16 tag_len, 5487 struct debug_htt_stats_req *stats_req) 5488{ 5489 const struct ath12k_htt_stats_pdev_rtt_tbr_cmd_result_stats_tlv *sbuf = tag_buf; 5490 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5491 u32 len = stats_req->buf_len; 5492 u8 *buf = stats_req->buf, i; 5493 5494 if (tag_len < sizeof(*sbuf)) 5495 return; 5496 5497 len += scnprintf(buf + len, buf_len - len, 5498 "HTT_STATS_PDEV_RTT_TBR_CMD_RESULT_STATS_TAG:\n"); 5499 for (i = 0; i < le32_to_cpu(sbuf->tbr_num_sch_cmd_result_buckets); i++) { 5500 len += scnprintf(buf + len, buf_len - len, "num_sch_cmd_status_%u:\n", i); 5501 len += scnprintf(buf + len, buf_len - len, 5502 "SU frame_SGEN_TF_POLL = %u\n", 5503 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TF_POLL][i])); 5504 len += scnprintf(buf + len, buf_len - len, 5505 "SU frame_SGEN_TF_SOUND = %u\n", 5506 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TF_SOUND][i])); 5507 len += scnprintf(buf + len, buf_len - len, 5508 "SU frame_SGEN_TBR_NDPA = %u\n", 5509 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TBR_NDPA][i])); 5510 len += scnprintf(buf + len, buf_len - len, 5511 "SU frame_SGEN_TBR_NDP = %u\n", 5512 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TBR_NDP][i])); 5513 len += scnprintf(buf + len, buf_len - len, 5514 "SU frame_SGEN_TBR_LMR = %u\n", 5515 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TBR_LMR][i])); 5516 len += scnprintf(buf + len, buf_len - len, 5517 "SU frame_SGEN_TF_REPORT = %u\n", 5518 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TF_RPRT][i])); 5519 len += scnprintf(buf + len, buf_len - len, 5520 "MU frame_SGEN_TF_POLL = %u\n", 5521 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TF_POLL][i])); 5522 len += scnprintf(buf + len, buf_len - len, 5523 "MU frame_SGEN_TF_SOUND = %u\n", 5524 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TF_SOUND][i])); 5525 len += scnprintf(buf + len, buf_len - len, 5526 "MU frame_SGEN_TBR_NDPA = %u\n", 5527 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TBR_NDPA][i])); 5528 len += scnprintf(buf + len, buf_len - len, 5529 "MU frame_SGEN_TBR_NDP = %u\n", 5530 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TBR_NDP][i])); 5531 len += scnprintf(buf + len, buf_len - len, 5532 "MU frame_SGEN_TBR_LMR = %u\n", 5533 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TBR_LMR][i])); 5534 len += scnprintf(buf + len, buf_len - len, 5535 "MU frame_SGEN_TF_REPORT = %u\n\n", 5536 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TF_RPRT][i])); 5537 } 5538 5539 stats_req->buf_len = len; 5540} 5541 5542static int ath12k_dbg_htt_ext_stats_parse(struct ath12k_base *ab, 5543 u16 tag, u16 len, const void *tag_buf, 5544 void *user_data) 5545{ 5546 struct debug_htt_stats_req *stats_req = user_data; 5547 5548 switch (tag) { 5549 case HTT_STATS_TX_PDEV_CMN_TAG: 5550 htt_print_tx_pdev_stats_cmn_tlv(tag_buf, len, stats_req); 5551 break; 5552 case HTT_STATS_TX_PDEV_UNDERRUN_TAG: 5553 htt_print_tx_pdev_stats_urrn_tlv(tag_buf, len, stats_req); 5554 break; 5555 case HTT_STATS_TX_PDEV_SIFS_TAG: 5556 htt_print_tx_pdev_stats_sifs_tlv(tag_buf, len, stats_req); 5557 break; 5558 case HTT_STATS_TX_PDEV_FLUSH_TAG: 5559 htt_print_tx_pdev_stats_flush_tlv(tag_buf, len, stats_req); 5560 break; 5561 case HTT_STATS_TX_PDEV_SIFS_HIST_TAG: 5562 htt_print_tx_pdev_stats_sifs_hist_tlv(tag_buf, len, stats_req); 5563 break; 5564 case HTT_STATS_PDEV_CTRL_PATH_TX_STATS_TAG: 5565 htt_print_pdev_ctrl_path_tx_stats_tlv(tag_buf, len, stats_req); 5566 break; 5567 case HTT_STATS_MU_PPDU_DIST_TAG: 5568 htt_print_tx_pdev_mu_ppdu_dist_stats_tlv(tag_buf, len, stats_req); 5569 break; 5570 case HTT_STATS_TX_SCHED_CMN_TAG: 5571 ath12k_htt_print_stats_tx_sched_cmn_tlv(tag_buf, len, stats_req); 5572 break; 5573 case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG: 5574 ath12k_htt_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf, len, stats_req); 5575 break; 5576 case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG: 5577 ath12k_htt_print_sched_txq_cmd_posted_tlv(tag_buf, len, stats_req); 5578 break; 5579 case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG: 5580 ath12k_htt_print_sched_txq_cmd_reaped_tlv(tag_buf, len, stats_req); 5581 break; 5582 case HTT_STATS_SCHED_TXQ_SCHED_ORDER_SU_TAG: 5583 ath12k_htt_print_sched_txq_sched_order_su_tlv(tag_buf, len, stats_req); 5584 break; 5585 case HTT_STATS_SCHED_TXQ_SCHED_INELIGIBILITY_TAG: 5586 ath12k_htt_print_sched_txq_sched_ineligibility_tlv(tag_buf, len, 5587 stats_req); 5588 break; 5589 case HTT_STATS_SCHED_TXQ_SUPERCYCLE_TRIGGER_TAG: 5590 ath12k_htt_print_sched_txq_supercycle_trigger_tlv(tag_buf, len, 5591 stats_req); 5592 break; 5593 case HTT_STATS_HW_PDEV_ERRS_TAG: 5594 ath12k_htt_print_hw_stats_pdev_errs_tlv(tag_buf, len, stats_req); 5595 break; 5596 case HTT_STATS_HW_INTR_MISC_TAG: 5597 ath12k_htt_print_hw_stats_intr_misc_tlv(tag_buf, len, stats_req); 5598 break; 5599 case HTT_STATS_WHAL_TX_TAG: 5600 ath12k_htt_print_hw_stats_whal_tx_tlv(tag_buf, len, stats_req); 5601 break; 5602 case HTT_STATS_HW_WAR_TAG: 5603 ath12k_htt_print_hw_war_tlv(tag_buf, len, stats_req); 5604 break; 5605 case HTT_STATS_TX_TQM_CMN_TAG: 5606 ath12k_htt_print_tx_tqm_cmn_stats_tlv(tag_buf, len, stats_req); 5607 break; 5608 case HTT_STATS_TX_TQM_ERROR_STATS_TAG: 5609 ath12k_htt_print_tx_tqm_error_stats_tlv(tag_buf, len, stats_req); 5610 break; 5611 case HTT_STATS_TX_TQM_GEN_MPDU_TAG: 5612 ath12k_htt_print_tx_tqm_gen_mpdu_stats_tlv(tag_buf, len, stats_req); 5613 break; 5614 case HTT_STATS_TX_TQM_LIST_MPDU_TAG: 5615 ath12k_htt_print_tx_tqm_list_mpdu_stats_tlv(tag_buf, len, stats_req); 5616 break; 5617 case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG: 5618 ath12k_htt_print_tx_tqm_list_mpdu_cnt_tlv(tag_buf, len, stats_req); 5619 break; 5620 case HTT_STATS_TX_TQM_PDEV_TAG: 5621 ath12k_htt_print_tx_tqm_pdev_stats_tlv(tag_buf, len, stats_req); 5622 break; 5623 case HTT_STATS_TX_DE_CMN_TAG: 5624 ath12k_htt_print_tx_de_cmn_stats_tlv(tag_buf, len, stats_req); 5625 break; 5626 case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG: 5627 ath12k_htt_print_tx_de_eapol_packets_stats_tlv(tag_buf, len, stats_req); 5628 break; 5629 case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG: 5630 ath12k_htt_print_tx_de_classify_stats_tlv(tag_buf, len, stats_req); 5631 break; 5632 case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG: 5633 ath12k_htt_print_tx_de_classify_failed_stats_tlv(tag_buf, len, stats_req); 5634 break; 5635 case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG: 5636 ath12k_htt_print_tx_de_classify_status_stats_tlv(tag_buf, len, stats_req); 5637 break; 5638 case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG: 5639 ath12k_htt_print_tx_de_enqueue_packets_stats_tlv(tag_buf, len, stats_req); 5640 break; 5641 case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG: 5642 ath12k_htt_print_tx_de_enqueue_discard_stats_tlv(tag_buf, len, stats_req); 5643 break; 5644 case HTT_STATS_TX_DE_COMPL_STATS_TAG: 5645 ath12k_htt_print_tx_de_compl_stats_tlv(tag_buf, len, stats_req); 5646 break; 5647 case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG: 5648 ath12k_htt_print_tx_selfgen_cmn_stats_tlv(tag_buf, len, stats_req); 5649 break; 5650 case HTT_STATS_TX_SELFGEN_AC_STATS_TAG: 5651 ath12k_htt_print_tx_selfgen_ac_stats_tlv(tag_buf, len, stats_req); 5652 break; 5653 case HTT_STATS_TX_SELFGEN_AX_STATS_TAG: 5654 ath12k_htt_print_tx_selfgen_ax_stats_tlv(tag_buf, len, stats_req); 5655 break; 5656 case HTT_STATS_TX_SELFGEN_BE_STATS_TAG: 5657 ath12k_htt_print_tx_selfgen_be_stats_tlv(tag_buf, len, stats_req); 5658 break; 5659 case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG: 5660 ath12k_htt_print_tx_selfgen_ac_err_stats_tlv(tag_buf, len, stats_req); 5661 break; 5662 case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG: 5663 ath12k_htt_print_tx_selfgen_ax_err_stats_tlv(tag_buf, len, stats_req); 5664 break; 5665 case HTT_STATS_TX_SELFGEN_BE_ERR_STATS_TAG: 5666 ath12k_htt_print_tx_selfgen_be_err_stats_tlv(tag_buf, len, stats_req); 5667 break; 5668 case HTT_STATS_TX_SELFGEN_AC_SCHED_STATUS_STATS_TAG: 5669 ath12k_htt_print_tx_selfgen_ac_sched_status_stats_tlv(tag_buf, len, 5670 stats_req); 5671 break; 5672 case HTT_STATS_TX_SELFGEN_AX_SCHED_STATUS_STATS_TAG: 5673 ath12k_htt_print_tx_selfgen_ax_sched_status_stats_tlv(tag_buf, len, 5674 stats_req); 5675 break; 5676 case HTT_STATS_TX_SELFGEN_BE_SCHED_STATUS_STATS_TAG: 5677 ath12k_htt_print_tx_selfgen_be_sched_status_stats_tlv(tag_buf, len, 5678 stats_req); 5679 break; 5680 case HTT_STATS_STRING_TAG: 5681 ath12k_htt_print_stats_string_tlv(tag_buf, len, stats_req); 5682 break; 5683 case HTT_STATS_SRING_STATS_TAG: 5684 ath12k_htt_print_sring_stats_tlv(tag_buf, len, stats_req); 5685 break; 5686 case HTT_STATS_SFM_CMN_TAG: 5687 ath12k_htt_print_sfm_cmn_tlv(tag_buf, len, stats_req); 5688 break; 5689 case HTT_STATS_SFM_CLIENT_TAG: 5690 ath12k_htt_print_sfm_client_tlv(tag_buf, len, stats_req); 5691 break; 5692 case HTT_STATS_SFM_CLIENT_USER_TAG: 5693 ath12k_htt_print_sfm_client_user_tlv(tag_buf, len, stats_req); 5694 break; 5695 case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG: 5696 ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, len, stats_req); 5697 break; 5698 case HTT_STATS_TX_PDEV_MUMIMO_GRP_STATS_TAG: 5699 ath12k_htt_print_tx_pdev_mumimo_grp_stats_tlv(tag_buf, len, stats_req); 5700 break; 5701 case HTT_STATS_TX_PDEV_MPDU_STATS_TAG: 5702 ath12k_htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf, len, stats_req); 5703 break; 5704 case HTT_STATS_PDEV_CCA_1SEC_HIST_TAG: 5705 case HTT_STATS_PDEV_CCA_100MSEC_HIST_TAG: 5706 case HTT_STATS_PDEV_CCA_STAT_CUMULATIVE_TAG: 5707 ath12k_htt_print_pdev_cca_stats_hist_tlv(tag_buf, len, stats_req); 5708 break; 5709 case HTT_STATS_PDEV_CCA_COUNTERS_TAG: 5710 ath12k_htt_print_pdev_stats_cca_counters_tlv(tag_buf, len, stats_req); 5711 break; 5712 case HTT_STATS_TX_SOUNDING_STATS_TAG: 5713 ath12k_htt_print_tx_sounding_stats_tlv(tag_buf, len, stats_req); 5714 break; 5715 case HTT_STATS_PDEV_OBSS_PD_TAG: 5716 ath12k_htt_print_pdev_obss_pd_stats_tlv(tag_buf, len, stats_req); 5717 break; 5718 case HTT_STATS_LATENCY_CTX_TAG: 5719 ath12k_htt_print_latency_prof_ctx_tlv(tag_buf, len, stats_req); 5720 break; 5721 case HTT_STATS_LATENCY_CNT_TAG: 5722 ath12k_htt_print_latency_prof_cnt(tag_buf, len, stats_req); 5723 break; 5724 case HTT_STATS_LATENCY_PROF_STATS_TAG: 5725 ath12k_htt_print_latency_prof_stats_tlv(tag_buf, len, stats_req); 5726 break; 5727 case HTT_STATS_RX_PDEV_UL_TRIG_STATS_TAG: 5728 ath12k_htt_print_ul_ofdma_trigger_stats(tag_buf, len, stats_req); 5729 break; 5730 case HTT_STATS_RX_PDEV_UL_OFDMA_USER_STATS_TAG: 5731 ath12k_htt_print_ul_ofdma_user_stats(tag_buf, len, stats_req); 5732 break; 5733 case HTT_STATS_RX_PDEV_UL_MUMIMO_TRIG_STATS_TAG: 5734 ath12k_htt_print_ul_mumimo_trig_stats(tag_buf, len, stats_req); 5735 break; 5736 case HTT_STATS_RX_FSE_STATS_TAG: 5737 ath12k_htt_print_rx_fse_stats_tlv(tag_buf, len, stats_req); 5738 break; 5739 case HTT_STATS_PDEV_TX_RATE_TXBF_STATS_TAG: 5740 ath12k_htt_print_pdev_tx_rate_txbf_stats_tlv(tag_buf, len, stats_req); 5741 break; 5742 case HTT_STATS_TXBF_OFDMA_AX_NDPA_STATS_TAG: 5743 ath12k_htt_print_txbf_ofdma_ax_ndpa_stats_tlv(tag_buf, len, stats_req); 5744 break; 5745 case HTT_STATS_TXBF_OFDMA_AX_NDP_STATS_TAG: 5746 ath12k_htt_print_txbf_ofdma_ax_ndp_stats_tlv(tag_buf, len, stats_req); 5747 break; 5748 case HTT_STATS_TXBF_OFDMA_AX_BRP_STATS_TAG: 5749 ath12k_htt_print_txbf_ofdma_ax_brp_stats_tlv(tag_buf, len, stats_req); 5750 break; 5751 case HTT_STATS_TXBF_OFDMA_AX_STEER_STATS_TAG: 5752 ath12k_htt_print_txbf_ofdma_ax_steer_stats_tlv(tag_buf, len, stats_req); 5753 break; 5754 case HTT_STATS_TXBF_OFDMA_AX_STEER_MPDU_STATS_TAG: 5755 ath12k_htt_print_txbf_ofdma_ax_steer_mpdu_stats_tlv(tag_buf, len, 5756 stats_req); 5757 break; 5758 case HTT_STATS_DLPAGER_STATS_TAG: 5759 ath12k_htt_print_dlpager_stats_tlv(tag_buf, len, stats_req); 5760 break; 5761 case HTT_STATS_PHY_STATS_TAG: 5762 ath12k_htt_print_phy_stats_tlv(tag_buf, len, stats_req); 5763 break; 5764 case HTT_STATS_PHY_COUNTERS_TAG: 5765 ath12k_htt_print_phy_counters_tlv(tag_buf, len, stats_req); 5766 break; 5767 case HTT_STATS_PHY_RESET_STATS_TAG: 5768 ath12k_htt_print_phy_reset_stats_tlv(tag_buf, len, stats_req); 5769 break; 5770 case HTT_STATS_PHY_RESET_COUNTERS_TAG: 5771 ath12k_htt_print_phy_reset_counters_tlv(tag_buf, len, stats_req); 5772 break; 5773 case HTT_STATS_PHY_TPC_STATS_TAG: 5774 ath12k_htt_print_phy_tpc_stats_tlv(tag_buf, len, stats_req); 5775 break; 5776 case HTT_STATS_SOC_TXRX_STATS_COMMON_TAG: 5777 ath12k_htt_print_soc_txrx_stats_common_tlv(tag_buf, len, stats_req); 5778 break; 5779 case HTT_STATS_PER_RATE_STATS_TAG: 5780 ath12k_htt_print_tx_per_rate_stats_tlv(tag_buf, len, stats_req); 5781 break; 5782 case HTT_STATS_AST_ENTRY_TAG: 5783 ath12k_htt_print_ast_entry_tlv(tag_buf, len, stats_req); 5784 break; 5785 case HTT_STATS_PDEV_PUNCTURE_STATS_TAG: 5786 ath12k_htt_print_puncture_stats_tlv(tag_buf, len, stats_req); 5787 break; 5788 case HTT_STATS_DMAC_RESET_STATS_TAG: 5789 ath12k_htt_print_dmac_reset_stats_tlv(tag_buf, len, stats_req); 5790 break; 5791 case HTT_STATS_PDEV_SCHED_ALGO_OFDMA_STATS_TAG: 5792 ath12k_htt_print_pdev_sched_algo_ofdma_stats_tlv(tag_buf, len, stats_req); 5793 break; 5794 case HTT_STATS_TX_PDEV_RATE_STATS_BE_OFDMA_TAG: 5795 ath12k_htt_print_tx_pdev_rate_stats_be_ofdma_tlv(tag_buf, len, stats_req); 5796 break; 5797 case HTT_STATS_PDEV_MBSSID_CTRL_FRAME_STATS_TAG: 5798 ath12k_htt_print_pdev_mbssid_ctrl_frame_stats_tlv(tag_buf, len, 5799 stats_req); 5800 break; 5801 case HTT_STATS_TX_PDEV_RATE_STATS_TAG: 5802 ath12k_htt_print_tx_pdev_rate_stats_tlv(tag_buf, len, stats_req); 5803 break; 5804 case HTT_STATS_TX_PDEV_HISTOGRAM_STATS_TAG: 5805 ath12k_htt_print_histogram_stats_tlv(tag_buf, len, stats_req); 5806 break; 5807 case HTT_STATS_RX_PDEV_RATE_STATS_TAG: 5808 ath12k_htt_print_rx_pdev_rate_stats_tlv(tag_buf, len, stats_req); 5809 break; 5810 case HTT_STATS_RX_PDEV_RATE_EXT_STATS_TAG: 5811 ath12k_htt_print_rx_pdev_rate_ext_stats_tlv(tag_buf, len, stats_req); 5812 break; 5813 case HTT_STATS_PDEV_TDMA_TAG: 5814 ath12k_htt_print_pdev_tdma_stats_tlv(tag_buf, len, stats_req); 5815 break; 5816 case HTT_STATS_MLO_SCHED_STATS_TAG: 5817 ath12k_htt_print_mlo_sched_stats_tlv(tag_buf, len, stats_req); 5818 break; 5819 case HTT_STATS_PDEV_MLO_IPC_STATS_TAG: 5820 ath12k_htt_print_mlo_ipc_stats_tlv(tag_buf, len, stats_req); 5821 break; 5822 case HTT_STATS_PDEV_RTT_RESP_STATS_TAG: 5823 ath12k_htt_print_pdev_rtt_resp_stats_tlv(tag_buf, len, stats_req); 5824 break; 5825 case HTT_STATS_PDEV_RTT_INIT_STATS_TAG: 5826 ath12k_htt_print_pdev_rtt_init_stats_tlv(tag_buf, len, stats_req); 5827 break; 5828 case HTT_STATS_PDEV_RTT_HW_STATS_TAG: 5829 ath12k_htt_print_pdev_rtt_hw_stats_tlv(tag_buf, len, stats_req); 5830 break; 5831 case HTT_STATS_PDEV_RTT_TBR_SELFGEN_QUEUED_STATS_TAG: 5832 ath12k_htt_print_pdev_rtt_tbr_selfgen_queued_stats_tlv(tag_buf, len, 5833 stats_req); 5834 break; 5835 case HTT_STATS_PDEV_RTT_TBR_CMD_RESULT_STATS_TAG: 5836 ath12k_htt_print_pdev_rtt_tbr_cmd_res_stats_tlv(tag_buf, len, stats_req); 5837 break; 5838 default: 5839 break; 5840 } 5841 5842 return 0; 5843} 5844 5845void ath12k_debugfs_htt_ext_stats_handler(struct ath12k_base *ab, 5846 struct sk_buff *skb) 5847{ 5848 struct ath12k_htt_extd_stats_msg *msg; 5849 struct debug_htt_stats_req *stats_req; 5850 struct ath12k *ar; 5851 u32 len, pdev_id, stats_info; 5852 u64 cookie; 5853 int ret; 5854 bool send_completion = false; 5855 5856 msg = (struct ath12k_htt_extd_stats_msg *)skb->data; 5857 cookie = le64_to_cpu(msg->cookie); 5858 5859 if (u64_get_bits(cookie, ATH12K_HTT_STATS_COOKIE_MSB) != 5860 ATH12K_HTT_STATS_MAGIC_VALUE) { 5861 ath12k_warn(ab, "received invalid htt ext stats event\n"); 5862 return; 5863 } 5864 5865 pdev_id = u64_get_bits(cookie, ATH12K_HTT_STATS_COOKIE_LSB); 5866 rcu_read_lock(); 5867 ar = ath12k_mac_get_ar_by_pdev_id(ab, pdev_id); 5868 if (!ar) { 5869 ath12k_warn(ab, "failed to get ar for pdev_id %d\n", pdev_id); 5870 goto exit; 5871 } 5872 5873 stats_req = ar->debug.htt_stats.stats_req; 5874 if (!stats_req) 5875 goto exit; 5876 5877 spin_lock_bh(&ar->data_lock); 5878 5879 stats_info = le32_to_cpu(msg->info1); 5880 stats_req->done = u32_get_bits(stats_info, ATH12K_HTT_T2H_EXT_STATS_INFO1_DONE); 5881 if (stats_req->done) 5882 send_completion = true; 5883 5884 spin_unlock_bh(&ar->data_lock); 5885 5886 len = u32_get_bits(stats_info, ATH12K_HTT_T2H_EXT_STATS_INFO1_LENGTH); 5887 if (len > skb->len) { 5888 ath12k_warn(ab, "invalid length %d for HTT stats", len); 5889 goto exit; 5890 } 5891 5892 ret = ath12k_dp_htt_tlv_iter(ab, msg->data, len, 5893 ath12k_dbg_htt_ext_stats_parse, 5894 stats_req); 5895 if (ret) 5896 ath12k_warn(ab, "Failed to parse tlv %d\n", ret); 5897 5898 if (send_completion) 5899 complete(&stats_req->htt_stats_rcvd); 5900exit: 5901 rcu_read_unlock(); 5902} 5903 5904static ssize_t ath12k_read_htt_stats_type(struct file *file, 5905 char __user *user_buf, 5906 size_t count, loff_t *ppos) 5907{ 5908 struct ath12k *ar = file->private_data; 5909 enum ath12k_dbg_htt_ext_stats_type type; 5910 char buf[32]; 5911 size_t len; 5912 5913 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 5914 type = ar->debug.htt_stats.type; 5915 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 5916 5917 len = scnprintf(buf, sizeof(buf), "%u\n", type); 5918 5919 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 5920} 5921 5922static ssize_t ath12k_write_htt_stats_type(struct file *file, 5923 const char __user *user_buf, 5924 size_t count, loff_t *ppos) 5925{ 5926 struct ath12k *ar = file->private_data; 5927 enum ath12k_dbg_htt_ext_stats_type type; 5928 unsigned int cfg_param[4] = {}; 5929 const int size = 32; 5930 int num_args; 5931 5932 if (count > size) 5933 return -EINVAL; 5934 5935 char *buf __free(kfree) = kzalloc(size, GFP_KERNEL); 5936 if (!buf) 5937 return -ENOMEM; 5938 5939 if (copy_from_user(buf, user_buf, count)) 5940 return -EFAULT; 5941 5942 num_args = sscanf(buf, "%u %u %u %u %u\n", &type, &cfg_param[0], 5943 &cfg_param[1], &cfg_param[2], &cfg_param[3]); 5944 if (!num_args || num_args > 5) 5945 return -EINVAL; 5946 5947 if (type == ATH12K_DBG_HTT_EXT_STATS_RESET || 5948 type >= ATH12K_DBG_HTT_NUM_EXT_STATS) 5949 return -EINVAL; 5950 5951 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 5952 5953 ar->debug.htt_stats.type = type; 5954 ar->debug.htt_stats.cfg_param[0] = cfg_param[0]; 5955 ar->debug.htt_stats.cfg_param[1] = cfg_param[1]; 5956 ar->debug.htt_stats.cfg_param[2] = cfg_param[2]; 5957 ar->debug.htt_stats.cfg_param[3] = cfg_param[3]; 5958 5959 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 5960 5961 return count; 5962} 5963 5964static const struct file_operations fops_htt_stats_type = { 5965 .read = ath12k_read_htt_stats_type, 5966 .write = ath12k_write_htt_stats_type, 5967 .open = simple_open, 5968 .owner = THIS_MODULE, 5969 .llseek = default_llseek, 5970}; 5971 5972static int ath12k_debugfs_htt_stats_req(struct ath12k *ar) 5973{ 5974 struct debug_htt_stats_req *stats_req = ar->debug.htt_stats.stats_req; 5975 enum ath12k_dbg_htt_ext_stats_type type = stats_req->type; 5976 u64 cookie; 5977 int ret, pdev_id; 5978 struct htt_ext_stats_cfg_params cfg_params = {}; 5979 5980 lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); 5981 5982 init_completion(&stats_req->htt_stats_rcvd); 5983 5984 pdev_id = ath12k_mac_get_target_pdev_id(ar); 5985 stats_req->done = false; 5986 stats_req->pdev_id = pdev_id; 5987 5988 cookie = u64_encode_bits(ATH12K_HTT_STATS_MAGIC_VALUE, 5989 ATH12K_HTT_STATS_COOKIE_MSB); 5990 cookie |= u64_encode_bits(pdev_id, ATH12K_HTT_STATS_COOKIE_LSB); 5991 5992 if (stats_req->override_cfg_param) { 5993 cfg_params.cfg0 = stats_req->cfg_param[0]; 5994 cfg_params.cfg1 = stats_req->cfg_param[1]; 5995 cfg_params.cfg2 = stats_req->cfg_param[2]; 5996 cfg_params.cfg3 = stats_req->cfg_param[3]; 5997 } 5998 5999 ret = ath12k_dp_tx_htt_h2t_ext_stats_req(ar, type, &cfg_params, cookie); 6000 if (ret) { 6001 ath12k_warn(ar->ab, "failed to send htt stats request: %d\n", ret); 6002 return ret; 6003 } 6004 if (!wait_for_completion_timeout(&stats_req->htt_stats_rcvd, 3 * HZ)) { 6005 spin_lock_bh(&ar->data_lock); 6006 if (!stats_req->done) { 6007 stats_req->done = true; 6008 spin_unlock_bh(&ar->data_lock); 6009 ath12k_warn(ar->ab, "stats request timed out\n"); 6010 return -ETIMEDOUT; 6011 } 6012 spin_unlock_bh(&ar->data_lock); 6013 } 6014 6015 return 0; 6016} 6017 6018static int ath12k_open_htt_stats(struct inode *inode, 6019 struct file *file) 6020{ 6021 struct ath12k *ar = inode->i_private; 6022 struct debug_htt_stats_req *stats_req; 6023 enum ath12k_dbg_htt_ext_stats_type type = ar->debug.htt_stats.type; 6024 struct ath12k_hw *ah = ath12k_ar_to_ah(ar); 6025 int ret; 6026 6027 if (type == ATH12K_DBG_HTT_EXT_STATS_RESET) 6028 return -EPERM; 6029 6030 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 6031 6032 if (ah->state != ATH12K_HW_STATE_ON) { 6033 ret = -ENETDOWN; 6034 goto err_unlock; 6035 } 6036 6037 if (ar->debug.htt_stats.stats_req) { 6038 ret = -EAGAIN; 6039 goto err_unlock; 6040 } 6041 6042 stats_req = kzalloc(sizeof(*stats_req) + ATH12K_HTT_STATS_BUF_SIZE, GFP_KERNEL); 6043 if (!stats_req) { 6044 ret = -ENOMEM; 6045 goto err_unlock; 6046 } 6047 6048 ar->debug.htt_stats.stats_req = stats_req; 6049 stats_req->type = type; 6050 stats_req->cfg_param[0] = ar->debug.htt_stats.cfg_param[0]; 6051 stats_req->cfg_param[1] = ar->debug.htt_stats.cfg_param[1]; 6052 stats_req->cfg_param[2] = ar->debug.htt_stats.cfg_param[2]; 6053 stats_req->cfg_param[3] = ar->debug.htt_stats.cfg_param[3]; 6054 stats_req->override_cfg_param = !!stats_req->cfg_param[0] || 6055 !!stats_req->cfg_param[1] || 6056 !!stats_req->cfg_param[2] || 6057 !!stats_req->cfg_param[3]; 6058 6059 ret = ath12k_debugfs_htt_stats_req(ar); 6060 if (ret < 0) 6061 goto out; 6062 6063 file->private_data = stats_req; 6064 6065 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 6066 6067 return 0; 6068out: 6069 kfree(stats_req); 6070 ar->debug.htt_stats.stats_req = NULL; 6071err_unlock: 6072 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 6073 6074 return ret; 6075} 6076 6077static int ath12k_release_htt_stats(struct inode *inode, 6078 struct file *file) 6079{ 6080 struct ath12k *ar = inode->i_private; 6081 6082 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 6083 kfree(file->private_data); 6084 ar->debug.htt_stats.stats_req = NULL; 6085 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 6086 6087 return 0; 6088} 6089 6090static ssize_t ath12k_read_htt_stats(struct file *file, 6091 char __user *user_buf, 6092 size_t count, loff_t *ppos) 6093{ 6094 struct debug_htt_stats_req *stats_req = file->private_data; 6095 char *buf; 6096 u32 length; 6097 6098 buf = stats_req->buf; 6099 length = min_t(u32, stats_req->buf_len, ATH12K_HTT_STATS_BUF_SIZE); 6100 return simple_read_from_buffer(user_buf, count, ppos, buf, length); 6101} 6102 6103static const struct file_operations fops_dump_htt_stats = { 6104 .open = ath12k_open_htt_stats, 6105 .release = ath12k_release_htt_stats, 6106 .read = ath12k_read_htt_stats, 6107 .owner = THIS_MODULE, 6108 .llseek = default_llseek, 6109}; 6110 6111static ssize_t ath12k_write_htt_stats_reset(struct file *file, 6112 const char __user *user_buf, 6113 size_t count, loff_t *ppos) 6114{ 6115 struct ath12k *ar = file->private_data; 6116 enum ath12k_dbg_htt_ext_stats_type type; 6117 struct htt_ext_stats_cfg_params cfg_params = {}; 6118 u8 param_pos; 6119 int ret; 6120 6121 ret = kstrtou32_from_user(user_buf, count, 0, &type); 6122 if (ret) 6123 return ret; 6124 6125 if (type >= ATH12K_DBG_HTT_NUM_EXT_STATS || 6126 type == ATH12K_DBG_HTT_EXT_STATS_RESET) 6127 return -E2BIG; 6128 6129 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 6130 cfg_params.cfg0 = HTT_STAT_DEFAULT_RESET_START_OFFSET; 6131 param_pos = (type >> 5) + 1; 6132 6133 switch (param_pos) { 6134 case ATH12K_HTT_STATS_RESET_PARAM_CFG_32_BYTES: 6135 cfg_params.cfg1 = 1 << (cfg_params.cfg0 + type); 6136 break; 6137 case ATH12K_HTT_STATS_RESET_PARAM_CFG_64_BYTES: 6138 cfg_params.cfg2 = ATH12K_HTT_STATS_RESET_BITMAP32_BIT(cfg_params.cfg0 + 6139 type); 6140 break; 6141 case ATH12K_HTT_STATS_RESET_PARAM_CFG_128_BYTES: 6142 cfg_params.cfg3 = ATH12K_HTT_STATS_RESET_BITMAP64_BIT(cfg_params.cfg0 + 6143 type); 6144 break; 6145 default: 6146 break; 6147 } 6148 6149 ret = ath12k_dp_tx_htt_h2t_ext_stats_req(ar, 6150 ATH12K_DBG_HTT_EXT_STATS_RESET, 6151 &cfg_params, 6152 0ULL); 6153 if (ret) { 6154 ath12k_warn(ar->ab, "failed to send htt stats request: %d\n", ret); 6155 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 6156 return ret; 6157 } 6158 6159 ar->debug.htt_stats.reset = type; 6160 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 6161 6162 return count; 6163} 6164 6165static const struct file_operations fops_htt_stats_reset = { 6166 .write = ath12k_write_htt_stats_reset, 6167 .open = simple_open, 6168 .owner = THIS_MODULE, 6169 .llseek = default_llseek, 6170}; 6171 6172void ath12k_debugfs_htt_stats_register(struct ath12k *ar) 6173{ 6174 debugfs_create_file("htt_stats_type", 0600, ar->debug.debugfs_pdev, 6175 ar, &fops_htt_stats_type); 6176 debugfs_create_file("htt_stats", 0400, ar->debug.debugfs_pdev, 6177 ar, &fops_dump_htt_stats); 6178 debugfs_create_file("htt_stats_reset", 0200, ar->debug.debugfs_pdev, 6179 ar, &fops_htt_stats_reset); 6180}
~/
Read-only file preview.