FILE
debugfs_htt_stats.c
File preview with syntax highlighting.
linux-6.19.14/drivers/net/wireless/ath/ath11k/debugfs_htt_stats.c
1// SPDX-License-Identifier: BSD-3-Clause-Clear 2/* 3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. 4 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved. 5 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 6 */ 7 8#include <linux/vmalloc.h> 9#include "core.h" 10#include "dp_tx.h" 11#include "dp_rx.h" 12#include "debug.h" 13#include "debugfs_htt_stats.h" 14 15#define HTT_MAX_PRINT_CHAR_PER_ELEM 15 16 17#define HTT_TLV_HDR_LEN 4 18 19#define PRINT_ARRAY_TO_BUF(out, buflen, arr, str, len, newline) \ 20 do { \ 21 int index = 0; u8 i; const char *str_val = str; \ 22 const char *new_line = newline; \ 23 if (str_val) { \ 24 index += scnprintf((out + buflen), \ 25 (ATH11K_HTT_STATS_BUF_SIZE - buflen), \ 26 "%s = ", str_val); \ 27 } \ 28 for (i = 0; i < len; i++) { \ 29 index += scnprintf((out + buflen) + index, \ 30 (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index, \ 31 " %u:%u,", i, arr[i]); \ 32 } \ 33 index += scnprintf((out + buflen) + index, \ 34 (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index, \ 35 "%s", new_line); \ 36 buflen += index; \ 37 } while (0) 38 39static inline void htt_print_stats_string_tlv(const void *tag_buf, 40 u16 tag_len, 41 struct debug_htt_stats_req *stats_req) 42{ 43 const struct htt_stats_string_tlv *htt_stats_buf = tag_buf; 44 u8 *buf = stats_req->buf; 45 u32 len = stats_req->buf_len; 46 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 47 u8 i; 48 49 tag_len = tag_len >> 2; 50 51 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n"); 52 53 len += scnprintf(buf + len, buf_len - len, 54 "data = "); 55 for (i = 0; i < tag_len; i++) { 56 len += scnprintf(buf + len, 57 buf_len - len, 58 "%.*s", 4, (char *)&(htt_stats_buf->data[i])); 59 } 60 /* New lines are added for better display */ 61 len += scnprintf(buf + len, buf_len - len, "\n\n"); 62 63 if (len >= buf_len) 64 buf[buf_len - 1] = 0; 65 else 66 buf[len] = 0; 67 68 stats_req->buf_len = len; 69} 70 71static inline void htt_print_tx_pdev_stats_cmn_tlv(const void *tag_buf, 72 struct debug_htt_stats_req *stats_req) 73{ 74 const struct htt_tx_pdev_stats_cmn_tlv *htt_stats_buf = tag_buf; 75 u8 *buf = stats_req->buf; 76 u32 len = stats_req->buf_len; 77 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 78 79 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n"); 80 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 81 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 82 len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n", 83 htt_stats_buf->hw_queued); 84 len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n", 85 htt_stats_buf->hw_reaped); 86 len += scnprintf(buf + len, buf_len - len, "underrun = %u\n", 87 htt_stats_buf->underrun); 88 len += scnprintf(buf + len, buf_len - len, "hw_paused = %u\n", 89 htt_stats_buf->hw_paused); 90 len += scnprintf(buf + len, buf_len - len, "hw_flush = %u\n", 91 htt_stats_buf->hw_flush); 92 len += scnprintf(buf + len, buf_len - len, "hw_filt = %u\n", 93 htt_stats_buf->hw_filt); 94 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n", 95 htt_stats_buf->tx_abort); 96 len += scnprintf(buf + len, buf_len - len, "mpdu_requeued = %u\n", 97 htt_stats_buf->mpdu_requeued); 98 len += scnprintf(buf + len, buf_len - len, "tx_xretry = %u\n", 99 htt_stats_buf->tx_xretry); 100 len += scnprintf(buf + len, buf_len - len, "data_rc = %u\n", 101 htt_stats_buf->data_rc); 102 len += scnprintf(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n", 103 htt_stats_buf->mpdu_dropped_xretry); 104 len += scnprintf(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n", 105 htt_stats_buf->illgl_rate_phy_err); 106 len += scnprintf(buf + len, buf_len - len, "cont_xretry = %u\n", 107 htt_stats_buf->cont_xretry); 108 len += scnprintf(buf + len, buf_len - len, "tx_timeout = %u\n", 109 htt_stats_buf->tx_timeout); 110 len += scnprintf(buf + len, buf_len - len, "pdev_resets = %u\n", 111 htt_stats_buf->pdev_resets); 112 len += scnprintf(buf + len, buf_len - len, "phy_underrun = %u\n", 113 htt_stats_buf->phy_underrun); 114 len += scnprintf(buf + len, buf_len - len, "txop_ovf = %u\n", 115 htt_stats_buf->txop_ovf); 116 len += scnprintf(buf + len, buf_len - len, "seq_posted = %u\n", 117 htt_stats_buf->seq_posted); 118 len += scnprintf(buf + len, buf_len - len, "seq_failed_queueing = %u\n", 119 htt_stats_buf->seq_failed_queueing); 120 len += scnprintf(buf + len, buf_len - len, "seq_completed = %u\n", 121 htt_stats_buf->seq_completed); 122 len += scnprintf(buf + len, buf_len - len, "seq_restarted = %u\n", 123 htt_stats_buf->seq_restarted); 124 len += scnprintf(buf + len, buf_len - len, "mu_seq_posted = %u\n", 125 htt_stats_buf->mu_seq_posted); 126 len += scnprintf(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n", 127 htt_stats_buf->seq_switch_hw_paused); 128 len += scnprintf(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n", 129 htt_stats_buf->next_seq_posted_dsr); 130 len += scnprintf(buf + len, buf_len - len, "seq_posted_isr = %u\n", 131 htt_stats_buf->seq_posted_isr); 132 len += scnprintf(buf + len, buf_len - len, "seq_ctrl_cached = %u\n", 133 htt_stats_buf->seq_ctrl_cached); 134 len += scnprintf(buf + len, buf_len - len, "mpdu_count_tqm = %u\n", 135 htt_stats_buf->mpdu_count_tqm); 136 len += scnprintf(buf + len, buf_len - len, "msdu_count_tqm = %u\n", 137 htt_stats_buf->msdu_count_tqm); 138 len += scnprintf(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n", 139 htt_stats_buf->mpdu_removed_tqm); 140 len += scnprintf(buf + len, buf_len - len, "msdu_removed_tqm = %u\n", 141 htt_stats_buf->msdu_removed_tqm); 142 len += scnprintf(buf + len, buf_len - len, "mpdus_sw_flush = %u\n", 143 htt_stats_buf->mpdus_sw_flush); 144 len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n", 145 htt_stats_buf->mpdus_hw_filter); 146 len += scnprintf(buf + len, buf_len - len, "mpdus_truncated = %u\n", 147 htt_stats_buf->mpdus_truncated); 148 len += scnprintf(buf + len, buf_len - len, "mpdus_ack_failed = %u\n", 149 htt_stats_buf->mpdus_ack_failed); 150 len += scnprintf(buf + len, buf_len - len, "mpdus_expired = %u\n", 151 htt_stats_buf->mpdus_expired); 152 len += scnprintf(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n", 153 htt_stats_buf->mpdus_seq_hw_retry); 154 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 155 htt_stats_buf->ack_tlv_proc); 156 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n", 157 htt_stats_buf->coex_abort_mpdu_cnt_valid); 158 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n", 159 htt_stats_buf->coex_abort_mpdu_cnt); 160 len += scnprintf(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n", 161 htt_stats_buf->num_total_ppdus_tried_ota); 162 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n", 163 htt_stats_buf->num_data_ppdus_tried_ota); 164 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n", 165 htt_stats_buf->local_ctrl_mgmt_enqued); 166 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n", 167 htt_stats_buf->local_ctrl_mgmt_freed); 168 len += scnprintf(buf + len, buf_len - len, "local_data_enqued = %u\n", 169 htt_stats_buf->local_data_enqued); 170 len += scnprintf(buf + len, buf_len - len, "local_data_freed = %u\n", 171 htt_stats_buf->local_data_freed); 172 len += scnprintf(buf + len, buf_len - len, "mpdu_tried = %u\n", 173 htt_stats_buf->mpdu_tried); 174 len += scnprintf(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n", 175 htt_stats_buf->isr_wait_seq_posted); 176 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n", 177 htt_stats_buf->tx_active_dur_us_low); 178 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n\n", 179 htt_stats_buf->tx_active_dur_us_high); 180 181 if (len >= buf_len) 182 buf[buf_len - 1] = 0; 183 else 184 buf[len] = 0; 185 186 stats_req->buf_len = len; 187} 188 189static inline void 190htt_print_tx_pdev_stats_urrn_tlv_v(const void *tag_buf, 191 u16 tag_len, 192 struct debug_htt_stats_req *stats_req) 193{ 194 const struct htt_tx_pdev_stats_urrn_tlv_v *htt_stats_buf = tag_buf; 195 u8 *buf = stats_req->buf; 196 u32 len = stats_req->buf_len; 197 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 198 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_URRN_STATS); 199 200 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_URRN_TLV_V:\n"); 201 202 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->urrn_stats, "urrn_stats", 203 num_elems, "\n\n"); 204 205 if (len >= buf_len) 206 buf[buf_len - 1] = 0; 207 else 208 buf[len] = 0; 209 210 stats_req->buf_len = len; 211} 212 213static inline void 214htt_print_tx_pdev_stats_flush_tlv_v(const void *tag_buf, 215 u16 tag_len, 216 struct debug_htt_stats_req *stats_req) 217{ 218 const struct htt_tx_pdev_stats_flush_tlv_v *htt_stats_buf = tag_buf; 219 u8 *buf = stats_req->buf; 220 u32 len = stats_req->buf_len; 221 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 222 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_FLUSH_REASON_STATS); 223 224 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_FLUSH_TLV_V:\n"); 225 226 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->flush_errs, "flush_errs", 227 num_elems, "\n\n"); 228 229 if (len >= buf_len) 230 buf[buf_len - 1] = 0; 231 else 232 buf[len] = 0; 233 234 stats_req->buf_len = len; 235} 236 237static inline void 238htt_print_tx_pdev_stats_sifs_tlv_v(const void *tag_buf, 239 u16 tag_len, 240 struct debug_htt_stats_req *stats_req) 241{ 242 const struct htt_tx_pdev_stats_sifs_tlv_v *htt_stats_buf = tag_buf; 243 u8 *buf = stats_req->buf; 244 u32 len = stats_req->buf_len; 245 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 246 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_SIFS_BURST_STATS); 247 248 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_SIFS_TLV_V:\n"); 249 250 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_status, "sifs_status", 251 num_elems, "\n\n"); 252 253 if (len >= buf_len) 254 buf[buf_len - 1] = 0; 255 else 256 buf[len] = 0; 257 258 stats_req->buf_len = len; 259} 260 261static inline void 262htt_print_tx_pdev_stats_phy_err_tlv_v(const void *tag_buf, 263 u16 tag_len, 264 struct debug_htt_stats_req *stats_req) 265{ 266 const struct htt_tx_pdev_stats_phy_err_tlv_v *htt_stats_buf = tag_buf; 267 u8 *buf = stats_req->buf; 268 u32 len = stats_req->buf_len; 269 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 270 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_PHY_ERR_STATS); 271 272 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_PHY_ERR_TLV_V:\n"); 273 274 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_errs, "phy_errs", 275 num_elems, "\n\n"); 276 277 if (len >= buf_len) 278 buf[buf_len - 1] = 0; 279 else 280 buf[len] = 0; 281 282 stats_req->buf_len = len; 283} 284 285static inline void 286htt_print_tx_pdev_stats_sifs_hist_tlv_v(const void *tag_buf, 287 u16 tag_len, 288 struct debug_htt_stats_req *stats_req) 289{ 290 const struct htt_tx_pdev_stats_sifs_hist_tlv_v *htt_stats_buf = tag_buf; 291 u8 *buf = stats_req->buf; 292 u32 len = stats_req->buf_len; 293 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 294 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_SIFS_BURST_HIST_STATS); 295 296 len += scnprintf(buf + len, buf_len - len, 297 "HTT_TX_PDEV_STATS_SIFS_HIST_TLV_V:\n"); 298 299 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_hist_status, 300 "sifs_hist_status", num_elems, "\n\n"); 301 302 if (len >= buf_len) 303 buf[buf_len - 1] = 0; 304 else 305 buf[len] = 0; 306 307 stats_req->buf_len = len; 308} 309 310static inline void 311htt_print_tx_pdev_stats_tx_ppdu_stats_tlv_v(const void *tag_buf, 312 struct debug_htt_stats_req *stats_req) 313{ 314 const struct htt_tx_pdev_stats_tx_ppdu_stats_tlv_v *htt_stats_buf = tag_buf; 315 u8 *buf = stats_req->buf; 316 u32 len = stats_req->buf_len; 317 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 318 319 len += scnprintf(buf + len, buf_len - len, 320 "HTT_TX_PDEV_STATS_TX_PPDU_STATS_TLV_V:\n"); 321 322 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_legacy_su = %u\n", 323 htt_stats_buf->num_data_ppdus_legacy_su); 324 325 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_ac_su = %u\n", 326 htt_stats_buf->num_data_ppdus_ac_su); 327 328 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_ax_su = %u\n", 329 htt_stats_buf->num_data_ppdus_ax_su); 330 331 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_ac_su_txbf = %u\n", 332 htt_stats_buf->num_data_ppdus_ac_su_txbf); 333 334 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_ax_su_txbf = %u\n\n", 335 htt_stats_buf->num_data_ppdus_ax_su_txbf); 336 337 if (len >= buf_len) 338 buf[buf_len - 1] = 0; 339 else 340 buf[len] = 0; 341 342 stats_req->buf_len = len; 343} 344 345static inline void 346htt_print_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v(const void *tag_buf, 347 u16 tag_len, 348 struct debug_htt_stats_req *stats_req) 349{ 350 const struct htt_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v *htt_stats_buf = tag_buf; 351 u8 *buf = stats_req->buf; 352 u32 len = stats_req->buf_len; 353 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 354 u32 num_elements = ((tag_len - sizeof(htt_stats_buf->hist_bin_size)) >> 2); 355 356 len += scnprintf(buf + len, buf_len - len, 357 "HTT_TX_PDEV_STATS_TRIED_MPDU_CNT_HIST_TLV_V:\n"); 358 len += scnprintf(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n", 359 htt_stats_buf->hist_bin_size); 360 361 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist, 362 "tried_mpdu_cnt_hist", num_elements, "\n\n"); 363 364 if (len >= buf_len) 365 buf[buf_len - 1] = 0; 366 else 367 buf[len] = 0; 368 369 stats_req->buf_len = len; 370} 371 372static inline void htt_print_hw_stats_intr_misc_tlv(const void *tag_buf, 373 struct debug_htt_stats_req *stats_req) 374{ 375 const struct htt_hw_stats_intr_misc_tlv *htt_stats_buf = tag_buf; 376 u8 *buf = stats_req->buf; 377 u32 len = stats_req->buf_len; 378 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 379 char hw_intr_name[HTT_STATS_MAX_HW_INTR_NAME_LEN + 1] = {}; 380 381 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_INTR_MISC_TLV:\n"); 382 memcpy(hw_intr_name, &(htt_stats_buf->hw_intr_name[0]), 383 HTT_STATS_MAX_HW_INTR_NAME_LEN); 384 len += scnprintf(buf + len, buf_len - len, "hw_intr_name = %s\n", hw_intr_name); 385 len += scnprintf(buf + len, buf_len - len, "mask = %u\n", 386 htt_stats_buf->mask); 387 len += scnprintf(buf + len, buf_len - len, "count = %u\n\n", 388 htt_stats_buf->count); 389 390 if (len >= buf_len) 391 buf[buf_len - 1] = 0; 392 else 393 buf[len] = 0; 394 395 stats_req->buf_len = len; 396} 397 398static inline void 399htt_print_hw_stats_wd_timeout_tlv(const void *tag_buf, 400 struct debug_htt_stats_req *stats_req) 401{ 402 const struct htt_hw_stats_wd_timeout_tlv *htt_stats_buf = tag_buf; 403 u8 *buf = stats_req->buf; 404 u32 len = stats_req->buf_len; 405 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 406 char hw_module_name[HTT_STATS_MAX_HW_MODULE_NAME_LEN + 1] = {}; 407 408 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WD_TIMEOUT_TLV:\n"); 409 memcpy(hw_module_name, &(htt_stats_buf->hw_module_name[0]), 410 HTT_STATS_MAX_HW_MODULE_NAME_LEN); 411 len += scnprintf(buf + len, buf_len - len, "hw_module_name = %s\n", 412 hw_module_name); 413 len += scnprintf(buf + len, buf_len - len, "count = %u\n", 414 htt_stats_buf->count); 415 416 if (len >= buf_len) 417 buf[buf_len - 1] = 0; 418 else 419 buf[len] = 0; 420 421 stats_req->buf_len = len; 422} 423 424static inline void htt_print_hw_stats_pdev_errs_tlv(const void *tag_buf, 425 struct debug_htt_stats_req *stats_req) 426{ 427 const struct htt_hw_stats_pdev_errs_tlv *htt_stats_buf = tag_buf; 428 u8 *buf = stats_req->buf; 429 u32 len = stats_req->buf_len; 430 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 431 432 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n"); 433 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 434 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 435 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n", 436 htt_stats_buf->tx_abort); 437 len += scnprintf(buf + len, buf_len - len, "tx_abort_fail_count = %u\n", 438 htt_stats_buf->tx_abort_fail_count); 439 len += scnprintf(buf + len, buf_len - len, "rx_abort = %u\n", 440 htt_stats_buf->rx_abort); 441 len += scnprintf(buf + len, buf_len - len, "rx_abort_fail_count = %u\n", 442 htt_stats_buf->rx_abort_fail_count); 443 len += scnprintf(buf + len, buf_len - len, "warm_reset = %u\n", 444 htt_stats_buf->warm_reset); 445 len += scnprintf(buf + len, buf_len - len, "cold_reset = %u\n", 446 htt_stats_buf->cold_reset); 447 len += scnprintf(buf + len, buf_len - len, "tx_flush = %u\n", 448 htt_stats_buf->tx_flush); 449 len += scnprintf(buf + len, buf_len - len, "tx_glb_reset = %u\n", 450 htt_stats_buf->tx_glb_reset); 451 len += scnprintf(buf + len, buf_len - len, "tx_txq_reset = %u\n", 452 htt_stats_buf->tx_txq_reset); 453 len += scnprintf(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n", 454 htt_stats_buf->rx_timeout_reset); 455 456 if (len >= buf_len) 457 buf[buf_len - 1] = 0; 458 else 459 buf[len] = 0; 460 461 stats_req->buf_len = len; 462} 463 464static inline void htt_print_msdu_flow_stats_tlv(const void *tag_buf, 465 struct debug_htt_stats_req *stats_req) 466{ 467 const struct htt_msdu_flow_stats_tlv *htt_stats_buf = tag_buf; 468 u8 *buf = stats_req->buf; 469 u32 len = stats_req->buf_len; 470 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 471 472 len += scnprintf(buf + len, buf_len - len, "HTT_MSDU_FLOW_STATS_TLV:\n"); 473 len += scnprintf(buf + len, buf_len - len, "last_update_timestamp = %u\n", 474 htt_stats_buf->last_update_timestamp); 475 len += scnprintf(buf + len, buf_len - len, "last_add_timestamp = %u\n", 476 htt_stats_buf->last_add_timestamp); 477 len += scnprintf(buf + len, buf_len - len, "last_remove_timestamp = %u\n", 478 htt_stats_buf->last_remove_timestamp); 479 len += scnprintf(buf + len, buf_len - len, "total_processed_msdu_count = %u\n", 480 htt_stats_buf->total_processed_msdu_count); 481 len += scnprintf(buf + len, buf_len - len, "cur_msdu_count_in_flowq = %u\n", 482 htt_stats_buf->cur_msdu_count_in_flowq); 483 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n", 484 htt_stats_buf->sw_peer_id); 485 len += scnprintf(buf + len, buf_len - len, "tx_flow_no = %lu\n", 486 FIELD_GET(HTT_MSDU_FLOW_STATS_TX_FLOW_NO, 487 htt_stats_buf->tx_flow_no__tid_num__drop_rule)); 488 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n", 489 FIELD_GET(HTT_MSDU_FLOW_STATS_TID_NUM, 490 htt_stats_buf->tx_flow_no__tid_num__drop_rule)); 491 len += scnprintf(buf + len, buf_len - len, "drop_rule = %lu\n", 492 FIELD_GET(HTT_MSDU_FLOW_STATS_DROP_RULE, 493 htt_stats_buf->tx_flow_no__tid_num__drop_rule)); 494 len += scnprintf(buf + len, buf_len - len, "last_cycle_enqueue_count = %u\n", 495 htt_stats_buf->last_cycle_enqueue_count); 496 len += scnprintf(buf + len, buf_len - len, "last_cycle_dequeue_count = %u\n", 497 htt_stats_buf->last_cycle_dequeue_count); 498 len += scnprintf(buf + len, buf_len - len, "last_cycle_drop_count = %u\n", 499 htt_stats_buf->last_cycle_drop_count); 500 len += scnprintf(buf + len, buf_len - len, "current_drop_th = %u\n\n", 501 htt_stats_buf->current_drop_th); 502 503 if (len >= buf_len) 504 buf[buf_len - 1] = 0; 505 else 506 buf[len] = 0; 507 508 stats_req->buf_len = len; 509} 510 511static inline void htt_print_tx_tid_stats_tlv(const void *tag_buf, 512 struct debug_htt_stats_req *stats_req) 513{ 514 const struct htt_tx_tid_stats_tlv *htt_stats_buf = tag_buf; 515 u8 *buf = stats_req->buf; 516 u32 len = stats_req->buf_len; 517 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 518 char tid_name[MAX_HTT_TID_NAME + 1] = {}; 519 520 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TID_STATS_TLV:\n"); 521 memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME); 522 len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name); 523 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n", 524 FIELD_GET(HTT_TX_TID_STATS_SW_PEER_ID, 525 htt_stats_buf->sw_peer_id__tid_num)); 526 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n", 527 FIELD_GET(HTT_TX_TID_STATS_TID_NUM, 528 htt_stats_buf->sw_peer_id__tid_num)); 529 len += scnprintf(buf + len, buf_len - len, "num_sched_pending = %lu\n", 530 FIELD_GET(HTT_TX_TID_STATS_NUM_SCHED_PENDING, 531 htt_stats_buf->num_sched_pending__num_ppdu_in_hwq)); 532 len += scnprintf(buf + len, buf_len - len, "num_ppdu_in_hwq = %lu\n", 533 FIELD_GET(HTT_TX_TID_STATS_NUM_PPDU_IN_HWQ, 534 htt_stats_buf->num_sched_pending__num_ppdu_in_hwq)); 535 len += scnprintf(buf + len, buf_len - len, "tid_flags = 0x%x\n", 536 htt_stats_buf->tid_flags); 537 len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n", 538 htt_stats_buf->hw_queued); 539 len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n", 540 htt_stats_buf->hw_reaped); 541 len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n", 542 htt_stats_buf->mpdus_hw_filter); 543 len += scnprintf(buf + len, buf_len - len, "qdepth_bytes = %u\n", 544 htt_stats_buf->qdepth_bytes); 545 len += scnprintf(buf + len, buf_len - len, "qdepth_num_msdu = %u\n", 546 htt_stats_buf->qdepth_num_msdu); 547 len += scnprintf(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n", 548 htt_stats_buf->qdepth_num_mpdu); 549 len += scnprintf(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n", 550 htt_stats_buf->last_scheduled_tsmp); 551 len += scnprintf(buf + len, buf_len - len, "pause_module_id = %u\n", 552 htt_stats_buf->pause_module_id); 553 len += scnprintf(buf + len, buf_len - len, "block_module_id = %u\n\n", 554 htt_stats_buf->block_module_id); 555 556 if (len >= buf_len) 557 buf[buf_len - 1] = 0; 558 else 559 buf[len] = 0; 560 561 stats_req->buf_len = len; 562} 563 564static inline void htt_print_tx_tid_stats_v1_tlv(const void *tag_buf, 565 struct debug_htt_stats_req *stats_req) 566{ 567 const struct htt_tx_tid_stats_v1_tlv *htt_stats_buf = tag_buf; 568 u8 *buf = stats_req->buf; 569 u32 len = stats_req->buf_len; 570 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 571 char tid_name[MAX_HTT_TID_NAME + 1] = {}; 572 573 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TID_STATS_V1_TLV:\n"); 574 memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME); 575 len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name); 576 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n", 577 FIELD_GET(HTT_TX_TID_STATS_V1_SW_PEER_ID, 578 htt_stats_buf->sw_peer_id__tid_num)); 579 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n", 580 FIELD_GET(HTT_TX_TID_STATS_V1_TID_NUM, 581 htt_stats_buf->sw_peer_id__tid_num)); 582 len += scnprintf(buf + len, buf_len - len, "num_sched_pending = %lu\n", 583 FIELD_GET(HTT_TX_TID_STATS_V1_NUM_SCHED_PENDING, 584 htt_stats_buf->num_sched_pending__num_ppdu_in_hwq)); 585 len += scnprintf(buf + len, buf_len - len, "num_ppdu_in_hwq = %lu\n", 586 FIELD_GET(HTT_TX_TID_STATS_V1_NUM_PPDU_IN_HWQ, 587 htt_stats_buf->num_sched_pending__num_ppdu_in_hwq)); 588 len += scnprintf(buf + len, buf_len - len, "tid_flags = 0x%x\n", 589 htt_stats_buf->tid_flags); 590 len += scnprintf(buf + len, buf_len - len, "max_qdepth_bytes = %u\n", 591 htt_stats_buf->max_qdepth_bytes); 592 len += scnprintf(buf + len, buf_len - len, "max_qdepth_n_msdus = %u\n", 593 htt_stats_buf->max_qdepth_n_msdus); 594 len += scnprintf(buf + len, buf_len - len, "rsvd = %u\n", 595 htt_stats_buf->rsvd); 596 len += scnprintf(buf + len, buf_len - len, "qdepth_bytes = %u\n", 597 htt_stats_buf->qdepth_bytes); 598 len += scnprintf(buf + len, buf_len - len, "qdepth_num_msdu = %u\n", 599 htt_stats_buf->qdepth_num_msdu); 600 len += scnprintf(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n", 601 htt_stats_buf->qdepth_num_mpdu); 602 len += scnprintf(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n", 603 htt_stats_buf->last_scheduled_tsmp); 604 len += scnprintf(buf + len, buf_len - len, "pause_module_id = %u\n", 605 htt_stats_buf->pause_module_id); 606 len += scnprintf(buf + len, buf_len - len, "block_module_id = %u\n", 607 htt_stats_buf->block_module_id); 608 len += scnprintf(buf + len, buf_len - len, "allow_n_flags = 0x%x\n", 609 htt_stats_buf->allow_n_flags); 610 len += scnprintf(buf + len, buf_len - len, "sendn_frms_allowed = %u\n\n", 611 htt_stats_buf->sendn_frms_allowed); 612 613 if (len >= buf_len) 614 buf[buf_len - 1] = 0; 615 else 616 buf[len] = 0; 617 618 stats_req->buf_len = len; 619} 620 621static inline void htt_print_rx_tid_stats_tlv(const void *tag_buf, 622 struct debug_htt_stats_req *stats_req) 623{ 624 const struct htt_rx_tid_stats_tlv *htt_stats_buf = tag_buf; 625 u8 *buf = stats_req->buf; 626 u32 len = stats_req->buf_len; 627 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 628 char tid_name[MAX_HTT_TID_NAME + 1] = {}; 629 630 len += scnprintf(buf + len, buf_len - len, "HTT_RX_TID_STATS_TLV:\n"); 631 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n", 632 FIELD_GET(HTT_RX_TID_STATS_SW_PEER_ID, 633 htt_stats_buf->sw_peer_id__tid_num)); 634 len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n", 635 FIELD_GET(HTT_RX_TID_STATS_TID_NUM, 636 htt_stats_buf->sw_peer_id__tid_num)); 637 memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME); 638 len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name); 639 len += scnprintf(buf + len, buf_len - len, "dup_in_reorder = %u\n", 640 htt_stats_buf->dup_in_reorder); 641 len += scnprintf(buf + len, buf_len - len, "dup_past_outside_window = %u\n", 642 htt_stats_buf->dup_past_outside_window); 643 len += scnprintf(buf + len, buf_len - len, "dup_past_within_window = %u\n", 644 htt_stats_buf->dup_past_within_window); 645 len += scnprintf(buf + len, buf_len - len, "rxdesc_err_decrypt = %u\n\n", 646 htt_stats_buf->rxdesc_err_decrypt); 647 648 if (len >= buf_len) 649 buf[buf_len - 1] = 0; 650 else 651 buf[len] = 0; 652 653 stats_req->buf_len = len; 654} 655 656static inline void htt_print_counter_tlv(const void *tag_buf, 657 struct debug_htt_stats_req *stats_req) 658{ 659 const struct htt_counter_tlv *htt_stats_buf = tag_buf; 660 u8 *buf = stats_req->buf; 661 u32 len = stats_req->buf_len; 662 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 663 664 len += scnprintf(buf + len, buf_len - len, "HTT_COUNTER_TLV:\n"); 665 666 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->counter_name, 667 "counter_name", 668 HTT_MAX_COUNTER_NAME, "\n"); 669 len += scnprintf(buf + len, buf_len - len, "count = %u\n\n", 670 htt_stats_buf->count); 671 672 if (len >= buf_len) 673 buf[buf_len - 1] = 0; 674 else 675 buf[len] = 0; 676 677 stats_req->buf_len = len; 678} 679 680static inline void htt_print_peer_stats_cmn_tlv(const void *tag_buf, 681 struct debug_htt_stats_req *stats_req) 682{ 683 const struct htt_peer_stats_cmn_tlv *htt_stats_buf = tag_buf; 684 u8 *buf = stats_req->buf; 685 u32 len = stats_req->buf_len; 686 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 687 688 len += scnprintf(buf + len, buf_len - len, "HTT_PEER_STATS_CMN_TLV:\n"); 689 len += scnprintf(buf + len, buf_len - len, "ppdu_cnt = %u\n", 690 htt_stats_buf->ppdu_cnt); 691 len += scnprintf(buf + len, buf_len - len, "mpdu_cnt = %u\n", 692 htt_stats_buf->mpdu_cnt); 693 len += scnprintf(buf + len, buf_len - len, "msdu_cnt = %u\n", 694 htt_stats_buf->msdu_cnt); 695 len += scnprintf(buf + len, buf_len - len, "pause_bitmap = %u\n", 696 htt_stats_buf->pause_bitmap); 697 len += scnprintf(buf + len, buf_len - len, "block_bitmap = %u\n", 698 htt_stats_buf->block_bitmap); 699 len += scnprintf(buf + len, buf_len - len, "last_rssi = %d\n", 700 htt_stats_buf->rssi); 701 len += scnprintf(buf + len, buf_len - len, "enqueued_count = %llu\n", 702 htt_stats_buf->peer_enqueued_count_low | 703 ((u64)htt_stats_buf->peer_enqueued_count_high << 32)); 704 len += scnprintf(buf + len, buf_len - len, "dequeued_count = %llu\n", 705 htt_stats_buf->peer_dequeued_count_low | 706 ((u64)htt_stats_buf->peer_dequeued_count_high << 32)); 707 len += scnprintf(buf + len, buf_len - len, "dropped_count = %llu\n", 708 htt_stats_buf->peer_dropped_count_low | 709 ((u64)htt_stats_buf->peer_dropped_count_high << 32)); 710 len += scnprintf(buf + len, buf_len - len, "transmitted_ppdu_bytes = %llu\n", 711 htt_stats_buf->ppdu_transmitted_bytes_low | 712 ((u64)htt_stats_buf->ppdu_transmitted_bytes_high << 32)); 713 len += scnprintf(buf + len, buf_len - len, "ttl_removed_count = %u\n", 714 htt_stats_buf->peer_ttl_removed_count); 715 len += scnprintf(buf + len, buf_len - len, "inactive_time = %u\n\n", 716 htt_stats_buf->inactive_time); 717 718 if (len >= buf_len) 719 buf[buf_len - 1] = 0; 720 else 721 buf[len] = 0; 722 723 stats_req->buf_len = len; 724} 725 726static inline void htt_print_peer_details_tlv(const void *tag_buf, 727 struct debug_htt_stats_req *stats_req) 728{ 729 const struct htt_peer_details_tlv *htt_stats_buf = tag_buf; 730 u8 *buf = stats_req->buf; 731 u32 len = stats_req->buf_len; 732 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 733 734 len += scnprintf(buf + len, buf_len - len, "HTT_PEER_DETAILS_TLV:\n"); 735 len += scnprintf(buf + len, buf_len - len, "peer_type = %u\n", 736 htt_stats_buf->peer_type); 737 len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n", 738 htt_stats_buf->sw_peer_id); 739 len += scnprintf(buf + len, buf_len - len, "vdev_id = %lu\n", 740 FIELD_GET(HTT_PEER_DETAILS_VDEV_ID, 741 htt_stats_buf->vdev_pdev_ast_idx)); 742 len += scnprintf(buf + len, buf_len - len, "pdev_id = %lu\n", 743 FIELD_GET(HTT_PEER_DETAILS_PDEV_ID, 744 htt_stats_buf->vdev_pdev_ast_idx)); 745 len += scnprintf(buf + len, buf_len - len, "ast_idx = %lu\n", 746 FIELD_GET(HTT_PEER_DETAILS_AST_IDX, 747 htt_stats_buf->vdev_pdev_ast_idx)); 748 len += scnprintf(buf + len, buf_len - len, 749 "mac_addr = %02lx:%02lx:%02lx:%02lx:%02lx:%02lx\n", 750 FIELD_GET(HTT_MAC_ADDR_L32_0, 751 htt_stats_buf->mac_addr.mac_addr_l32), 752 FIELD_GET(HTT_MAC_ADDR_L32_1, 753 htt_stats_buf->mac_addr.mac_addr_l32), 754 FIELD_GET(HTT_MAC_ADDR_L32_2, 755 htt_stats_buf->mac_addr.mac_addr_l32), 756 FIELD_GET(HTT_MAC_ADDR_L32_3, 757 htt_stats_buf->mac_addr.mac_addr_l32), 758 FIELD_GET(HTT_MAC_ADDR_H16_0, 759 htt_stats_buf->mac_addr.mac_addr_h16), 760 FIELD_GET(HTT_MAC_ADDR_H16_1, 761 htt_stats_buf->mac_addr.mac_addr_h16)); 762 len += scnprintf(buf + len, buf_len - len, "peer_flags = 0x%x\n", 763 htt_stats_buf->peer_flags); 764 len += scnprintf(buf + len, buf_len - len, "qpeer_flags = 0x%x\n\n", 765 htt_stats_buf->qpeer_flags); 766 767 if (len >= buf_len) 768 buf[buf_len - 1] = 0; 769 else 770 buf[len] = 0; 771 772 stats_req->buf_len = len; 773} 774 775static inline void htt_print_tx_peer_rate_stats_tlv(const void *tag_buf, 776 struct debug_htt_stats_req *stats_req) 777{ 778 const struct htt_tx_peer_rate_stats_tlv *htt_stats_buf = tag_buf; 779 u8 *buf = stats_req->buf; 780 u32 len = stats_req->buf_len; 781 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 782 u8 j; 783 784 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PEER_RATE_STATS_TLV:\n"); 785 len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n", 786 htt_stats_buf->tx_ldpc); 787 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n", 788 htt_stats_buf->rts_cnt); 789 len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n", 790 htt_stats_buf->ack_rssi); 791 792 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs, "tx_mcs", 793 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 794 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_su_mcs, "tx_su_mcs", 795 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 796 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mu_mcs, "tx_mu_mcs", 797 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 798 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss, "tx_nss", 799 HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 800 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw, "tx_bw", 801 HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 802 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc, "tx_stbc", 803 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 804 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream, "tx_pream", 805 HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n"); 806 807 for (j = 0; j < HTT_TX_PEER_STATS_NUM_GI_COUNTERS; j++) { 808 len += scnprintf(buf + len, buf_len - len, 809 "tx_gi[%u] = ", j); 810 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_gi[j], NULL, 811 HTT_TX_PEER_STATS_NUM_MCS_COUNTERS, "\n"); 812 } 813 814 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm, "tx_dcm", 815 HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\n"); 816 817 if (len >= buf_len) 818 buf[buf_len - 1] = 0; 819 else 820 buf[len] = 0; 821 822 stats_req->buf_len = len; 823} 824 825static inline void htt_print_rx_peer_rate_stats_tlv(const void *tag_buf, 826 struct debug_htt_stats_req *stats_req) 827{ 828 const struct htt_rx_peer_rate_stats_tlv *htt_stats_buf = tag_buf; 829 u8 *buf = stats_req->buf; 830 u32 len = stats_req->buf_len; 831 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 832 u8 j; 833 834 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PEER_RATE_STATS_TLV:\n"); 835 len += scnprintf(buf + len, buf_len - len, "nsts = %u\n", 836 htt_stats_buf->nsts); 837 len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n", 838 htt_stats_buf->rx_ldpc); 839 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n", 840 htt_stats_buf->rts_cnt); 841 len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n", 842 htt_stats_buf->rssi_mgmt); 843 len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n", 844 htt_stats_buf->rssi_data); 845 len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n", 846 htt_stats_buf->rssi_comb); 847 848 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs, "rx_mcs", 849 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 850 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss, "rx_nss", 851 HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 852 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm, "rx_dcm", 853 HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n"); 854 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc, "rx_stbc", 855 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 856 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw, "rx_bw", 857 HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 858 859 for (j = 0; j < HTT_RX_PEER_STATS_NUM_SPATIAL_STREAMS; j++) { 860 len += scnprintf(buf + len, (buf_len - len), 861 "rssi_chain[%u] = ", j); 862 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain[j], NULL, 863 HTT_RX_PEER_STATS_NUM_BW_COUNTERS, "\n"); 864 } 865 866 for (j = 0; j < HTT_RX_PEER_STATS_NUM_GI_COUNTERS; j++) { 867 len += scnprintf(buf + len, (buf_len - len), 868 "rx_gi[%u] = ", j); 869 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi[j], NULL, 870 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 871 } 872 873 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream, "rx_pream", 874 HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n"); 875 876 if (len >= buf_len) 877 buf[buf_len - 1] = 0; 878 else 879 buf[len] = 0; 880 881 stats_req->buf_len = len; 882} 883 884static inline void 885htt_print_tx_hwq_mu_mimo_sch_stats_tlv(const void *tag_buf, 886 struct debug_htt_stats_req *stats_req) 887{ 888 const struct htt_tx_hwq_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf; 889 u8 *buf = stats_req->buf; 890 u32 len = stats_req->buf_len; 891 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 892 893 len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_SCH_STATS_TLV:\n"); 894 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n", 895 htt_stats_buf->mu_mimo_sch_posted); 896 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n", 897 htt_stats_buf->mu_mimo_sch_failed); 898 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n\n", 899 htt_stats_buf->mu_mimo_ppdu_posted); 900 901 if (len >= buf_len) 902 buf[buf_len - 1] = 0; 903 else 904 buf[len] = 0; 905 906 stats_req->buf_len = len; 907} 908 909static inline void 910htt_print_tx_hwq_mu_mimo_mpdu_stats_tlv(const void *tag_buf, 911 struct debug_htt_stats_req *stats_req) 912{ 913 const struct htt_tx_hwq_mu_mimo_mpdu_stats_tlv *htt_stats_buf = tag_buf; 914 u8 *buf = stats_req->buf; 915 u32 len = stats_req->buf_len; 916 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 917 918 len += scnprintf(buf + len, buf_len - len, 919 "HTT_TX_HWQ_MU_MIMO_MPDU_STATS_TLV:\n"); 920 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_queued_usr = %u\n", 921 htt_stats_buf->mu_mimo_mpdus_queued_usr); 922 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_tried_usr = %u\n", 923 htt_stats_buf->mu_mimo_mpdus_tried_usr); 924 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_failed_usr = %u\n", 925 htt_stats_buf->mu_mimo_mpdus_failed_usr); 926 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_requeued_usr = %u\n", 927 htt_stats_buf->mu_mimo_mpdus_requeued_usr); 928 len += scnprintf(buf + len, buf_len - len, "mu_mimo_err_no_ba_usr = %u\n", 929 htt_stats_buf->mu_mimo_err_no_ba_usr); 930 len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdu_underrun_usr = %u\n", 931 htt_stats_buf->mu_mimo_mpdu_underrun_usr); 932 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ampdu_underrun_usr = %u\n\n", 933 htt_stats_buf->mu_mimo_ampdu_underrun_usr); 934 935 if (len >= buf_len) 936 buf[buf_len - 1] = 0; 937 else 938 buf[len] = 0; 939 940 stats_req->buf_len = len; 941} 942 943static inline void 944htt_print_tx_hwq_mu_mimo_cmn_stats_tlv(const void *tag_buf, 945 struct debug_htt_stats_req *stats_req) 946{ 947 const struct htt_tx_hwq_mu_mimo_cmn_stats_tlv *htt_stats_buf = tag_buf; 948 u8 *buf = stats_req->buf; 949 u32 len = stats_req->buf_len; 950 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 951 952 len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_CMN_STATS_TLV:\n"); 953 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 954 FIELD_GET(HTT_TX_HWQ_STATS_MAC_ID, 955 htt_stats_buf->mac_id__hwq_id__word)); 956 len += scnprintf(buf + len, buf_len - len, "hwq_id = %lu\n\n", 957 FIELD_GET(HTT_TX_HWQ_STATS_HWQ_ID, 958 htt_stats_buf->mac_id__hwq_id__word)); 959 960 if (len >= buf_len) 961 buf[buf_len - 1] = 0; 962 else 963 buf[len] = 0; 964 965 stats_req->buf_len = len; 966} 967 968static inline void 969htt_print_tx_hwq_stats_cmn_tlv(const void *tag_buf, struct debug_htt_stats_req *stats_req) 970{ 971 const struct htt_tx_hwq_stats_cmn_tlv *htt_stats_buf = tag_buf; 972 u8 *buf = stats_req->buf; 973 u32 len = stats_req->buf_len; 974 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 975 976 /* TODO: HKDBG */ 977 len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_STATS_CMN_TLV:\n"); 978 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 979 FIELD_GET(HTT_TX_HWQ_STATS_MAC_ID, 980 htt_stats_buf->mac_id__hwq_id__word)); 981 len += scnprintf(buf + len, buf_len - len, "hwq_id = %lu\n", 982 FIELD_GET(HTT_TX_HWQ_STATS_HWQ_ID, 983 htt_stats_buf->mac_id__hwq_id__word)); 984 len += scnprintf(buf + len, buf_len - len, "xretry = %u\n", 985 htt_stats_buf->xretry); 986 len += scnprintf(buf + len, buf_len - len, "underrun_cnt = %u\n", 987 htt_stats_buf->underrun_cnt); 988 len += scnprintf(buf + len, buf_len - len, "flush_cnt = %u\n", 989 htt_stats_buf->flush_cnt); 990 len += scnprintf(buf + len, buf_len - len, "filt_cnt = %u\n", 991 htt_stats_buf->filt_cnt); 992 len += scnprintf(buf + len, buf_len - len, "null_mpdu_bmap = %u\n", 993 htt_stats_buf->null_mpdu_bmap); 994 len += scnprintf(buf + len, buf_len - len, "user_ack_failure = %u\n", 995 htt_stats_buf->user_ack_failure); 996 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 997 htt_stats_buf->ack_tlv_proc); 998 len += scnprintf(buf + len, buf_len - len, "sched_id_proc = %u\n", 999 htt_stats_buf->sched_id_proc); 1000 len += scnprintf(buf + len, buf_len - len, "null_mpdu_tx_count = %u\n", 1001 htt_stats_buf->null_mpdu_tx_count); 1002 len += scnprintf(buf + len, buf_len - len, "mpdu_bmap_not_recvd = %u\n", 1003 htt_stats_buf->mpdu_bmap_not_recvd); 1004 len += scnprintf(buf + len, buf_len - len, "num_bar = %u\n", 1005 htt_stats_buf->num_bar); 1006 len += scnprintf(buf + len, buf_len - len, "rts = %u\n", 1007 htt_stats_buf->rts); 1008 len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n", 1009 htt_stats_buf->cts2self); 1010 len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n", 1011 htt_stats_buf->qos_null); 1012 len += scnprintf(buf + len, buf_len - len, "mpdu_tried_cnt = %u\n", 1013 htt_stats_buf->mpdu_tried_cnt); 1014 len += scnprintf(buf + len, buf_len - len, "mpdu_queued_cnt = %u\n", 1015 htt_stats_buf->mpdu_queued_cnt); 1016 len += scnprintf(buf + len, buf_len - len, "mpdu_ack_fail_cnt = %u\n", 1017 htt_stats_buf->mpdu_ack_fail_cnt); 1018 len += scnprintf(buf + len, buf_len - len, "mpdu_filt_cnt = %u\n", 1019 htt_stats_buf->mpdu_filt_cnt); 1020 len += scnprintf(buf + len, buf_len - len, "false_mpdu_ack_count = %u\n", 1021 htt_stats_buf->false_mpdu_ack_count); 1022 len += scnprintf(buf + len, buf_len - len, "txq_timeout = %u\n\n", 1023 htt_stats_buf->txq_timeout); 1024 1025 if (len >= buf_len) 1026 buf[buf_len - 1] = 0; 1027 else 1028 buf[len] = 0; 1029 1030 stats_req->buf_len = len; 1031} 1032 1033static inline void 1034htt_print_tx_hwq_difs_latency_stats_tlv_v(const void *tag_buf, 1035 u16 tag_len, 1036 struct debug_htt_stats_req *stats_req) 1037{ 1038 const struct htt_tx_hwq_difs_latency_stats_tlv_v *htt_stats_buf = tag_buf; 1039 u8 *buf = stats_req->buf; 1040 u32 len = stats_req->buf_len; 1041 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1042 u16 data_len = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_DIFS_LATENCY_BINS); 1043 1044 len += scnprintf(buf + len, buf_len - len, 1045 "HTT_TX_HWQ_DIFS_LATENCY_STATS_TLV_V:\n"); 1046 len += scnprintf(buf + len, buf_len - len, "hist_intvl = %u\n", 1047 htt_stats_buf->hist_intvl); 1048 1049 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->difs_latency_hist, 1050 "difs_latency_hist", data_len, "\n\n"); 1051 1052 if (len >= buf_len) 1053 buf[buf_len - 1] = 0; 1054 else 1055 buf[len] = 0; 1056 1057 stats_req->buf_len = len; 1058} 1059 1060static inline void 1061htt_print_tx_hwq_cmd_result_stats_tlv_v(const void *tag_buf, 1062 u16 tag_len, 1063 struct debug_htt_stats_req *stats_req) 1064{ 1065 const struct htt_tx_hwq_cmd_result_stats_tlv_v *htt_stats_buf = tag_buf; 1066 u8 *buf = stats_req->buf; 1067 u32 len = stats_req->buf_len; 1068 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1069 u16 data_len; 1070 1071 data_len = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_CMD_RESULT_STATS); 1072 1073 len += scnprintf(buf + len, buf_len - len, 1074 "HTT_TX_HWQ_CMD_RESULT_STATS_TLV_V:\n"); 1075 1076 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_result, "cmd_result", 1077 data_len, "\n\n"); 1078 1079 if (len >= buf_len) 1080 buf[buf_len - 1] = 0; 1081 else 1082 buf[len] = 0; 1083 1084 stats_req->buf_len = len; 1085} 1086 1087static inline void 1088htt_print_tx_hwq_cmd_stall_stats_tlv_v(const void *tag_buf, 1089 u16 tag_len, 1090 struct debug_htt_stats_req *stats_req) 1091{ 1092 const struct htt_tx_hwq_cmd_stall_stats_tlv_v *htt_stats_buf = tag_buf; 1093 u8 *buf = stats_req->buf; 1094 u32 len = stats_req->buf_len; 1095 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1096 u16 num_elems; 1097 1098 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_CMD_STALL_STATS); 1099 1100 len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_CMD_STALL_STATS_TLV_V:\n"); 1101 1102 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_stall_status, 1103 "cmd_stall_status", num_elems, "\n\n"); 1104 1105 if (len >= buf_len) 1106 buf[buf_len - 1] = 0; 1107 else 1108 buf[len] = 0; 1109 1110 stats_req->buf_len = len; 1111} 1112 1113static inline void 1114htt_print_tx_hwq_fes_result_stats_tlv_v(const void *tag_buf, 1115 u16 tag_len, 1116 struct debug_htt_stats_req *stats_req) 1117{ 1118 const struct htt_tx_hwq_fes_result_stats_tlv_v *htt_stats_buf = tag_buf; 1119 u8 *buf = stats_req->buf; 1120 u32 len = stats_req->buf_len; 1121 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1122 u16 num_elems; 1123 1124 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_FES_RESULT_STATS); 1125 1126 len += scnprintf(buf + len, buf_len - len, 1127 "HTT_TX_HWQ_FES_RESULT_STATS_TLV_V:\n"); 1128 1129 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fes_result, "fes_result", 1130 num_elems, "\n\n"); 1131 1132 if (len >= buf_len) 1133 buf[buf_len - 1] = 0; 1134 else 1135 buf[len] = 0; 1136 1137 stats_req->buf_len = len; 1138} 1139 1140static inline void 1141htt_print_tx_hwq_tried_mpdu_cnt_hist_tlv_v(const void *tag_buf, 1142 u16 tag_len, 1143 struct debug_htt_stats_req *stats_req) 1144{ 1145 const struct htt_tx_hwq_tried_mpdu_cnt_hist_tlv_v *htt_stats_buf = tag_buf; 1146 u8 *buf = stats_req->buf; 1147 u32 len = stats_req->buf_len; 1148 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1149 u32 num_elements = ((tag_len - 1150 sizeof(htt_stats_buf->hist_bin_size)) >> 2); 1151 1152 len += scnprintf(buf + len, buf_len - len, 1153 "HTT_TX_HWQ_TRIED_MPDU_CNT_HIST_TLV_V:\n"); 1154 len += scnprintf(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n", 1155 htt_stats_buf->hist_bin_size); 1156 1157 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist, 1158 "tried_mpdu_cnt_hist", num_elements, "\n\n"); 1159 1160 if (len >= buf_len) 1161 buf[buf_len - 1] = 0; 1162 else 1163 buf[len] = 0; 1164 1165 stats_req->buf_len = len; 1166} 1167 1168static inline void 1169htt_print_tx_hwq_txop_used_cnt_hist_tlv_v(const void *tag_buf, 1170 u16 tag_len, 1171 struct debug_htt_stats_req *stats_req) 1172{ 1173 const struct htt_tx_hwq_txop_used_cnt_hist_tlv_v *htt_stats_buf = tag_buf; 1174 u8 *buf = stats_req->buf; 1175 u32 len = stats_req->buf_len; 1176 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1177 u32 num_elements = tag_len >> 2; 1178 1179 len += scnprintf(buf + len, buf_len - len, 1180 "HTT_TX_HWQ_TXOP_USED_CNT_HIST_TLV_V:\n"); 1181 1182 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->txop_used_cnt_hist, 1183 "txop_used_cnt_hist", num_elements, "\n\n"); 1184 1185 if (len >= buf_len) 1186 buf[buf_len - 1] = 0; 1187 else 1188 buf[len] = 0; 1189 1190 stats_req->buf_len = len; 1191} 1192 1193static inline void htt_print_tx_sounding_stats_tlv(const void *tag_buf, 1194 struct debug_htt_stats_req *stats_req) 1195{ 1196 s32 i; 1197 const struct htt_tx_sounding_stats_tlv *htt_stats_buf = tag_buf; 1198 u8 *buf = stats_req->buf; 1199 u32 len = stats_req->buf_len; 1200 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1201 const u32 *cbf_20 = htt_stats_buf->cbf_20; 1202 const u32 *cbf_40 = htt_stats_buf->cbf_40; 1203 const u32 *cbf_80 = htt_stats_buf->cbf_80; 1204 const u32 *cbf_160 = htt_stats_buf->cbf_160; 1205 1206 if (htt_stats_buf->tx_sounding_mode == HTT_TX_AC_SOUNDING_MODE) { 1207 len += scnprintf(buf + len, buf_len - len, 1208 "\nHTT_TX_AC_SOUNDING_STATS_TLV:\n\n"); 1209 len += scnprintf(buf + len, buf_len - len, 1210 "ac_cbf_20 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1211 cbf_20[HTT_IMPLICIT_TXBF_STEER_STATS], 1212 cbf_20[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1213 cbf_20[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1214 cbf_20[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1215 cbf_20[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1216 len += scnprintf(buf + len, buf_len - len, 1217 "ac_cbf_40 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1218 cbf_40[HTT_IMPLICIT_TXBF_STEER_STATS], 1219 cbf_40[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1220 cbf_40[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1221 cbf_40[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1222 cbf_40[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1223 len += scnprintf(buf + len, buf_len - len, 1224 "ac_cbf_80 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1225 cbf_80[HTT_IMPLICIT_TXBF_STEER_STATS], 1226 cbf_80[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1227 cbf_80[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1228 cbf_80[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1229 cbf_80[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1230 len += scnprintf(buf + len, buf_len - len, 1231 "ac_cbf_160 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1232 cbf_160[HTT_IMPLICIT_TXBF_STEER_STATS], 1233 cbf_160[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1234 cbf_160[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1235 cbf_160[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1236 cbf_160[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1237 1238 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++) { 1239 len += scnprintf(buf + len, buf_len - len, 1240 "Sounding User %u = 20MHz: %u, 40MHz : %u, 80MHz: %u, 160MHz: %u\n", 1241 i, 1242 htt_stats_buf->sounding[0], 1243 htt_stats_buf->sounding[1], 1244 htt_stats_buf->sounding[2], 1245 htt_stats_buf->sounding[3]); 1246 } 1247 } else if (htt_stats_buf->tx_sounding_mode == HTT_TX_AX_SOUNDING_MODE) { 1248 len += scnprintf(buf + len, buf_len - len, 1249 "\nHTT_TX_AX_SOUNDING_STATS_TLV:\n"); 1250 len += scnprintf(buf + len, buf_len - len, 1251 "ax_cbf_20 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1252 cbf_20[HTT_IMPLICIT_TXBF_STEER_STATS], 1253 cbf_20[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1254 cbf_20[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1255 cbf_20[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1256 cbf_20[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1257 len += scnprintf(buf + len, buf_len - len, 1258 "ax_cbf_40 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1259 cbf_40[HTT_IMPLICIT_TXBF_STEER_STATS], 1260 cbf_40[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1261 cbf_40[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1262 cbf_40[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1263 cbf_40[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1264 len += scnprintf(buf + len, buf_len - len, 1265 "ax_cbf_80 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1266 cbf_80[HTT_IMPLICIT_TXBF_STEER_STATS], 1267 cbf_80[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1268 cbf_80[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1269 cbf_80[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1270 cbf_80[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1271 len += scnprintf(buf + len, buf_len - len, 1272 "ax_cbf_160 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n", 1273 cbf_160[HTT_IMPLICIT_TXBF_STEER_STATS], 1274 cbf_160[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS], 1275 cbf_160[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS], 1276 cbf_160[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS], 1277 cbf_160[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]); 1278 1279 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++) { 1280 len += scnprintf(buf + len, buf_len - len, 1281 "Sounding User %u = 20MHz: %u, 40MHz : %u, 80MHz: %u, 160MHz: %u\n", 1282 i, 1283 htt_stats_buf->sounding[0], 1284 htt_stats_buf->sounding[1], 1285 htt_stats_buf->sounding[2], 1286 htt_stats_buf->sounding[3]); 1287 } 1288 } 1289 1290 if (len >= buf_len) 1291 buf[buf_len - 1] = 0; 1292 else 1293 buf[len] = 0; 1294 1295 stats_req->buf_len = len; 1296} 1297 1298static inline void 1299htt_print_tx_selfgen_cmn_stats_tlv(const void *tag_buf, 1300 struct debug_htt_stats_req *stats_req) 1301{ 1302 const struct htt_tx_selfgen_cmn_stats_tlv *htt_stats_buf = tag_buf; 1303 u8 *buf = stats_req->buf; 1304 u32 len = stats_req->buf_len; 1305 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1306 1307 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n"); 1308 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 1309 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 1310 len += scnprintf(buf + len, buf_len - len, "su_bar = %u\n", 1311 htt_stats_buf->su_bar); 1312 len += scnprintf(buf + len, buf_len - len, "rts = %u\n", 1313 htt_stats_buf->rts); 1314 len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n", 1315 htt_stats_buf->cts2self); 1316 len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n", 1317 htt_stats_buf->qos_null); 1318 len += scnprintf(buf + len, buf_len - len, "delayed_bar_1 = %u\n", 1319 htt_stats_buf->delayed_bar_1); 1320 len += scnprintf(buf + len, buf_len - len, "delayed_bar_2 = %u\n", 1321 htt_stats_buf->delayed_bar_2); 1322 len += scnprintf(buf + len, buf_len - len, "delayed_bar_3 = %u\n", 1323 htt_stats_buf->delayed_bar_3); 1324 len += scnprintf(buf + len, buf_len - len, "delayed_bar_4 = %u\n", 1325 htt_stats_buf->delayed_bar_4); 1326 len += scnprintf(buf + len, buf_len - len, "delayed_bar_5 = %u\n", 1327 htt_stats_buf->delayed_bar_5); 1328 len += scnprintf(buf + len, buf_len - len, "delayed_bar_6 = %u\n", 1329 htt_stats_buf->delayed_bar_6); 1330 len += scnprintf(buf + len, buf_len - len, "delayed_bar_7 = %u\n\n", 1331 htt_stats_buf->delayed_bar_7); 1332 1333 if (len >= buf_len) 1334 buf[buf_len - 1] = 0; 1335 else 1336 buf[len] = 0; 1337 1338 stats_req->buf_len = len; 1339} 1340 1341static inline void 1342htt_print_tx_selfgen_ac_stats_tlv(const void *tag_buf, 1343 struct debug_htt_stats_req *stats_req) 1344{ 1345 const struct htt_tx_selfgen_ac_stats_tlv *htt_stats_buf = tag_buf; 1346 u8 *buf = stats_req->buf; 1347 u32 len = stats_req->buf_len; 1348 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1349 1350 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n"); 1351 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa = %u\n", 1352 htt_stats_buf->ac_su_ndpa); 1353 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp = %u\n", 1354 htt_stats_buf->ac_su_ndp); 1355 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa = %u\n", 1356 htt_stats_buf->ac_mu_mimo_ndpa); 1357 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp = %u\n", 1358 htt_stats_buf->ac_mu_mimo_ndp); 1359 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_1 = %u\n", 1360 htt_stats_buf->ac_mu_mimo_brpoll_1); 1361 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_2 = %u\n", 1362 htt_stats_buf->ac_mu_mimo_brpoll_2); 1363 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_3 = %u\n\n", 1364 htt_stats_buf->ac_mu_mimo_brpoll_3); 1365 1366 if (len >= buf_len) 1367 buf[buf_len - 1] = 0; 1368 else 1369 buf[len] = 0; 1370 1371 stats_req->buf_len = len; 1372} 1373 1374static inline void 1375htt_print_tx_selfgen_ax_stats_tlv(const void *tag_buf, 1376 struct debug_htt_stats_req *stats_req) 1377{ 1378 const struct htt_tx_selfgen_ax_stats_tlv *htt_stats_buf = tag_buf; 1379 u8 *buf = stats_req->buf; 1380 u32 len = stats_req->buf_len; 1381 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1382 1383 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n"); 1384 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa = %u\n", 1385 htt_stats_buf->ax_su_ndpa); 1386 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp = %u\n", 1387 htt_stats_buf->ax_su_ndp); 1388 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa = %u\n", 1389 htt_stats_buf->ax_mu_mimo_ndpa); 1390 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp = %u\n", 1391 htt_stats_buf->ax_mu_mimo_ndp); 1392 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_1 = %u\n", 1393 htt_stats_buf->ax_mu_mimo_brpoll_1); 1394 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_2 = %u\n", 1395 htt_stats_buf->ax_mu_mimo_brpoll_2); 1396 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_3 = %u\n", 1397 htt_stats_buf->ax_mu_mimo_brpoll_3); 1398 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_4 = %u\n", 1399 htt_stats_buf->ax_mu_mimo_brpoll_4); 1400 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_5 = %u\n", 1401 htt_stats_buf->ax_mu_mimo_brpoll_5); 1402 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_6 = %u\n", 1403 htt_stats_buf->ax_mu_mimo_brpoll_6); 1404 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_7 = %u\n", 1405 htt_stats_buf->ax_mu_mimo_brpoll_7); 1406 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger = %u\n", 1407 htt_stats_buf->ax_basic_trigger); 1408 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_trigger = %u\n", 1409 htt_stats_buf->ax_ulmumimo_trigger); 1410 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger = %u\n", 1411 htt_stats_buf->ax_bsr_trigger); 1412 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n", 1413 htt_stats_buf->ax_mu_bar_trigger); 1414 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n\n", 1415 htt_stats_buf->ax_mu_rts_trigger); 1416 1417 if (len >= buf_len) 1418 buf[buf_len - 1] = 0; 1419 else 1420 buf[len] = 0; 1421 1422 stats_req->buf_len = len; 1423} 1424 1425static inline void 1426htt_print_tx_selfgen_ac_err_stats_tlv(const void *tag_buf, 1427 struct debug_htt_stats_req *stats_req) 1428{ 1429 const struct htt_tx_selfgen_ac_err_stats_tlv *htt_stats_buf = tag_buf; 1430 u8 *buf = stats_req->buf; 1431 u32 len = stats_req->buf_len; 1432 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1433 1434 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n"); 1435 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_err = %u\n", 1436 htt_stats_buf->ac_su_ndp_err); 1437 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n", 1438 htt_stats_buf->ac_su_ndpa_err); 1439 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n", 1440 htt_stats_buf->ac_mu_mimo_ndpa_err); 1441 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n", 1442 htt_stats_buf->ac_mu_mimo_ndp_err); 1443 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n", 1444 htt_stats_buf->ac_mu_mimo_brp1_err); 1445 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n", 1446 htt_stats_buf->ac_mu_mimo_brp2_err); 1447 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n", 1448 htt_stats_buf->ac_mu_mimo_brp3_err); 1449 1450 if (len >= buf_len) 1451 buf[buf_len - 1] = 0; 1452 else 1453 buf[len] = 0; 1454 1455 stats_req->buf_len = len; 1456} 1457 1458static inline void 1459htt_print_tx_selfgen_ax_err_stats_tlv(const void *tag_buf, 1460 struct debug_htt_stats_req *stats_req) 1461{ 1462 const struct htt_tx_selfgen_ax_err_stats_tlv *htt_stats_buf = tag_buf; 1463 u8 *buf = stats_req->buf; 1464 u32 len = stats_req->buf_len; 1465 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1466 1467 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n"); 1468 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_err = %u\n", 1469 htt_stats_buf->ax_su_ndp_err); 1470 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n", 1471 htt_stats_buf->ax_su_ndpa_err); 1472 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n", 1473 htt_stats_buf->ax_mu_mimo_ndpa_err); 1474 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n", 1475 htt_stats_buf->ax_mu_mimo_ndp_err); 1476 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp1_err = %u\n", 1477 htt_stats_buf->ax_mu_mimo_brp1_err); 1478 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp2_err = %u\n", 1479 htt_stats_buf->ax_mu_mimo_brp2_err); 1480 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp3_err = %u\n", 1481 htt_stats_buf->ax_mu_mimo_brp3_err); 1482 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp4_err = %u\n", 1483 htt_stats_buf->ax_mu_mimo_brp4_err); 1484 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp5_err = %u\n", 1485 htt_stats_buf->ax_mu_mimo_brp5_err); 1486 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp6_err = %u\n", 1487 htt_stats_buf->ax_mu_mimo_brp6_err); 1488 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp7_err = %u\n", 1489 htt_stats_buf->ax_mu_mimo_brp7_err); 1490 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger_err = %u\n", 1491 htt_stats_buf->ax_basic_trigger_err); 1492 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_trigger_err = %u\n", 1493 htt_stats_buf->ax_ulmumimo_trigger_err); 1494 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n", 1495 htt_stats_buf->ax_bsr_trigger_err); 1496 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n", 1497 htt_stats_buf->ax_mu_bar_trigger_err); 1498 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n\n", 1499 htt_stats_buf->ax_mu_rts_trigger_err); 1500 1501 if (len >= buf_len) 1502 buf[buf_len - 1] = 0; 1503 else 1504 buf[len] = 0; 1505 1506 stats_req->buf_len = len; 1507} 1508 1509static inline void 1510htt_print_tx_pdev_mu_mimo_sch_stats_tlv(const void *tag_buf, 1511 struct debug_htt_stats_req *stats_req) 1512{ 1513 const struct htt_tx_pdev_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf; 1514 u8 *buf = stats_req->buf; 1515 u32 len = stats_req->buf_len; 1516 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1517 u8 i; 1518 1519 len += scnprintf(buf + len, buf_len - len, 1520 "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n"); 1521 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n", 1522 htt_stats_buf->mu_mimo_sch_posted); 1523 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n", 1524 htt_stats_buf->mu_mimo_sch_failed); 1525 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n\n", 1526 htt_stats_buf->mu_mimo_ppdu_posted); 1527 1528 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++) 1529 len += scnprintf(buf + len, buf_len - len, 1530 "ac_mu_mimo_sch_posted_per_group_index %u = %u\n", 1531 i, htt_stats_buf->ac_mu_mimo_sch_posted_per_grp_sz[i]); 1532 1533 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++) 1534 len += scnprintf(buf + len, buf_len - len, 1535 "ax_mu_mimo_sch_posted_per_group_index %u = %u\n", 1536 i, htt_stats_buf->ax_mu_mimo_sch_posted_per_grp_sz[i]); 1537 1538 len += scnprintf(buf + len, buf_len - len, "11ac MU_MIMO SCH STATS:\n"); 1539 1540 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++) 1541 len += scnprintf(buf + len, buf_len - len, 1542 "ac_mu_mimo_sch_nusers_%u = %u\n", 1543 i, htt_stats_buf->ac_mu_mimo_sch_nusers[i]); 1544 1545 len += scnprintf(buf + len, buf_len - len, "\n11ax MU_MIMO SCH STATS:\n"); 1546 1547 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++) 1548 len += scnprintf(buf + len, buf_len - len, 1549 "ax_mu_mimo_sch_nusers_%u = %u\n", 1550 i, htt_stats_buf->ax_mu_mimo_sch_nusers[i]); 1551 1552 len += scnprintf(buf + len, buf_len - len, "\n11ax OFDMA SCH STATS:\n"); 1553 1554 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) { 1555 len += scnprintf(buf + len, buf_len - len, 1556 "ax_ofdma_sch_nusers_%u = %u\n", 1557 i, htt_stats_buf->ax_ofdma_sch_nusers[i]); 1558 len += scnprintf(buf + len, buf_len - len, 1559 "ax_ul_ofdma_basic_sch_nusers_%u = %u\n", 1560 i, htt_stats_buf->ax_ul_ofdma_basic_sch_nusers[i]); 1561 len += scnprintf(buf + len, buf_len - len, 1562 "ax_ul_ofdma_bsr_sch_nusers_%u = %u\n", 1563 i, htt_stats_buf->ax_ul_ofdma_bsr_sch_nusers[i]); 1564 len += scnprintf(buf + len, buf_len - len, 1565 "ax_ul_ofdma_sch_bar_nusers_%u = %u\n", 1566 i, htt_stats_buf->ax_ul_ofdma_bar_sch_nusers[i]); 1567 len += scnprintf(buf + len, buf_len - len, 1568 "ax_ul_ofdma_brp_sch_nusers_%u = %u\n", 1569 i, htt_stats_buf->ax_ul_ofdma_brp_sch_nusers[i]); 1570 } 1571 1572 len += scnprintf(buf + len, buf_len - len, "\n11ax UL MUMIO SCH STATS:\n"); 1573 1574 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_UL_MUMIMO_USER_STATS; i++) { 1575 len += scnprintf(buf + len, buf_len - len, 1576 "ax_ul_mumimo_basic_sch_nusers_%u = %u\n", 1577 i, htt_stats_buf->ax_ul_mumimo_basic_sch_nusers[i]); 1578 len += scnprintf(buf + len, buf_len - len, 1579 "ax_ul_mumimo_brp_sch_nusers_%u = %u\n", 1580 i, htt_stats_buf->ax_ul_mumimo_brp_sch_nusers[i]); 1581 } 1582 1583 if (len >= buf_len) 1584 buf[buf_len - 1] = 0; 1585 else 1586 buf[len] = 0; 1587 1588 stats_req->buf_len = len; 1589} 1590 1591static inline void 1592htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(const void *tag_buf, 1593 struct debug_htt_stats_req *stats_req) 1594{ 1595 const struct htt_tx_pdev_mpdu_stats_tlv *htt_stats_buf = tag_buf; 1596 u8 *buf = stats_req->buf; 1597 u32 len = stats_req->buf_len; 1598 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1599 1600 if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_MIMO_AC) { 1601 if (!htt_stats_buf->user_index) 1602 len += scnprintf(buf + len, buf_len - len, 1603 "HTT_TX_PDEV_MU_MIMO_AC_MPDU_STATS:\n"); 1604 1605 if (htt_stats_buf->user_index < 1606 HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS) { 1607 len += scnprintf(buf + len, buf_len - len, 1608 "ac_mu_mimo_mpdus_queued_usr_%u = %u\n", 1609 htt_stats_buf->user_index, 1610 htt_stats_buf->mpdus_queued_usr); 1611 len += scnprintf(buf + len, buf_len - len, 1612 "ac_mu_mimo_mpdus_tried_usr_%u = %u\n", 1613 htt_stats_buf->user_index, 1614 htt_stats_buf->mpdus_tried_usr); 1615 len += scnprintf(buf + len, buf_len - len, 1616 "ac_mu_mimo_mpdus_failed_usr_%u = %u\n", 1617 htt_stats_buf->user_index, 1618 htt_stats_buf->mpdus_failed_usr); 1619 len += scnprintf(buf + len, buf_len - len, 1620 "ac_mu_mimo_mpdus_requeued_usr_%u = %u\n", 1621 htt_stats_buf->user_index, 1622 htt_stats_buf->mpdus_requeued_usr); 1623 len += scnprintf(buf + len, buf_len - len, 1624 "ac_mu_mimo_err_no_ba_usr_%u = %u\n", 1625 htt_stats_buf->user_index, 1626 htt_stats_buf->err_no_ba_usr); 1627 len += scnprintf(buf + len, buf_len - len, 1628 "ac_mu_mimo_mpdu_underrun_usr_%u = %u\n", 1629 htt_stats_buf->user_index, 1630 htt_stats_buf->mpdu_underrun_usr); 1631 len += scnprintf(buf + len, buf_len - len, 1632 "ac_mu_mimo_ampdu_underrun_usr_%u = %u\n\n", 1633 htt_stats_buf->user_index, 1634 htt_stats_buf->ampdu_underrun_usr); 1635 } 1636 } 1637 1638 if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_MIMO_AX) { 1639 if (!htt_stats_buf->user_index) 1640 len += scnprintf(buf + len, buf_len - len, 1641 "HTT_TX_PDEV_MU_MIMO_AX_MPDU_STATS:\n"); 1642 1643 if (htt_stats_buf->user_index < 1644 HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS) { 1645 len += scnprintf(buf + len, buf_len - len, 1646 "ax_mu_mimo_mpdus_queued_usr_%u = %u\n", 1647 htt_stats_buf->user_index, 1648 htt_stats_buf->mpdus_queued_usr); 1649 len += scnprintf(buf + len, buf_len - len, 1650 "ax_mu_mimo_mpdus_tried_usr_%u = %u\n", 1651 htt_stats_buf->user_index, 1652 htt_stats_buf->mpdus_tried_usr); 1653 len += scnprintf(buf + len, buf_len - len, 1654 "ax_mu_mimo_mpdus_failed_usr_%u = %u\n", 1655 htt_stats_buf->user_index, 1656 htt_stats_buf->mpdus_failed_usr); 1657 len += scnprintf(buf + len, buf_len - len, 1658 "ax_mu_mimo_mpdus_requeued_usr_%u = %u\n", 1659 htt_stats_buf->user_index, 1660 htt_stats_buf->mpdus_requeued_usr); 1661 len += scnprintf(buf + len, buf_len - len, 1662 "ax_mu_mimo_err_no_ba_usr_%u = %u\n", 1663 htt_stats_buf->user_index, 1664 htt_stats_buf->err_no_ba_usr); 1665 len += scnprintf(buf + len, buf_len - len, 1666 "ax_mu_mimo_mpdu_underrun_usr_%u = %u\n", 1667 htt_stats_buf->user_index, 1668 htt_stats_buf->mpdu_underrun_usr); 1669 len += scnprintf(buf + len, buf_len - len, 1670 "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n\n", 1671 htt_stats_buf->user_index, 1672 htt_stats_buf->ampdu_underrun_usr); 1673 } 1674 } 1675 1676 if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_OFDMA_AX) { 1677 if (!htt_stats_buf->user_index) 1678 len += scnprintf(buf + len, buf_len - len, 1679 "HTT_TX_PDEV_AX_MU_OFDMA_MPDU_STATS:\n"); 1680 1681 if (htt_stats_buf->user_index < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS) { 1682 len += scnprintf(buf + len, buf_len - len, 1683 "ax_mu_ofdma_mpdus_queued_usr_%u = %u\n", 1684 htt_stats_buf->user_index, 1685 htt_stats_buf->mpdus_queued_usr); 1686 len += scnprintf(buf + len, buf_len - len, 1687 "ax_mu_ofdma_mpdus_tried_usr_%u = %u\n", 1688 htt_stats_buf->user_index, 1689 htt_stats_buf->mpdus_tried_usr); 1690 len += scnprintf(buf + len, buf_len - len, 1691 "ax_mu_ofdma_mpdus_failed_usr_%u = %u\n", 1692 htt_stats_buf->user_index, 1693 htt_stats_buf->mpdus_failed_usr); 1694 len += scnprintf(buf + len, buf_len - len, 1695 "ax_mu_ofdma_mpdus_requeued_usr_%u = %u\n", 1696 htt_stats_buf->user_index, 1697 htt_stats_buf->mpdus_requeued_usr); 1698 len += scnprintf(buf + len, buf_len - len, 1699 "ax_mu_ofdma_err_no_ba_usr_%u = %u\n", 1700 htt_stats_buf->user_index, 1701 htt_stats_buf->err_no_ba_usr); 1702 len += scnprintf(buf + len, buf_len - len, 1703 "ax_mu_ofdma_mpdu_underrun_usr_%u = %u\n", 1704 htt_stats_buf->user_index, 1705 htt_stats_buf->mpdu_underrun_usr); 1706 len += scnprintf(buf + len, buf_len - len, 1707 "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n\n", 1708 htt_stats_buf->user_index, 1709 htt_stats_buf->ampdu_underrun_usr); 1710 } 1711 } 1712 1713 if (len >= buf_len) 1714 buf[buf_len - 1] = 0; 1715 else 1716 buf[len] = 0; 1717 1718 stats_req->buf_len = len; 1719} 1720 1721static inline void 1722htt_print_sched_txq_cmd_posted_tlv_v(const void *tag_buf, 1723 u16 tag_len, 1724 struct debug_htt_stats_req *stats_req) 1725{ 1726 const struct htt_sched_txq_cmd_posted_tlv_v *htt_stats_buf = tag_buf; 1727 u8 *buf = stats_req->buf; 1728 u32 len = stats_req->buf_len; 1729 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1730 u16 num_elements = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_SCHED_TX_MODE_MAX); 1731 1732 len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV_V:\n"); 1733 1734 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_cmd_posted, 1735 "sched_cmd_posted", num_elements, "\n\n"); 1736 1737 if (len >= buf_len) 1738 buf[buf_len - 1] = 0; 1739 else 1740 buf[len] = 0; 1741 1742 stats_req->buf_len = len; 1743} 1744 1745static inline void 1746htt_print_sched_txq_cmd_reaped_tlv_v(const void *tag_buf, 1747 u16 tag_len, 1748 struct debug_htt_stats_req *stats_req) 1749{ 1750 const struct htt_sched_txq_cmd_reaped_tlv_v *htt_stats_buf = tag_buf; 1751 u8 *buf = stats_req->buf; 1752 u32 len = stats_req->buf_len; 1753 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1754 u16 num_elements = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_SCHED_TX_MODE_MAX); 1755 1756 len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_REAPED_TLV_V:\n"); 1757 1758 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_cmd_reaped, 1759 "sched_cmd_reaped", num_elements, "\n\n"); 1760 1761 if (len >= buf_len) 1762 buf[buf_len - 1] = 0; 1763 else 1764 buf[len] = 0; 1765 1766 stats_req->buf_len = len; 1767} 1768 1769static inline void 1770htt_print_sched_txq_sched_order_su_tlv_v(const void *tag_buf, 1771 u16 tag_len, 1772 struct debug_htt_stats_req *stats_req) 1773{ 1774 const struct htt_sched_txq_sched_order_su_tlv_v *htt_stats_buf = tag_buf; 1775 u8 *buf = stats_req->buf; 1776 u32 len = stats_req->buf_len; 1777 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1778 /* each entry is u32, i.e. 4 bytes */ 1779 u32 sched_order_su_num_entries = 1780 min_t(u32, (tag_len >> 2), HTT_TX_PDEV_NUM_SCHED_ORDER_LOG); 1781 1782 len += scnprintf(buf + len, buf_len - len, 1783 "HTT_SCHED_TXQ_SCHED_ORDER_SU_TLV_V:\n"); 1784 1785 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_order_su, "sched_order_su", 1786 sched_order_su_num_entries, "\n\n"); 1787 1788 if (len >= buf_len) 1789 buf[buf_len - 1] = 0; 1790 else 1791 buf[len] = 0; 1792 1793 stats_req->buf_len = len; 1794} 1795 1796static inline void 1797htt_print_sched_txq_sched_ineligibility_tlv_v(const void *tag_buf, 1798 u16 tag_len, 1799 struct debug_htt_stats_req *stats_req) 1800{ 1801 const struct htt_sched_txq_sched_ineligibility_tlv_v *htt_stats_buf = tag_buf; 1802 u8 *buf = stats_req->buf; 1803 u32 len = stats_req->buf_len; 1804 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1805 /* each entry is u32, i.e. 4 bytes */ 1806 u32 sched_ineligibility_num_entries = tag_len >> 2; 1807 1808 len += scnprintf(buf + len, buf_len - len, 1809 "HTT_SCHED_TXQ_SCHED_INELIGIBILITY_V:\n"); 1810 1811 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_ineligibility, 1812 "sched_ineligibility", sched_ineligibility_num_entries, 1813 "\n\n"); 1814 1815 if (len >= buf_len) 1816 buf[buf_len - 1] = 0; 1817 else 1818 buf[len] = 0; 1819 1820 stats_req->buf_len = len; 1821} 1822 1823static inline void 1824htt_print_tx_pdev_stats_sched_per_txq_tlv(const void *tag_buf, 1825 struct debug_htt_stats_req *stats_req) 1826{ 1827 const struct htt_tx_pdev_stats_sched_per_txq_tlv *htt_stats_buf = tag_buf; 1828 u8 *buf = stats_req->buf; 1829 u32 len = stats_req->buf_len; 1830 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1831 1832 len += scnprintf(buf + len, buf_len - len, 1833 "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:\n"); 1834 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 1835 FIELD_GET(HTT_TX_PDEV_STATS_SCHED_PER_TXQ_MAC_ID, 1836 htt_stats_buf->mac_id__txq_id__word)); 1837 len += scnprintf(buf + len, buf_len - len, "txq_id = %lu\n", 1838 FIELD_GET(HTT_TX_PDEV_STATS_SCHED_PER_TXQ_ID, 1839 htt_stats_buf->mac_id__txq_id__word)); 1840 len += scnprintf(buf + len, buf_len - len, "sched_policy = %u\n", 1841 htt_stats_buf->sched_policy); 1842 len += scnprintf(buf + len, buf_len - len, 1843 "last_sched_cmd_posted_timestamp = %u\n", 1844 htt_stats_buf->last_sched_cmd_posted_timestamp); 1845 len += scnprintf(buf + len, buf_len - len, 1846 "last_sched_cmd_compl_timestamp = %u\n", 1847 htt_stats_buf->last_sched_cmd_compl_timestamp); 1848 len += scnprintf(buf + len, buf_len - len, "sched_2_tac_lwm_count = %u\n", 1849 htt_stats_buf->sched_2_tac_lwm_count); 1850 len += scnprintf(buf + len, buf_len - len, "sched_2_tac_ring_full = %u\n", 1851 htt_stats_buf->sched_2_tac_ring_full); 1852 len += scnprintf(buf + len, buf_len - len, "sched_cmd_post_failure = %u\n", 1853 htt_stats_buf->sched_cmd_post_failure); 1854 len += scnprintf(buf + len, buf_len - len, "num_active_tids = %u\n", 1855 htt_stats_buf->num_active_tids); 1856 len += scnprintf(buf + len, buf_len - len, "num_ps_schedules = %u\n", 1857 htt_stats_buf->num_ps_schedules); 1858 len += scnprintf(buf + len, buf_len - len, "sched_cmds_pending = %u\n", 1859 htt_stats_buf->sched_cmds_pending); 1860 len += scnprintf(buf + len, buf_len - len, "num_tid_register = %u\n", 1861 htt_stats_buf->num_tid_register); 1862 len += scnprintf(buf + len, buf_len - len, "num_tid_unregister = %u\n", 1863 htt_stats_buf->num_tid_unregister); 1864 len += scnprintf(buf + len, buf_len - len, "num_qstats_queried = %u\n", 1865 htt_stats_buf->num_qstats_queried); 1866 len += scnprintf(buf + len, buf_len - len, "qstats_update_pending = %u\n", 1867 htt_stats_buf->qstats_update_pending); 1868 len += scnprintf(buf + len, buf_len - len, "last_qstats_query_timestamp = %u\n", 1869 htt_stats_buf->last_qstats_query_timestamp); 1870 len += scnprintf(buf + len, buf_len - len, "num_tqm_cmdq_full = %u\n", 1871 htt_stats_buf->num_tqm_cmdq_full); 1872 len += scnprintf(buf + len, buf_len - len, "num_de_sched_algo_trigger = %u\n", 1873 htt_stats_buf->num_de_sched_algo_trigger); 1874 len += scnprintf(buf + len, buf_len - len, "num_rt_sched_algo_trigger = %u\n", 1875 htt_stats_buf->num_rt_sched_algo_trigger); 1876 len += scnprintf(buf + len, buf_len - len, "num_tqm_sched_algo_trigger = %u\n", 1877 htt_stats_buf->num_tqm_sched_algo_trigger); 1878 len += scnprintf(buf + len, buf_len - len, "notify_sched = %u\n\n", 1879 htt_stats_buf->notify_sched); 1880 len += scnprintf(buf + len, buf_len - len, "dur_based_sendn_term = %u\n\n", 1881 htt_stats_buf->dur_based_sendn_term); 1882 1883 if (len >= buf_len) 1884 buf[buf_len - 1] = 0; 1885 else 1886 buf[len] = 0; 1887 1888 stats_req->buf_len = len; 1889} 1890 1891static inline void htt_print_stats_tx_sched_cmn_tlv(const void *tag_buf, 1892 struct debug_htt_stats_req *stats_req) 1893{ 1894 const struct htt_stats_tx_sched_cmn_tlv *htt_stats_buf = tag_buf; 1895 u8 *buf = stats_req->buf; 1896 u32 len = stats_req->buf_len; 1897 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1898 1899 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_TX_SCHED_CMN_TLV:\n"); 1900 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 1901 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 1902 len += scnprintf(buf + len, buf_len - len, "current_timestamp = %u\n\n", 1903 htt_stats_buf->current_timestamp); 1904 1905 if (len >= buf_len) 1906 buf[buf_len - 1] = 0; 1907 else 1908 buf[len] = 0; 1909 1910 stats_req->buf_len = len; 1911} 1912 1913static inline void 1914htt_print_tx_tqm_gen_mpdu_stats_tlv_v(const void *tag_buf, 1915 u16 tag_len, 1916 struct debug_htt_stats_req *stats_req) 1917{ 1918 const struct htt_tx_tqm_gen_mpdu_stats_tlv_v *htt_stats_buf = tag_buf; 1919 u8 *buf = stats_req->buf; 1920 u32 len = stats_req->buf_len; 1921 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1922 u16 num_elements = min_t(u16, (tag_len >> 2), 1923 HTT_TX_TQM_MAX_LIST_MPDU_END_REASON); 1924 1925 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_GEN_MPDU_STATS_TLV_V:\n"); 1926 1927 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->gen_mpdu_end_reason, 1928 "gen_mpdu_end_reason", num_elements, "\n\n"); 1929 1930 if (len >= buf_len) 1931 buf[buf_len - 1] = 0; 1932 else 1933 buf[len] = 0; 1934 1935 stats_req->buf_len = len; 1936} 1937 1938static inline void 1939htt_print_tx_tqm_list_mpdu_stats_tlv_v(const void *tag_buf, 1940 u16 tag_len, 1941 struct debug_htt_stats_req *stats_req) 1942{ 1943 const struct htt_tx_tqm_list_mpdu_stats_tlv_v *htt_stats_buf = tag_buf; 1944 u8 *buf = stats_req->buf; 1945 u32 len = stats_req->buf_len; 1946 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1947 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_TQM_MAX_LIST_MPDU_END_REASON); 1948 1949 len += scnprintf(buf + len, buf_len - len, 1950 "HTT_TX_TQM_LIST_MPDU_STATS_TLV_V:\n"); 1951 1952 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->list_mpdu_end_reason, 1953 "list_mpdu_end_reason", num_elems, "\n\n"); 1954 1955 if (len >= buf_len) 1956 buf[buf_len - 1] = 0; 1957 else 1958 buf[len] = 0; 1959 1960 stats_req->buf_len = len; 1961} 1962 1963static inline void 1964htt_print_tx_tqm_list_mpdu_cnt_tlv_v(const void *tag_buf, 1965 u16 tag_len, 1966 struct debug_htt_stats_req *stats_req) 1967{ 1968 const struct htt_tx_tqm_list_mpdu_cnt_tlv_v *htt_stats_buf = tag_buf; 1969 u8 *buf = stats_req->buf; 1970 u32 len = stats_req->buf_len; 1971 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1972 u16 num_elems = min_t(u16, (tag_len >> 2), 1973 HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS); 1974 1975 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:\n"); 1976 1977 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->list_mpdu_cnt_hist, 1978 "list_mpdu_cnt_hist", num_elems, "\n\n"); 1979 1980 if (len >= buf_len) 1981 buf[buf_len - 1] = 0; 1982 else 1983 buf[len] = 0; 1984 1985 stats_req->buf_len = len; 1986} 1987 1988static inline void 1989htt_print_tx_tqm_pdev_stats_tlv_v(const void *tag_buf, 1990 struct debug_htt_stats_req *stats_req) 1991{ 1992 const struct htt_tx_tqm_pdev_stats_tlv_v *htt_stats_buf = tag_buf; 1993 u8 *buf = stats_req->buf; 1994 u32 len = stats_req->buf_len; 1995 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 1996 1997 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_PDEV_STATS_TLV_V:\n"); 1998 len += scnprintf(buf + len, buf_len - len, "msdu_count = %u\n", 1999 htt_stats_buf->msdu_count); 2000 len += scnprintf(buf + len, buf_len - len, "mpdu_count = %u\n", 2001 htt_stats_buf->mpdu_count); 2002 len += scnprintf(buf + len, buf_len - len, "remove_msdu = %u\n", 2003 htt_stats_buf->remove_msdu); 2004 len += scnprintf(buf + len, buf_len - len, "remove_mpdu = %u\n", 2005 htt_stats_buf->remove_mpdu); 2006 len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl = %u\n", 2007 htt_stats_buf->remove_msdu_ttl); 2008 len += scnprintf(buf + len, buf_len - len, "send_bar = %u\n", 2009 htt_stats_buf->send_bar); 2010 len += scnprintf(buf + len, buf_len - len, "bar_sync = %u\n", 2011 htt_stats_buf->bar_sync); 2012 len += scnprintf(buf + len, buf_len - len, "notify_mpdu = %u\n", 2013 htt_stats_buf->notify_mpdu); 2014 len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n", 2015 htt_stats_buf->sync_cmd); 2016 len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n", 2017 htt_stats_buf->write_cmd); 2018 len += scnprintf(buf + len, buf_len - len, "hwsch_trigger = %u\n", 2019 htt_stats_buf->hwsch_trigger); 2020 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 2021 htt_stats_buf->ack_tlv_proc); 2022 len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n", 2023 htt_stats_buf->gen_mpdu_cmd); 2024 len += scnprintf(buf + len, buf_len - len, "gen_list_cmd = %u\n", 2025 htt_stats_buf->gen_list_cmd); 2026 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n", 2027 htt_stats_buf->remove_mpdu_cmd); 2028 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_tried_cmd = %u\n", 2029 htt_stats_buf->remove_mpdu_tried_cmd); 2030 len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n", 2031 htt_stats_buf->mpdu_queue_stats_cmd); 2032 len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n", 2033 htt_stats_buf->mpdu_head_info_cmd); 2034 len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n", 2035 htt_stats_buf->msdu_flow_stats_cmd); 2036 len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n", 2037 htt_stats_buf->remove_msdu_cmd); 2038 len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl_cmd = %u\n", 2039 htt_stats_buf->remove_msdu_ttl_cmd); 2040 len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n", 2041 htt_stats_buf->flush_cache_cmd); 2042 len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n", 2043 htt_stats_buf->update_mpduq_cmd); 2044 len += scnprintf(buf + len, buf_len - len, "enqueue = %u\n", 2045 htt_stats_buf->enqueue); 2046 len += scnprintf(buf + len, buf_len - len, "enqueue_notify = %u\n", 2047 htt_stats_buf->enqueue_notify); 2048 len += scnprintf(buf + len, buf_len - len, "notify_mpdu_at_head = %u\n", 2049 htt_stats_buf->notify_mpdu_at_head); 2050 len += scnprintf(buf + len, buf_len - len, "notify_mpdu_state_valid = %u\n", 2051 htt_stats_buf->notify_mpdu_state_valid); 2052 len += scnprintf(buf + len, buf_len - len, "sched_udp_notify1 = %u\n", 2053 htt_stats_buf->sched_udp_notify1); 2054 len += scnprintf(buf + len, buf_len - len, "sched_udp_notify2 = %u\n", 2055 htt_stats_buf->sched_udp_notify2); 2056 len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify1 = %u\n", 2057 htt_stats_buf->sched_nonudp_notify1); 2058 len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify2 = %u\n\n", 2059 htt_stats_buf->sched_nonudp_notify2); 2060 2061 if (len >= buf_len) 2062 buf[buf_len - 1] = 0; 2063 else 2064 buf[len] = 0; 2065 2066 stats_req->buf_len = len; 2067} 2068 2069static inline void htt_print_tx_tqm_cmn_stats_tlv(const void *tag_buf, 2070 struct debug_htt_stats_req *stats_req) 2071{ 2072 const struct htt_tx_tqm_cmn_stats_tlv *htt_stats_buf = tag_buf; 2073 u8 *buf = stats_req->buf; 2074 u32 len = stats_req->buf_len; 2075 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2076 2077 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMN_STATS_TLV:\n"); 2078 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2079 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 2080 len += scnprintf(buf + len, buf_len - len, "max_cmdq_id = %u\n", 2081 htt_stats_buf->max_cmdq_id); 2082 len += scnprintf(buf + len, buf_len - len, "list_mpdu_cnt_hist_intvl = %u\n", 2083 htt_stats_buf->list_mpdu_cnt_hist_intvl); 2084 len += scnprintf(buf + len, buf_len - len, "add_msdu = %u\n", 2085 htt_stats_buf->add_msdu); 2086 len += scnprintf(buf + len, buf_len - len, "q_empty = %u\n", 2087 htt_stats_buf->q_empty); 2088 len += scnprintf(buf + len, buf_len - len, "q_not_empty = %u\n", 2089 htt_stats_buf->q_not_empty); 2090 len += scnprintf(buf + len, buf_len - len, "drop_notification = %u\n", 2091 htt_stats_buf->drop_notification); 2092 len += scnprintf(buf + len, buf_len - len, "desc_threshold = %u\n\n", 2093 htt_stats_buf->desc_threshold); 2094 2095 if (len >= buf_len) 2096 buf[buf_len - 1] = 0; 2097 else 2098 buf[len] = 0; 2099 2100 stats_req->buf_len = len; 2101} 2102 2103static inline void htt_print_tx_tqm_error_stats_tlv(const void *tag_buf, 2104 struct debug_htt_stats_req *stats_req) 2105{ 2106 const struct htt_tx_tqm_error_stats_tlv *htt_stats_buf = tag_buf; 2107 u8 *buf = stats_req->buf; 2108 u32 len = stats_req->buf_len; 2109 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2110 2111 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_ERROR_STATS_TLV:\n"); 2112 len += scnprintf(buf + len, buf_len - len, "q_empty_failure = %u\n", 2113 htt_stats_buf->q_empty_failure); 2114 len += scnprintf(buf + len, buf_len - len, "q_not_empty_failure = %u\n", 2115 htt_stats_buf->q_not_empty_failure); 2116 len += scnprintf(buf + len, buf_len - len, "add_msdu_failure = %u\n\n", 2117 htt_stats_buf->add_msdu_failure); 2118 2119 if (len >= buf_len) 2120 buf[buf_len - 1] = 0; 2121 else 2122 buf[len] = 0; 2123 2124 stats_req->buf_len = len; 2125} 2126 2127static inline void htt_print_tx_tqm_cmdq_status_tlv(const void *tag_buf, 2128 struct debug_htt_stats_req *stats_req) 2129{ 2130 const struct htt_tx_tqm_cmdq_status_tlv *htt_stats_buf = tag_buf; 2131 u8 *buf = stats_req->buf; 2132 u32 len = stats_req->buf_len; 2133 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2134 2135 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMDQ_STATUS_TLV:\n"); 2136 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2137 FIELD_GET(HTT_TX_TQM_CMDQ_STATUS_MAC_ID, 2138 htt_stats_buf->mac_id__cmdq_id__word)); 2139 len += scnprintf(buf + len, buf_len - len, "cmdq_id = %lu\n\n", 2140 FIELD_GET(HTT_TX_TQM_CMDQ_STATUS_CMDQ_ID, 2141 htt_stats_buf->mac_id__cmdq_id__word)); 2142 len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n", 2143 htt_stats_buf->sync_cmd); 2144 len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n", 2145 htt_stats_buf->write_cmd); 2146 len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n", 2147 htt_stats_buf->gen_mpdu_cmd); 2148 len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n", 2149 htt_stats_buf->mpdu_queue_stats_cmd); 2150 len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n", 2151 htt_stats_buf->mpdu_head_info_cmd); 2152 len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n", 2153 htt_stats_buf->msdu_flow_stats_cmd); 2154 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n", 2155 htt_stats_buf->remove_mpdu_cmd); 2156 len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n", 2157 htt_stats_buf->remove_msdu_cmd); 2158 len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n", 2159 htt_stats_buf->flush_cache_cmd); 2160 len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n", 2161 htt_stats_buf->update_mpduq_cmd); 2162 len += scnprintf(buf + len, buf_len - len, "update_msduq_cmd = %u\n\n", 2163 htt_stats_buf->update_msduq_cmd); 2164 2165 if (len >= buf_len) 2166 buf[buf_len - 1] = 0; 2167 else 2168 buf[len] = 0; 2169 2170 stats_req->buf_len = len; 2171} 2172 2173static inline void 2174htt_print_tx_de_eapol_packets_stats_tlv(const void *tag_buf, 2175 struct debug_htt_stats_req *stats_req) 2176{ 2177 const struct htt_tx_de_eapol_packets_stats_tlv *htt_stats_buf = tag_buf; 2178 u8 *buf = stats_req->buf; 2179 u32 len = stats_req->buf_len; 2180 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2181 2182 len += scnprintf(buf + len, buf_len - len, 2183 "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:\n"); 2184 len += scnprintf(buf + len, buf_len - len, "m1_packets = %u\n", 2185 htt_stats_buf->m1_packets); 2186 len += scnprintf(buf + len, buf_len - len, "m2_packets = %u\n", 2187 htt_stats_buf->m2_packets); 2188 len += scnprintf(buf + len, buf_len - len, "m3_packets = %u\n", 2189 htt_stats_buf->m3_packets); 2190 len += scnprintf(buf + len, buf_len - len, "m4_packets = %u\n", 2191 htt_stats_buf->m4_packets); 2192 len += scnprintf(buf + len, buf_len - len, "g1_packets = %u\n", 2193 htt_stats_buf->g1_packets); 2194 len += scnprintf(buf + len, buf_len - len, "g2_packets = %u\n\n", 2195 htt_stats_buf->g2_packets); 2196 2197 if (len >= buf_len) 2198 buf[buf_len - 1] = 0; 2199 else 2200 buf[len] = 0; 2201 2202 stats_req->buf_len = len; 2203} 2204 2205static inline void 2206htt_print_tx_de_classify_failed_stats_tlv(const void *tag_buf, 2207 struct debug_htt_stats_req *stats_req) 2208{ 2209 const struct htt_tx_de_classify_failed_stats_tlv *htt_stats_buf = tag_buf; 2210 u8 *buf = stats_req->buf; 2211 u32 len = stats_req->buf_len; 2212 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2213 2214 len += scnprintf(buf + len, buf_len - len, 2215 "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:\n"); 2216 len += scnprintf(buf + len, buf_len - len, "ap_bss_peer_not_found = %u\n", 2217 htt_stats_buf->ap_bss_peer_not_found); 2218 len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_no_peer = %u\n", 2219 htt_stats_buf->ap_bcast_mcast_no_peer); 2220 len += scnprintf(buf + len, buf_len - len, "sta_delete_in_progress = %u\n", 2221 htt_stats_buf->sta_delete_in_progress); 2222 len += scnprintf(buf + len, buf_len - len, "ibss_no_bss_peer = %u\n", 2223 htt_stats_buf->ibss_no_bss_peer); 2224 len += scnprintf(buf + len, buf_len - len, "invalid_vdev_type = %u\n", 2225 htt_stats_buf->invalid_vdev_type); 2226 len += scnprintf(buf + len, buf_len - len, "invalid_ast_peer_entry = %u\n", 2227 htt_stats_buf->invalid_ast_peer_entry); 2228 len += scnprintf(buf + len, buf_len - len, "peer_entry_invalid = %u\n", 2229 htt_stats_buf->peer_entry_invalid); 2230 len += scnprintf(buf + len, buf_len - len, "ethertype_not_ip = %u\n", 2231 htt_stats_buf->ethertype_not_ip); 2232 len += scnprintf(buf + len, buf_len - len, "eapol_lookup_failed = %u\n", 2233 htt_stats_buf->eapol_lookup_failed); 2234 len += scnprintf(buf + len, buf_len - len, "qpeer_not_allow_data = %u\n", 2235 htt_stats_buf->qpeer_not_allow_data); 2236 len += scnprintf(buf + len, buf_len - len, "fse_tid_override = %u\n", 2237 htt_stats_buf->fse_tid_override); 2238 len += scnprintf(buf + len, buf_len - len, "ipv6_jumbogram_zero_length = %u\n", 2239 htt_stats_buf->ipv6_jumbogram_zero_length); 2240 len += scnprintf(buf + len, buf_len - len, "qos_to_non_qos_in_prog = %u\n\n", 2241 htt_stats_buf->qos_to_non_qos_in_prog); 2242 2243 if (len >= buf_len) 2244 buf[buf_len - 1] = 0; 2245 else 2246 buf[len] = 0; 2247 2248 stats_req->buf_len = len; 2249} 2250 2251static inline void 2252htt_print_tx_de_classify_stats_tlv(const void *tag_buf, 2253 struct debug_htt_stats_req *stats_req) 2254{ 2255 const struct htt_tx_de_classify_stats_tlv *htt_stats_buf = tag_buf; 2256 u8 *buf = stats_req->buf; 2257 u32 len = stats_req->buf_len; 2258 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2259 2260 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CLASSIFY_STATS_TLV:\n"); 2261 len += scnprintf(buf + len, buf_len - len, "arp_packets = %u\n", 2262 htt_stats_buf->arp_packets); 2263 len += scnprintf(buf + len, buf_len - len, "igmp_packets = %u\n", 2264 htt_stats_buf->igmp_packets); 2265 len += scnprintf(buf + len, buf_len - len, "dhcp_packets = %u\n", 2266 htt_stats_buf->dhcp_packets); 2267 len += scnprintf(buf + len, buf_len - len, "host_inspected = %u\n", 2268 htt_stats_buf->host_inspected); 2269 len += scnprintf(buf + len, buf_len - len, "htt_included = %u\n", 2270 htt_stats_buf->htt_included); 2271 len += scnprintf(buf + len, buf_len - len, "htt_valid_mcs = %u\n", 2272 htt_stats_buf->htt_valid_mcs); 2273 len += scnprintf(buf + len, buf_len - len, "htt_valid_nss = %u\n", 2274 htt_stats_buf->htt_valid_nss); 2275 len += scnprintf(buf + len, buf_len - len, "htt_valid_preamble_type = %u\n", 2276 htt_stats_buf->htt_valid_preamble_type); 2277 len += scnprintf(buf + len, buf_len - len, "htt_valid_chainmask = %u\n", 2278 htt_stats_buf->htt_valid_chainmask); 2279 len += scnprintf(buf + len, buf_len - len, "htt_valid_guard_interval = %u\n", 2280 htt_stats_buf->htt_valid_guard_interval); 2281 len += scnprintf(buf + len, buf_len - len, "htt_valid_retries = %u\n", 2282 htt_stats_buf->htt_valid_retries); 2283 len += scnprintf(buf + len, buf_len - len, "htt_valid_bw_info = %u\n", 2284 htt_stats_buf->htt_valid_bw_info); 2285 len += scnprintf(buf + len, buf_len - len, "htt_valid_power = %u\n", 2286 htt_stats_buf->htt_valid_power); 2287 len += scnprintf(buf + len, buf_len - len, "htt_valid_key_flags = 0x%x\n", 2288 htt_stats_buf->htt_valid_key_flags); 2289 len += scnprintf(buf + len, buf_len - len, "htt_valid_no_encryption = %u\n", 2290 htt_stats_buf->htt_valid_no_encryption); 2291 len += scnprintf(buf + len, buf_len - len, "fse_entry_count = %u\n", 2292 htt_stats_buf->fse_entry_count); 2293 len += scnprintf(buf + len, buf_len - len, "fse_priority_be = %u\n", 2294 htt_stats_buf->fse_priority_be); 2295 len += scnprintf(buf + len, buf_len - len, "fse_priority_high = %u\n", 2296 htt_stats_buf->fse_priority_high); 2297 len += scnprintf(buf + len, buf_len - len, "fse_priority_low = %u\n", 2298 htt_stats_buf->fse_priority_low); 2299 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_be = %u\n", 2300 htt_stats_buf->fse_traffic_ptrn_be); 2301 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_over_sub = %u\n", 2302 htt_stats_buf->fse_traffic_ptrn_over_sub); 2303 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_bursty = %u\n", 2304 htt_stats_buf->fse_traffic_ptrn_bursty); 2305 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_interactive = %u\n", 2306 htt_stats_buf->fse_traffic_ptrn_interactive); 2307 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_periodic = %u\n", 2308 htt_stats_buf->fse_traffic_ptrn_periodic); 2309 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_alloc = %u\n", 2310 htt_stats_buf->fse_hwqueue_alloc); 2311 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_created = %u\n", 2312 htt_stats_buf->fse_hwqueue_created); 2313 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_send_to_host = %u\n", 2314 htt_stats_buf->fse_hwqueue_send_to_host); 2315 len += scnprintf(buf + len, buf_len - len, "mcast_entry = %u\n", 2316 htt_stats_buf->mcast_entry); 2317 len += scnprintf(buf + len, buf_len - len, "bcast_entry = %u\n", 2318 htt_stats_buf->bcast_entry); 2319 len += scnprintf(buf + len, buf_len - len, "htt_update_peer_cache = %u\n", 2320 htt_stats_buf->htt_update_peer_cache); 2321 len += scnprintf(buf + len, buf_len - len, "htt_learning_frame = %u\n", 2322 htt_stats_buf->htt_learning_frame); 2323 len += scnprintf(buf + len, buf_len - len, "fse_invalid_peer = %u\n", 2324 htt_stats_buf->fse_invalid_peer); 2325 len += scnprintf(buf + len, buf_len - len, "mec_notify = %u\n\n", 2326 htt_stats_buf->mec_notify); 2327 2328 if (len >= buf_len) 2329 buf[buf_len - 1] = 0; 2330 else 2331 buf[len] = 0; 2332 2333 stats_req->buf_len = len; 2334} 2335 2336static inline void 2337htt_print_tx_de_classify_status_stats_tlv(const void *tag_buf, 2338 struct debug_htt_stats_req *stats_req) 2339{ 2340 const struct htt_tx_de_classify_status_stats_tlv *htt_stats_buf = tag_buf; 2341 u8 *buf = stats_req->buf; 2342 u32 len = stats_req->buf_len; 2343 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2344 2345 len += scnprintf(buf + len, buf_len - len, 2346 "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:\n"); 2347 len += scnprintf(buf + len, buf_len - len, "eok = %u\n", 2348 htt_stats_buf->eok); 2349 len += scnprintf(buf + len, buf_len - len, "classify_done = %u\n", 2350 htt_stats_buf->classify_done); 2351 len += scnprintf(buf + len, buf_len - len, "lookup_failed = %u\n", 2352 htt_stats_buf->lookup_failed); 2353 len += scnprintf(buf + len, buf_len - len, "send_host_dhcp = %u\n", 2354 htt_stats_buf->send_host_dhcp); 2355 len += scnprintf(buf + len, buf_len - len, "send_host_mcast = %u\n", 2356 htt_stats_buf->send_host_mcast); 2357 len += scnprintf(buf + len, buf_len - len, "send_host_unknown_dest = %u\n", 2358 htt_stats_buf->send_host_unknown_dest); 2359 len += scnprintf(buf + len, buf_len - len, "send_host = %u\n", 2360 htt_stats_buf->send_host); 2361 len += scnprintf(buf + len, buf_len - len, "status_invalid = %u\n\n", 2362 htt_stats_buf->status_invalid); 2363 2364 if (len >= buf_len) 2365 buf[buf_len - 1] = 0; 2366 else 2367 buf[len] = 0; 2368 2369 stats_req->buf_len = len; 2370} 2371 2372static inline void 2373htt_print_tx_de_enqueue_packets_stats_tlv(const void *tag_buf, 2374 struct debug_htt_stats_req *stats_req) 2375{ 2376 const struct htt_tx_de_enqueue_packets_stats_tlv *htt_stats_buf = tag_buf; 2377 u8 *buf = stats_req->buf; 2378 u32 len = stats_req->buf_len; 2379 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2380 2381 len += scnprintf(buf + len, buf_len - len, 2382 "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:\n"); 2383 len += scnprintf(buf + len, buf_len - len, "enqueued_pkts = %u\n", 2384 htt_stats_buf->enqueued_pkts); 2385 len += scnprintf(buf + len, buf_len - len, "to_tqm = %u\n", 2386 htt_stats_buf->to_tqm); 2387 len += scnprintf(buf + len, buf_len - len, "to_tqm_bypass = %u\n\n", 2388 htt_stats_buf->to_tqm_bypass); 2389 2390 if (len >= buf_len) 2391 buf[buf_len - 1] = 0; 2392 else 2393 buf[len] = 0; 2394 2395 stats_req->buf_len = len; 2396} 2397 2398static inline void 2399htt_print_tx_de_enqueue_discard_stats_tlv(const void *tag_buf, 2400 struct debug_htt_stats_req *stats_req) 2401{ 2402 const struct htt_tx_de_enqueue_discard_stats_tlv *htt_stats_buf = tag_buf; 2403 u8 *buf = stats_req->buf; 2404 u32 len = stats_req->buf_len; 2405 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2406 2407 len += scnprintf(buf + len, buf_len - len, 2408 "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:\n"); 2409 len += scnprintf(buf + len, buf_len - len, "discarded_pkts = %u\n", 2410 htt_stats_buf->discarded_pkts); 2411 len += scnprintf(buf + len, buf_len - len, "local_frames = %u\n", 2412 htt_stats_buf->local_frames); 2413 len += scnprintf(buf + len, buf_len - len, "is_ext_msdu = %u\n\n", 2414 htt_stats_buf->is_ext_msdu); 2415 2416 if (len >= buf_len) 2417 buf[buf_len - 1] = 0; 2418 else 2419 buf[len] = 0; 2420 2421 stats_req->buf_len = len; 2422} 2423 2424static inline void htt_print_tx_de_compl_stats_tlv(const void *tag_buf, 2425 struct debug_htt_stats_req *stats_req) 2426{ 2427 const struct htt_tx_de_compl_stats_tlv *htt_stats_buf = tag_buf; 2428 u8 *buf = stats_req->buf; 2429 u32 len = stats_req->buf_len; 2430 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2431 2432 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_COMPL_STATS_TLV:\n"); 2433 len += scnprintf(buf + len, buf_len - len, "tcl_dummy_frame = %u\n", 2434 htt_stats_buf->tcl_dummy_frame); 2435 len += scnprintf(buf + len, buf_len - len, "tqm_dummy_frame = %u\n", 2436 htt_stats_buf->tqm_dummy_frame); 2437 len += scnprintf(buf + len, buf_len - len, "tqm_notify_frame = %u\n", 2438 htt_stats_buf->tqm_notify_frame); 2439 len += scnprintf(buf + len, buf_len - len, "fw2wbm_enq = %u\n", 2440 htt_stats_buf->fw2wbm_enq); 2441 len += scnprintf(buf + len, buf_len - len, "tqm_bypass_frame = %u\n\n", 2442 htt_stats_buf->tqm_bypass_frame); 2443 2444 if (len >= buf_len) 2445 buf[buf_len - 1] = 0; 2446 else 2447 buf[len] = 0; 2448 2449 stats_req->buf_len = len; 2450} 2451 2452static inline void 2453htt_print_tx_de_fw2wbm_ring_full_hist_tlv(const void *tag_buf, 2454 u16 tag_len, 2455 struct debug_htt_stats_req *stats_req) 2456{ 2457 const struct htt_tx_de_fw2wbm_ring_full_hist_tlv *htt_stats_buf = tag_buf; 2458 u8 *buf = stats_req->buf; 2459 u32 len = stats_req->buf_len; 2460 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2461 u16 num_elements = tag_len >> 2; 2462 2463 len += scnprintf(buf + len, buf_len - len, 2464 "HTT_TX_DE_FW2WBM_RING_FULL_HIST_TLV"); 2465 2466 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw2wbm_ring_full_hist, 2467 "fw2wbm_ring_full_hist", num_elements, "\n\n"); 2468 2469 if (len >= buf_len) 2470 buf[buf_len - 1] = 0; 2471 else 2472 buf[len] = 0; 2473 2474 stats_req->buf_len = len; 2475} 2476 2477static inline void 2478htt_print_tx_de_cmn_stats_tlv(const void *tag_buf, struct debug_htt_stats_req *stats_req) 2479{ 2480 const struct htt_tx_de_cmn_stats_tlv *htt_stats_buf = tag_buf; 2481 u8 *buf = stats_req->buf; 2482 u32 len = stats_req->buf_len; 2483 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2484 2485 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CMN_STATS_TLV:\n"); 2486 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2487 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 2488 len += scnprintf(buf + len, buf_len - len, "tcl2fw_entry_count = %u\n", 2489 htt_stats_buf->tcl2fw_entry_count); 2490 len += scnprintf(buf + len, buf_len - len, "not_to_fw = %u\n", 2491 htt_stats_buf->not_to_fw); 2492 len += scnprintf(buf + len, buf_len - len, "invalid_pdev_vdev_peer = %u\n", 2493 htt_stats_buf->invalid_pdev_vdev_peer); 2494 len += scnprintf(buf + len, buf_len - len, "tcl_res_invalid_addrx = %u\n", 2495 htt_stats_buf->tcl_res_invalid_addrx); 2496 len += scnprintf(buf + len, buf_len - len, "wbm2fw_entry_count = %u\n", 2497 htt_stats_buf->wbm2fw_entry_count); 2498 len += scnprintf(buf + len, buf_len - len, "invalid_pdev = %u\n\n", 2499 htt_stats_buf->invalid_pdev); 2500 2501 if (len >= buf_len) 2502 buf[buf_len - 1] = 0; 2503 else 2504 buf[len] = 0; 2505 2506 stats_req->buf_len = len; 2507} 2508 2509static inline void htt_print_ring_if_stats_tlv(const void *tag_buf, 2510 struct debug_htt_stats_req *stats_req) 2511{ 2512 const struct htt_ring_if_stats_tlv *htt_stats_buf = tag_buf; 2513 u8 *buf = stats_req->buf; 2514 u32 len = stats_req->buf_len; 2515 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2516 2517 len += scnprintf(buf + len, buf_len - len, "HTT_RING_IF_STATS_TLV:\n"); 2518 len += scnprintf(buf + len, buf_len - len, "base_addr = %u\n", 2519 htt_stats_buf->base_addr); 2520 len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n", 2521 htt_stats_buf->elem_size); 2522 len += scnprintf(buf + len, buf_len - len, "num_elems = %lu\n", 2523 FIELD_GET(HTT_RING_IF_STATS_NUM_ELEMS, 2524 htt_stats_buf->num_elems__prefetch_tail_idx)); 2525 len += scnprintf(buf + len, buf_len - len, "prefetch_tail_idx = %lu\n", 2526 FIELD_GET(HTT_RING_IF_STATS_PREFETCH_TAIL_INDEX, 2527 htt_stats_buf->num_elems__prefetch_tail_idx)); 2528 len += scnprintf(buf + len, buf_len - len, "head_idx = %lu\n", 2529 FIELD_GET(HTT_RING_IF_STATS_HEAD_IDX, 2530 htt_stats_buf->head_idx__tail_idx)); 2531 len += scnprintf(buf + len, buf_len - len, "tail_idx = %lu\n", 2532 FIELD_GET(HTT_RING_IF_STATS_TAIL_IDX, 2533 htt_stats_buf->head_idx__tail_idx)); 2534 len += scnprintf(buf + len, buf_len - len, "shadow_head_idx = %lu\n", 2535 FIELD_GET(HTT_RING_IF_STATS_SHADOW_HEAD_IDX, 2536 htt_stats_buf->shadow_head_idx__shadow_tail_idx)); 2537 len += scnprintf(buf + len, buf_len - len, "shadow_tail_idx = %lu\n", 2538 FIELD_GET(HTT_RING_IF_STATS_SHADOW_TAIL_IDX, 2539 htt_stats_buf->shadow_head_idx__shadow_tail_idx)); 2540 len += scnprintf(buf + len, buf_len - len, "num_tail_incr = %u\n", 2541 htt_stats_buf->num_tail_incr); 2542 len += scnprintf(buf + len, buf_len - len, "lwm_thresh = %lu\n", 2543 FIELD_GET(HTT_RING_IF_STATS_LWM_THRESH, 2544 htt_stats_buf->lwm_thresh__hwm_thresh)); 2545 len += scnprintf(buf + len, buf_len - len, "hwm_thresh = %lu\n", 2546 FIELD_GET(HTT_RING_IF_STATS_HWM_THRESH, 2547 htt_stats_buf->lwm_thresh__hwm_thresh)); 2548 len += scnprintf(buf + len, buf_len - len, "overrun_hit_count = %u\n", 2549 htt_stats_buf->overrun_hit_count); 2550 len += scnprintf(buf + len, buf_len - len, "underrun_hit_count = %u\n", 2551 htt_stats_buf->underrun_hit_count); 2552 len += scnprintf(buf + len, buf_len - len, "prod_blockwait_count = %u\n", 2553 htt_stats_buf->prod_blockwait_count); 2554 len += scnprintf(buf + len, buf_len - len, "cons_blockwait_count = %u\n", 2555 htt_stats_buf->cons_blockwait_count); 2556 2557 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->low_wm_hit_count, 2558 "low_wm_hit_count", HTT_STATS_LOW_WM_BINS, "\n"); 2559 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->high_wm_hit_count, 2560 "high_wm_hit_count", HTT_STATS_HIGH_WM_BINS, "\n\n"); 2561 2562 if (len >= buf_len) 2563 buf[buf_len - 1] = 0; 2564 else 2565 buf[len] = 0; 2566 2567 stats_req->buf_len = len; 2568} 2569 2570static inline void htt_print_ring_if_cmn_tlv(const void *tag_buf, 2571 struct debug_htt_stats_req *stats_req) 2572{ 2573 const struct htt_ring_if_cmn_tlv *htt_stats_buf = tag_buf; 2574 u8 *buf = stats_req->buf; 2575 u32 len = stats_req->buf_len; 2576 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2577 2578 len += scnprintf(buf + len, buf_len - len, "HTT_RING_IF_CMN_TLV:\n"); 2579 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2580 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 2581 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n", 2582 htt_stats_buf->num_records); 2583 2584 if (len >= buf_len) 2585 buf[buf_len - 1] = 0; 2586 else 2587 buf[len] = 0; 2588 2589 stats_req->buf_len = len; 2590} 2591 2592static inline void htt_print_sfm_client_user_tlv_v(const void *tag_buf, 2593 u16 tag_len, 2594 struct debug_htt_stats_req *stats_req) 2595{ 2596 const struct htt_sfm_client_user_tlv_v *htt_stats_buf = tag_buf; 2597 u8 *buf = stats_req->buf; 2598 u32 len = stats_req->buf_len; 2599 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2600 u16 num_elems = tag_len >> 2; 2601 2602 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_USER_TLV_V:\n"); 2603 2604 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->dwords_used_by_user_n, 2605 "dwords_used_by_user_n", num_elems, "\n\n"); 2606 2607 if (len >= buf_len) 2608 buf[buf_len - 1] = 0; 2609 else 2610 buf[len] = 0; 2611 2612 stats_req->buf_len = len; 2613} 2614 2615static inline void htt_print_sfm_client_tlv(const void *tag_buf, 2616 struct debug_htt_stats_req *stats_req) 2617{ 2618 const struct htt_sfm_client_tlv *htt_stats_buf = tag_buf; 2619 u8 *buf = stats_req->buf; 2620 u32 len = stats_req->buf_len; 2621 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2622 2623 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_TLV:\n"); 2624 len += scnprintf(buf + len, buf_len - len, "client_id = %u\n", 2625 htt_stats_buf->client_id); 2626 len += scnprintf(buf + len, buf_len - len, "buf_min = %u\n", 2627 htt_stats_buf->buf_min); 2628 len += scnprintf(buf + len, buf_len - len, "buf_max = %u\n", 2629 htt_stats_buf->buf_max); 2630 len += scnprintf(buf + len, buf_len - len, "buf_busy = %u\n", 2631 htt_stats_buf->buf_busy); 2632 len += scnprintf(buf + len, buf_len - len, "buf_alloc = %u\n", 2633 htt_stats_buf->buf_alloc); 2634 len += scnprintf(buf + len, buf_len - len, "buf_avail = %u\n", 2635 htt_stats_buf->buf_avail); 2636 len += scnprintf(buf + len, buf_len - len, "num_users = %u\n\n", 2637 htt_stats_buf->num_users); 2638 2639 if (len >= buf_len) 2640 buf[buf_len - 1] = 0; 2641 else 2642 buf[len] = 0; 2643 2644 stats_req->buf_len = len; 2645} 2646 2647static inline void htt_print_sfm_cmn_tlv(const void *tag_buf, 2648 struct debug_htt_stats_req *stats_req) 2649{ 2650 const struct htt_sfm_cmn_tlv *htt_stats_buf = tag_buf; 2651 u8 *buf = stats_req->buf; 2652 u32 len = stats_req->buf_len; 2653 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2654 2655 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CMN_TLV:\n"); 2656 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2657 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 2658 len += scnprintf(buf + len, buf_len - len, "buf_total = %u\n", 2659 htt_stats_buf->buf_total); 2660 len += scnprintf(buf + len, buf_len - len, "mem_empty = %u\n", 2661 htt_stats_buf->mem_empty); 2662 len += scnprintf(buf + len, buf_len - len, "deallocate_bufs = %u\n", 2663 htt_stats_buf->deallocate_bufs); 2664 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n", 2665 htt_stats_buf->num_records); 2666 2667 if (len >= buf_len) 2668 buf[buf_len - 1] = 0; 2669 else 2670 buf[len] = 0; 2671 2672 stats_req->buf_len = len; 2673} 2674 2675static inline void htt_print_sring_stats_tlv(const void *tag_buf, 2676 struct debug_htt_stats_req *stats_req) 2677{ 2678 const struct htt_sring_stats_tlv *htt_stats_buf = tag_buf; 2679 u8 *buf = stats_req->buf; 2680 u32 len = stats_req->buf_len; 2681 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2682 2683 len += scnprintf(buf + len, buf_len - len, "HTT_SRING_STATS_TLV:\n"); 2684 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2685 FIELD_GET(HTT_SRING_STATS_MAC_ID, 2686 htt_stats_buf->mac_id__ring_id__arena__ep)); 2687 len += scnprintf(buf + len, buf_len - len, "ring_id = %lu\n", 2688 FIELD_GET(HTT_SRING_STATS_RING_ID, 2689 htt_stats_buf->mac_id__ring_id__arena__ep)); 2690 len += scnprintf(buf + len, buf_len - len, "arena = %lu\n", 2691 FIELD_GET(HTT_SRING_STATS_ARENA, 2692 htt_stats_buf->mac_id__ring_id__arena__ep)); 2693 len += scnprintf(buf + len, buf_len - len, "ep = %lu\n", 2694 FIELD_GET(HTT_SRING_STATS_EP, 2695 htt_stats_buf->mac_id__ring_id__arena__ep)); 2696 len += scnprintf(buf + len, buf_len - len, "base_addr_lsb = 0x%x\n", 2697 htt_stats_buf->base_addr_lsb); 2698 len += scnprintf(buf + len, buf_len - len, "base_addr_msb = 0x%x\n", 2699 htt_stats_buf->base_addr_msb); 2700 len += scnprintf(buf + len, buf_len - len, "ring_size = %u\n", 2701 htt_stats_buf->ring_size); 2702 len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n", 2703 htt_stats_buf->elem_size); 2704 len += scnprintf(buf + len, buf_len - len, "num_avail_words = %lu\n", 2705 FIELD_GET(HTT_SRING_STATS_NUM_AVAIL_WORDS, 2706 htt_stats_buf->num_avail_words__num_valid_words)); 2707 len += scnprintf(buf + len, buf_len - len, "num_valid_words = %lu\n", 2708 FIELD_GET(HTT_SRING_STATS_NUM_VALID_WORDS, 2709 htt_stats_buf->num_avail_words__num_valid_words)); 2710 len += scnprintf(buf + len, buf_len - len, "head_ptr = %lu\n", 2711 FIELD_GET(HTT_SRING_STATS_HEAD_PTR, 2712 htt_stats_buf->head_ptr__tail_ptr)); 2713 len += scnprintf(buf + len, buf_len - len, "tail_ptr = %lu\n", 2714 FIELD_GET(HTT_SRING_STATS_TAIL_PTR, 2715 htt_stats_buf->head_ptr__tail_ptr)); 2716 len += scnprintf(buf + len, buf_len - len, "consumer_empty = %lu\n", 2717 FIELD_GET(HTT_SRING_STATS_CONSUMER_EMPTY, 2718 htt_stats_buf->consumer_empty__producer_full)); 2719 len += scnprintf(buf + len, buf_len - len, "producer_full = %lu\n", 2720 FIELD_GET(HTT_SRING_STATS_PRODUCER_FULL, 2721 htt_stats_buf->consumer_empty__producer_full)); 2722 len += scnprintf(buf + len, buf_len - len, "prefetch_count = %lu\n", 2723 FIELD_GET(HTT_SRING_STATS_PREFETCH_COUNT, 2724 htt_stats_buf->prefetch_count__internal_tail_ptr)); 2725 len += scnprintf(buf + len, buf_len - len, "internal_tail_ptr = %lu\n\n", 2726 FIELD_GET(HTT_SRING_STATS_INTERNAL_TAIL_PTR, 2727 htt_stats_buf->prefetch_count__internal_tail_ptr)); 2728 2729 if (len >= buf_len) 2730 buf[buf_len - 1] = 0; 2731 else 2732 buf[len] = 0; 2733 2734 stats_req->buf_len = len; 2735} 2736 2737static inline void htt_print_sring_cmn_tlv(const void *tag_buf, 2738 struct debug_htt_stats_req *stats_req) 2739{ 2740 const struct htt_sring_cmn_tlv *htt_stats_buf = tag_buf; 2741 u8 *buf = stats_req->buf; 2742 u32 len = stats_req->buf_len; 2743 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2744 2745 len += scnprintf(buf + len, buf_len - len, "HTT_SRING_CMN_TLV:\n"); 2746 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n", 2747 htt_stats_buf->num_records); 2748 2749 if (len >= buf_len) 2750 buf[buf_len - 1] = 0; 2751 else 2752 buf[len] = 0; 2753 2754 stats_req->buf_len = len; 2755} 2756 2757static inline void htt_print_tx_pdev_rate_stats_tlv(const void *tag_buf, 2758 struct debug_htt_stats_req *stats_req) 2759{ 2760 const struct htt_tx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf; 2761 u8 *buf = stats_req->buf; 2762 u32 len = stats_req->buf_len; 2763 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2764 u8 j; 2765 2766 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_RATE_STATS_TLV:\n"); 2767 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2768 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 2769 len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n", 2770 htt_stats_buf->tx_ldpc); 2771 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_tx_ldpc = %u\n", 2772 htt_stats_buf->ac_mu_mimo_tx_ldpc); 2773 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_tx_ldpc = %u\n", 2774 htt_stats_buf->ax_mu_mimo_tx_ldpc); 2775 len += scnprintf(buf + len, buf_len - len, "ofdma_tx_ldpc = %u\n", 2776 htt_stats_buf->ofdma_tx_ldpc); 2777 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n", 2778 htt_stats_buf->rts_cnt); 2779 len += scnprintf(buf + len, buf_len - len, "rts_success = %u\n", 2780 htt_stats_buf->rts_success); 2781 len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n", 2782 htt_stats_buf->ack_rssi); 2783 2784 len += scnprintf(buf + len, buf_len - len, 2785 "Legacy CCK Rates: 1 Mbps: %u, 2 Mbps: %u, 5.5 Mbps: %u, 11 Mbps: %u\n", 2786 htt_stats_buf->tx_legacy_cck_rate[0], 2787 htt_stats_buf->tx_legacy_cck_rate[1], 2788 htt_stats_buf->tx_legacy_cck_rate[2], 2789 htt_stats_buf->tx_legacy_cck_rate[3]); 2790 2791 len += scnprintf(buf + len, buf_len - len, 2792 "Legacy OFDM Rates: 6 Mbps: %u, 9 Mbps: %u, 12 Mbps: %u, 18 Mbps: %u\n" 2793 " 24 Mbps: %u, 36 Mbps: %u, 48 Mbps: %u, 54 Mbps: %u\n", 2794 htt_stats_buf->tx_legacy_ofdm_rate[0], 2795 htt_stats_buf->tx_legacy_ofdm_rate[1], 2796 htt_stats_buf->tx_legacy_ofdm_rate[2], 2797 htt_stats_buf->tx_legacy_ofdm_rate[3], 2798 htt_stats_buf->tx_legacy_ofdm_rate[4], 2799 htt_stats_buf->tx_legacy_ofdm_rate[5], 2800 htt_stats_buf->tx_legacy_ofdm_rate[6], 2801 htt_stats_buf->tx_legacy_ofdm_rate[7]); 2802 2803 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs, "tx_mcs", 2804 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2805 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_mcs, 2806 "ac_mu_mimo_tx_mcs", HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2807 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_mcs, 2808 "ax_mu_mimo_tx_mcs", HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2809 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_mcs, "ofdma_tx_mcs", 2810 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2811 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss, "tx_nss", 2812 HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 2813 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_nss, 2814 "ac_mu_mimo_tx_nss", 2815 HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 2816 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_nss, 2817 "ax_mu_mimo_tx_nss", 2818 HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 2819 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_nss, "ofdma_tx_nss", 2820 HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 2821 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw, "tx_bw", 2822 HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 2823 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_bw, 2824 "ac_mu_mimo_tx_bw", HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 2825 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_bw, 2826 "ax_mu_mimo_tx_bw", 2827 HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 2828 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_bw, "ofdma_tx_bw", 2829 HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 2830 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc, "tx_stbc", 2831 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2832 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream, "tx_pream", 2833 HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n"); 2834 2835 len += scnprintf(buf + len, buf_len - len, "HE LTF: 1x: %u, 2x: %u, 4x: %u\n", 2836 htt_stats_buf->tx_he_ltf[1], 2837 htt_stats_buf->tx_he_ltf[2], 2838 htt_stats_buf->tx_he_ltf[3]); 2839 2840 /* SU GI Stats */ 2841 for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 2842 len += scnprintf(buf + len, (buf_len - len), 2843 "tx_gi[%u] = ", j); 2844 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_gi[j], NULL, 2845 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2846 } 2847 2848 /* AC MU-MIMO GI Stats */ 2849 for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 2850 len += scnprintf(buf + len, (buf_len - len), 2851 "ac_mu_mimo_tx_gi[%u] = ", j); 2852 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_gi[j], 2853 NULL, HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2854 } 2855 2856 /* AX MU-MIMO GI Stats */ 2857 for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 2858 len += scnprintf(buf + len, (buf_len - len), 2859 "ax_mu_mimo_tx_gi[%u] = ", j); 2860 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_gi[j], 2861 NULL, HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2862 } 2863 2864 /* DL OFDMA GI Stats */ 2865 for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 2866 len += scnprintf(buf + len, (buf_len - len), 2867 "ofdma_tx_gi[%u] = ", j); 2868 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_gi[j], NULL, 2869 HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2870 } 2871 2872 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm, "tx_dcm", 2873 HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\n"); 2874 2875 if (len >= buf_len) 2876 buf[buf_len - 1] = 0; 2877 else 2878 buf[len] = 0; 2879 2880 stats_req->buf_len = len; 2881} 2882 2883static inline void htt_print_rx_pdev_rate_stats_tlv(const void *tag_buf, 2884 struct debug_htt_stats_req *stats_req) 2885{ 2886 const struct htt_rx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf; 2887 u8 *buf = stats_req->buf; 2888 u32 len = stats_req->buf_len; 2889 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 2890 u8 i, j; 2891 2892 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_STATS_TLV:\n"); 2893 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 2894 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 2895 len += scnprintf(buf + len, buf_len - len, "nsts = %u\n", 2896 htt_stats_buf->nsts); 2897 len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n", 2898 htt_stats_buf->rx_ldpc); 2899 len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n", 2900 htt_stats_buf->rts_cnt); 2901 len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n", 2902 htt_stats_buf->rssi_mgmt); 2903 len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n", 2904 htt_stats_buf->rssi_data); 2905 len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n", 2906 htt_stats_buf->rssi_comb); 2907 len += scnprintf(buf + len, buf_len - len, "rssi_in_dbm = %d\n", 2908 htt_stats_buf->rssi_in_dbm); 2909 2910 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs, "rx_mcs", 2911 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2912 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss, "rx_nss", 2913 HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 2914 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm, "rx_dcm", 2915 HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n"); 2916 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc, "rx_stbc", 2917 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2918 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw, "rx_bw", 2919 HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 2920 2921 len += scnprintf(buf + len, buf_len - len, "rx_evm_nss_count = %u\n", 2922 htt_stats_buf->nss_count); 2923 2924 len += scnprintf(buf + len, buf_len - len, "rx_evm_pilot_count = %u\n", 2925 htt_stats_buf->pilot_count); 2926 2927 for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 2928 len += scnprintf(buf + len, buf_len - len, 2929 "pilot_evm_db[%u] = ", j); 2930 for (i = 0; i < HTT_RX_PDEV_STATS_RXEVM_MAX_PILOTS_PER_NSS; i++) 2931 len += scnprintf(buf + len, 2932 buf_len - len, 2933 " %u:%d,", 2934 i, 2935 htt_stats_buf->rx_pilot_evm_db[j][i]); 2936 len += scnprintf(buf + len, buf_len - len, "\n"); 2937 } 2938 2939 len += scnprintf(buf + len, buf_len - len, 2940 "pilot_evm_db_mean = "); 2941 for (i = 0; i < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++) 2942 len += scnprintf(buf + len, 2943 buf_len - len, 2944 " %u:%d,", i, 2945 htt_stats_buf->rx_pilot_evm_db_mean[i]); 2946 len += scnprintf(buf + len, buf_len - len, "\n"); 2947 2948 for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 2949 len += scnprintf(buf + len, buf_len - len, 2950 "rssi_chain[%u] = ", j); 2951 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain[j], NULL, 2952 HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 2953 } 2954 2955 for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 2956 len += scnprintf(buf + len, buf_len - len, 2957 "rx_gi[%u] = ", j); 2958 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi[j], NULL, 2959 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 2960 } 2961 2962 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream, "rx_pream", 2963 HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n"); 2964 2965 len += scnprintf(buf + len, buf_len - len, "rx_11ax_su_ext = %u\n", 2966 htt_stats_buf->rx_11ax_su_ext); 2967 len += scnprintf(buf + len, buf_len - len, "rx_11ac_mumimo = %u\n", 2968 htt_stats_buf->rx_11ac_mumimo); 2969 len += scnprintf(buf + len, buf_len - len, "rx_11ax_mumimo = %u\n", 2970 htt_stats_buf->rx_11ax_mumimo); 2971 len += scnprintf(buf + len, buf_len - len, "rx_11ax_ofdma = %u\n", 2972 htt_stats_buf->rx_11ax_ofdma); 2973 len += scnprintf(buf + len, buf_len - len, "txbf = %u\n", 2974 htt_stats_buf->txbf); 2975 2976 len += scnprintf(buf + len, buf_len - len, "\nrx_su_ndpa = %u", 2977 htt_stats_buf->rx_su_ndpa); 2978 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_su_txbf_mcs, 2979 "rx_11ax_su_txbf_mcs", HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, 2980 "\n"); 2981 2982 len += scnprintf(buf + len, buf_len - len, "\nrx_mu_ndpa = %u", 2983 htt_stats_buf->rx_mu_ndpa); 2984 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_mu_txbf_mcs, 2985 "rx_11ax_mu_txbf_mcs", HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, 2986 "\n"); 2987 2988 len += scnprintf(buf + len, buf_len - len, "\nrx_br_poll = %u", 2989 htt_stats_buf->rx_br_poll); 2990 2991 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_legacy_cck_rate, 2992 "rx_legacy_cck_rate", 2993 HTT_RX_PDEV_STATS_NUM_LEGACY_CCK_STATS, "\n"); 2994 2995 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_legacy_ofdm_rate, 2996 "rx_legacy_ofdm_rate", 2997 HTT_RX_PDEV_STATS_NUM_LEGACY_OFDM_STATS, "\n"); 2998 2999 len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_low = %u\n", 3000 htt_stats_buf->rx_active_dur_us_low); 3001 len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_high = %u\n", 3002 htt_stats_buf->rx_active_dur_us_high); 3003 len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_ofdma = %u\n", 3004 htt_stats_buf->rx_11ax_ul_ofdma); 3005 3006 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_mcs, 3007 "ul_ofdma_rx_mcs", 3008 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 3009 3010 for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) { 3011 len += scnprintf(buf + len, buf_len - len, 3012 "ul_ofdma_rx_gi[%u] = ", j); 3013 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_gi[j], NULL, 3014 HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n"); 3015 } 3016 3017 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_nss, 3018 "ul_ofdma_rx_nss", 3019 HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n"); 3020 3021 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_bw, "ul_ofdma_rx_bw", 3022 HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n"); 3023 3024 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_stbc = %u\n", 3025 htt_stats_buf->ul_ofdma_rx_stbc); 3026 len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_ldpc = %u\n", 3027 htt_stats_buf->ul_ofdma_rx_ldpc); 3028 3029 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_non_data_ppdu, 3030 "rx_ulofdma_non_data_ppdu", 3031 HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 3032 3033 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_data_ppdu, 3034 "rx_ulofdma_data_ppdu", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 3035 3036 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_mpdu_ok, 3037 "rx_ulofdma_mpdu_ok", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 3038 3039 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_mpdu_fail, 3040 "rx_ulofdma_mpdu_fail", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n"); 3041 3042 for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 3043 len += scnprintf(buf + len, buf_len - len, 3044 "rx_ul_fd_rssi: nss[%u] = ", j); 3045 for (i = 0; i < HTT_RX_PDEV_MAX_OFDMA_NUM_USER; i++) 3046 len += scnprintf(buf + len, 3047 buf_len - len, 3048 " %u:%d,", 3049 i, htt_stats_buf->rx_ul_fd_rssi[j][i]); 3050 len += scnprintf(buf + len, buf_len - len, "\n"); 3051 } 3052 3053 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_non_data_nusers, 3054 "rx_ulofdma_non_data_nusers", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, 3055 "\n"); 3056 3057 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_data_nusers, 3058 "rx_ulofdma_data_nusers", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, 3059 "\n"); 3060 3061 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_mcs, 3062 "rx_11ax_dl_ofdma_mcs", HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, 3063 "\n"); 3064 3065 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_ru, 3066 "rx_11ax_dl_ofdma_ru", HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS, 3067 "\n"); 3068 3069 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_non_data_ppdu, 3070 "rx_ulmumimo_non_data_ppdu", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, 3071 "\n"); 3072 3073 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_data_ppdu, 3074 "rx_ulmumimo_data_ppdu", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, 3075 "\n"); 3076 3077 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_mpdu_ok, 3078 "rx_ulmumimo_mpdu_ok", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, 3079 "\n"); 3080 3081 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_mpdu_fail, 3082 "rx_ulmumimo_mpdu_fail", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, 3083 "\n"); 3084 3085 len += scnprintf(buf + len, buf_len - len, "per_chain_rssi_pkt_type = %#x\n", 3086 htt_stats_buf->per_chain_rssi_pkt_type); 3087 3088 for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) { 3089 len += scnprintf(buf + len, buf_len - len, 3090 "rx_per_chain_rssi_in_dbm[%u] = ", j); 3091 for (i = 0; i < HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++) 3092 len += scnprintf(buf + len, 3093 buf_len - len, 3094 " %u:%d,", 3095 i, 3096 htt_stats_buf->rx_per_chain_rssi_in_dbm[j][i]); 3097 len += scnprintf(buf + len, buf_len - len, "\n"); 3098 } 3099 len += scnprintf(buf + len, buf_len - len, "\n"); 3100 3101 if (len >= buf_len) 3102 buf[buf_len - 1] = 0; 3103 else 3104 buf[len] = 0; 3105 3106 stats_req->buf_len = len; 3107} 3108 3109static inline void htt_print_rx_soc_fw_stats_tlv(const void *tag_buf, 3110 struct debug_htt_stats_req *stats_req) 3111{ 3112 const struct htt_rx_soc_fw_stats_tlv *htt_stats_buf = tag_buf; 3113 u8 *buf = stats_req->buf; 3114 u32 len = stats_req->buf_len; 3115 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3116 3117 len += scnprintf(buf + len, buf_len - len, "HTT_RX_SOC_FW_STATS_TLV:\n"); 3118 len += scnprintf(buf + len, buf_len - len, "fw_reo_ring_data_msdu = %u\n", 3119 htt_stats_buf->fw_reo_ring_data_msdu); 3120 len += scnprintf(buf + len, buf_len - len, "fw_to_host_data_msdu_bcmc = %u\n", 3121 htt_stats_buf->fw_to_host_data_msdu_bcmc); 3122 len += scnprintf(buf + len, buf_len - len, "fw_to_host_data_msdu_uc = %u\n", 3123 htt_stats_buf->fw_to_host_data_msdu_uc); 3124 len += scnprintf(buf + len, buf_len - len, 3125 "ofld_remote_data_buf_recycle_cnt = %u\n", 3126 htt_stats_buf->ofld_remote_data_buf_recycle_cnt); 3127 len += scnprintf(buf + len, buf_len - len, 3128 "ofld_remote_free_buf_indication_cnt = %u\n", 3129 htt_stats_buf->ofld_remote_free_buf_indication_cnt); 3130 len += scnprintf(buf + len, buf_len - len, 3131 "ofld_buf_to_host_data_msdu_uc = %u\n", 3132 htt_stats_buf->ofld_buf_to_host_data_msdu_uc); 3133 len += scnprintf(buf + len, buf_len - len, 3134 "reo_fw_ring_to_host_data_msdu_uc = %u\n", 3135 htt_stats_buf->reo_fw_ring_to_host_data_msdu_uc); 3136 len += scnprintf(buf + len, buf_len - len, "wbm_sw_ring_reap = %u\n", 3137 htt_stats_buf->wbm_sw_ring_reap); 3138 len += scnprintf(buf + len, buf_len - len, "wbm_forward_to_host_cnt = %u\n", 3139 htt_stats_buf->wbm_forward_to_host_cnt); 3140 len += scnprintf(buf + len, buf_len - len, "wbm_target_recycle_cnt = %u\n", 3141 htt_stats_buf->wbm_target_recycle_cnt); 3142 len += scnprintf(buf + len, buf_len - len, 3143 "target_refill_ring_recycle_cnt = %u\n", 3144 htt_stats_buf->target_refill_ring_recycle_cnt); 3145 3146 if (len >= buf_len) 3147 buf[buf_len - 1] = 0; 3148 else 3149 buf[len] = 0; 3150 3151 stats_req->buf_len = len; 3152} 3153 3154static inline void 3155htt_print_rx_soc_fw_refill_ring_empty_tlv_v(const void *tag_buf, 3156 u16 tag_len, 3157 struct debug_htt_stats_req *stats_req) 3158{ 3159 const struct htt_rx_soc_fw_refill_ring_empty_tlv_v *htt_stats_buf = tag_buf; 3160 u8 *buf = stats_req->buf; 3161 u32 len = stats_req->buf_len; 3162 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3163 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_REFILL_MAX_RING); 3164 3165 len += scnprintf(buf + len, buf_len - len, 3166 "HTT_RX_SOC_FW_REFILL_RING_EMPTY_TLV_V:\n"); 3167 3168 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->refill_ring_empty_cnt, 3169 "refill_ring_empty_cnt", num_elems, "\n\n"); 3170 3171 if (len >= buf_len) 3172 buf[buf_len - 1] = 0; 3173 else 3174 buf[len] = 0; 3175 3176 stats_req->buf_len = len; 3177} 3178 3179static inline void 3180htt_print_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v(const void *tag_buf, 3181 u16 tag_len, 3182 struct debug_htt_stats_req *stats_req) 3183{ 3184 const struct htt_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v *htt_stats_buf = 3185 tag_buf; 3186 u8 *buf = stats_req->buf; 3187 u32 len = stats_req->buf_len; 3188 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3189 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_RXDMA_MAX_ERR_CODE); 3190 3191 len += scnprintf(buf + len, buf_len - len, 3192 "HTT_RX_SOC_FW_REFILL_RING_NUM_RXDMA_ERR_TLV_V:\n"); 3193 3194 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rxdma_err, "rxdma_err", 3195 num_elems, "\n\n"); 3196 3197 if (len >= buf_len) 3198 buf[buf_len - 1] = 0; 3199 else 3200 buf[len] = 0; 3201 3202 stats_req->buf_len = len; 3203} 3204 3205static inline void 3206htt_print_rx_soc_fw_refill_ring_num_reo_err_tlv_v(const void *tag_buf, 3207 u16 tag_len, 3208 struct debug_htt_stats_req *stats_req) 3209{ 3210 const struct htt_rx_soc_fw_refill_ring_num_reo_err_tlv_v *htt_stats_buf = tag_buf; 3211 u8 *buf = stats_req->buf; 3212 u32 len = stats_req->buf_len; 3213 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3214 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_REO_MAX_ERR_CODE); 3215 3216 len += scnprintf(buf + len, buf_len - len, 3217 "HTT_RX_SOC_FW_REFILL_RING_NUM_REO_ERR_TLV_V:\n"); 3218 3219 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->reo_err, "reo_err", 3220 num_elems, "\n\n"); 3221 3222 if (len >= buf_len) 3223 buf[buf_len - 1] = 0; 3224 else 3225 buf[len] = 0; 3226 3227 stats_req->buf_len = len; 3228} 3229 3230static inline void 3231htt_print_rx_reo_debug_stats_tlv_v(const void *tag_buf, 3232 struct debug_htt_stats_req *stats_req) 3233{ 3234 const struct htt_rx_reo_resource_stats_tlv_v *htt_stats_buf = tag_buf; 3235 u8 *buf = stats_req->buf; 3236 u32 len = stats_req->buf_len; 3237 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3238 3239 len += scnprintf(buf + len, buf_len - len, "HTT_RX_REO_RESOURCE_STATS_TLV:\n"); 3240 len += scnprintf(buf + len, buf_len - len, "sample_id = %u\n", 3241 htt_stats_buf->sample_id); 3242 len += scnprintf(buf + len, buf_len - len, "total_max = %u\n", 3243 htt_stats_buf->total_max); 3244 len += scnprintf(buf + len, buf_len - len, "total_avg = %u\n", 3245 htt_stats_buf->total_avg); 3246 len += scnprintf(buf + len, buf_len - len, "total_sample = %u\n", 3247 htt_stats_buf->total_sample); 3248 len += scnprintf(buf + len, buf_len - len, "non_zeros_avg = %u\n", 3249 htt_stats_buf->non_zeros_avg); 3250 len += scnprintf(buf + len, buf_len - len, "non_zeros_sample = %u\n", 3251 htt_stats_buf->non_zeros_sample); 3252 len += scnprintf(buf + len, buf_len - len, "last_non_zeros_max = %u\n", 3253 htt_stats_buf->last_non_zeros_max); 3254 len += scnprintf(buf + len, buf_len - len, "last_non_zeros_min %u\n", 3255 htt_stats_buf->last_non_zeros_min); 3256 len += scnprintf(buf + len, buf_len - len, "last_non_zeros_avg %u\n", 3257 htt_stats_buf->last_non_zeros_avg); 3258 len += scnprintf(buf + len, buf_len - len, "last_non_zeros_sample %u\n\n", 3259 htt_stats_buf->last_non_zeros_sample); 3260 3261 if (len >= buf_len) 3262 buf[buf_len - 1] = 0; 3263 else 3264 buf[len] = 0; 3265 3266 stats_req->buf_len = len; 3267} 3268 3269static inline void 3270htt_print_rx_soc_fw_refill_ring_num_refill_tlv_v(const void *tag_buf, 3271 u16 tag_len, 3272 struct debug_htt_stats_req *stats_req) 3273{ 3274 const struct htt_rx_soc_fw_refill_ring_num_refill_tlv_v *htt_stats_buf = tag_buf; 3275 u8 *buf = stats_req->buf; 3276 u32 len = stats_req->buf_len; 3277 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3278 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_REFILL_MAX_RING); 3279 3280 len += scnprintf(buf + len, buf_len - len, 3281 "HTT_RX_SOC_FW_REFILL_RING_NUM_REFILL_TLV_V:\n"); 3282 3283 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->refill_ring_num_refill, 3284 "refill_ring_num_refill", num_elems, "\n\n"); 3285 3286 if (len >= buf_len) 3287 buf[buf_len - 1] = 0; 3288 else 3289 buf[len] = 0; 3290 3291 stats_req->buf_len = len; 3292} 3293 3294static inline void htt_print_rx_pdev_fw_stats_tlv(const void *tag_buf, 3295 struct debug_htt_stats_req *stats_req) 3296{ 3297 const struct htt_rx_pdev_fw_stats_tlv *htt_stats_buf = tag_buf; 3298 u8 *buf = stats_req->buf; 3299 u32 len = stats_req->buf_len; 3300 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3301 3302 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_TLV:\n"); 3303 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 3304 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 3305 len += scnprintf(buf + len, buf_len - len, "ppdu_recvd = %u\n", 3306 htt_stats_buf->ppdu_recvd); 3307 len += scnprintf(buf + len, buf_len - len, "mpdu_cnt_fcs_ok = %u\n", 3308 htt_stats_buf->mpdu_cnt_fcs_ok); 3309 len += scnprintf(buf + len, buf_len - len, "mpdu_cnt_fcs_err = %u\n", 3310 htt_stats_buf->mpdu_cnt_fcs_err); 3311 len += scnprintf(buf + len, buf_len - len, "tcp_msdu_cnt = %u\n", 3312 htt_stats_buf->tcp_msdu_cnt); 3313 len += scnprintf(buf + len, buf_len - len, "tcp_ack_msdu_cnt = %u\n", 3314 htt_stats_buf->tcp_ack_msdu_cnt); 3315 len += scnprintf(buf + len, buf_len - len, "udp_msdu_cnt = %u\n", 3316 htt_stats_buf->udp_msdu_cnt); 3317 len += scnprintf(buf + len, buf_len - len, "other_msdu_cnt = %u\n", 3318 htt_stats_buf->other_msdu_cnt); 3319 len += scnprintf(buf + len, buf_len - len, "fw_ring_mpdu_ind = %u\n", 3320 htt_stats_buf->fw_ring_mpdu_ind); 3321 3322 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_mgmt_subtype, 3323 "fw_ring_mgmt_subtype", HTT_STATS_SUBTYPE_MAX, "\n"); 3324 3325 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_ctrl_subtype, 3326 "fw_ring_ctrl_subtype", HTT_STATS_SUBTYPE_MAX, "\n"); 3327 3328 len += scnprintf(buf + len, buf_len - len, "fw_ring_mcast_data_msdu = %u\n", 3329 htt_stats_buf->fw_ring_mcast_data_msdu); 3330 len += scnprintf(buf + len, buf_len - len, "fw_ring_bcast_data_msdu = %u\n", 3331 htt_stats_buf->fw_ring_bcast_data_msdu); 3332 len += scnprintf(buf + len, buf_len - len, "fw_ring_ucast_data_msdu = %u\n", 3333 htt_stats_buf->fw_ring_ucast_data_msdu); 3334 len += scnprintf(buf + len, buf_len - len, "fw_ring_null_data_msdu = %u\n", 3335 htt_stats_buf->fw_ring_null_data_msdu); 3336 len += scnprintf(buf + len, buf_len - len, "fw_ring_mpdu_drop = %u\n", 3337 htt_stats_buf->fw_ring_mpdu_drop); 3338 len += scnprintf(buf + len, buf_len - len, "ofld_local_data_ind_cnt = %u\n", 3339 htt_stats_buf->ofld_local_data_ind_cnt); 3340 len += scnprintf(buf + len, buf_len - len, 3341 "ofld_local_data_buf_recycle_cnt = %u\n", 3342 htt_stats_buf->ofld_local_data_buf_recycle_cnt); 3343 len += scnprintf(buf + len, buf_len - len, "drx_local_data_ind_cnt = %u\n", 3344 htt_stats_buf->drx_local_data_ind_cnt); 3345 len += scnprintf(buf + len, buf_len - len, 3346 "drx_local_data_buf_recycle_cnt = %u\n", 3347 htt_stats_buf->drx_local_data_buf_recycle_cnt); 3348 len += scnprintf(buf + len, buf_len - len, "local_nondata_ind_cnt = %u\n", 3349 htt_stats_buf->local_nondata_ind_cnt); 3350 len += scnprintf(buf + len, buf_len - len, "local_nondata_buf_recycle_cnt = %u\n", 3351 htt_stats_buf->local_nondata_buf_recycle_cnt); 3352 len += scnprintf(buf + len, buf_len - len, "fw_status_buf_ring_refill_cnt = %u\n", 3353 htt_stats_buf->fw_status_buf_ring_refill_cnt); 3354 len += scnprintf(buf + len, buf_len - len, "fw_status_buf_ring_empty_cnt = %u\n", 3355 htt_stats_buf->fw_status_buf_ring_empty_cnt); 3356 len += scnprintf(buf + len, buf_len - len, "fw_pkt_buf_ring_refill_cnt = %u\n", 3357 htt_stats_buf->fw_pkt_buf_ring_refill_cnt); 3358 len += scnprintf(buf + len, buf_len - len, "fw_pkt_buf_ring_empty_cnt = %u\n", 3359 htt_stats_buf->fw_pkt_buf_ring_empty_cnt); 3360 len += scnprintf(buf + len, buf_len - len, "fw_link_buf_ring_refill_cnt = %u\n", 3361 htt_stats_buf->fw_link_buf_ring_refill_cnt); 3362 len += scnprintf(buf + len, buf_len - len, "fw_link_buf_ring_empty_cnt = %u\n", 3363 htt_stats_buf->fw_link_buf_ring_empty_cnt); 3364 len += scnprintf(buf + len, buf_len - len, "host_pkt_buf_ring_refill_cnt = %u\n", 3365 htt_stats_buf->host_pkt_buf_ring_refill_cnt); 3366 len += scnprintf(buf + len, buf_len - len, "host_pkt_buf_ring_empty_cnt = %u\n", 3367 htt_stats_buf->host_pkt_buf_ring_empty_cnt); 3368 len += scnprintf(buf + len, buf_len - len, "mon_pkt_buf_ring_refill_cnt = %u\n", 3369 htt_stats_buf->mon_pkt_buf_ring_refill_cnt); 3370 len += scnprintf(buf + len, buf_len - len, "mon_pkt_buf_ring_empty_cnt = %u\n", 3371 htt_stats_buf->mon_pkt_buf_ring_empty_cnt); 3372 len += scnprintf(buf + len, buf_len - len, 3373 "mon_status_buf_ring_refill_cnt = %u\n", 3374 htt_stats_buf->mon_status_buf_ring_refill_cnt); 3375 len += scnprintf(buf + len, buf_len - len, "mon_status_buf_ring_empty_cnt = %u\n", 3376 htt_stats_buf->mon_status_buf_ring_empty_cnt); 3377 len += scnprintf(buf + len, buf_len - len, "mon_desc_buf_ring_refill_cnt = %u\n", 3378 htt_stats_buf->mon_desc_buf_ring_refill_cnt); 3379 len += scnprintf(buf + len, buf_len - len, "mon_desc_buf_ring_empty_cnt = %u\n", 3380 htt_stats_buf->mon_desc_buf_ring_empty_cnt); 3381 len += scnprintf(buf + len, buf_len - len, "mon_dest_ring_update_cnt = %u\n", 3382 htt_stats_buf->mon_dest_ring_update_cnt); 3383 len += scnprintf(buf + len, buf_len - len, "mon_dest_ring_full_cnt = %u\n", 3384 htt_stats_buf->mon_dest_ring_full_cnt); 3385 len += scnprintf(buf + len, buf_len - len, "rx_suspend_cnt = %u\n", 3386 htt_stats_buf->rx_suspend_cnt); 3387 len += scnprintf(buf + len, buf_len - len, "rx_suspend_fail_cnt = %u\n", 3388 htt_stats_buf->rx_suspend_fail_cnt); 3389 len += scnprintf(buf + len, buf_len - len, "rx_resume_cnt = %u\n", 3390 htt_stats_buf->rx_resume_cnt); 3391 len += scnprintf(buf + len, buf_len - len, "rx_resume_fail_cnt = %u\n", 3392 htt_stats_buf->rx_resume_fail_cnt); 3393 len += scnprintf(buf + len, buf_len - len, "rx_ring_switch_cnt = %u\n", 3394 htt_stats_buf->rx_ring_switch_cnt); 3395 len += scnprintf(buf + len, buf_len - len, "rx_ring_restore_cnt = %u\n", 3396 htt_stats_buf->rx_ring_restore_cnt); 3397 len += scnprintf(buf + len, buf_len - len, "rx_flush_cnt = %u\n", 3398 htt_stats_buf->rx_flush_cnt); 3399 len += scnprintf(buf + len, buf_len - len, "rx_recovery_reset_cnt = %u\n\n", 3400 htt_stats_buf->rx_recovery_reset_cnt); 3401 3402 if (len >= buf_len) 3403 buf[buf_len - 1] = 0; 3404 else 3405 buf[len] = 0; 3406 3407 stats_req->buf_len = len; 3408} 3409 3410static inline void 3411htt_print_rx_pdev_fw_ring_mpdu_err_tlv_v(const void *tag_buf, 3412 struct debug_htt_stats_req *stats_req) 3413{ 3414 const struct htt_rx_pdev_fw_ring_mpdu_err_tlv_v *htt_stats_buf = tag_buf; 3415 u8 *buf = stats_req->buf; 3416 u32 len = stats_req->buf_len; 3417 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3418 3419 len += scnprintf(buf + len, buf_len - len, 3420 "HTT_RX_PDEV_FW_RING_MPDU_ERR_TLV_V:\n"); 3421 3422 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_mpdu_err, 3423 "fw_ring_mpdu_err", HTT_RX_STATS_RXDMA_MAX_ERR, "\n"); 3424 3425 if (len >= buf_len) 3426 buf[buf_len - 1] = 0; 3427 else 3428 buf[len] = 0; 3429 3430 stats_req->buf_len = len; 3431} 3432 3433static inline void 3434htt_print_rx_pdev_fw_mpdu_drop_tlv_v(const void *tag_buf, 3435 u16 tag_len, 3436 struct debug_htt_stats_req *stats_req) 3437{ 3438 const struct htt_rx_pdev_fw_mpdu_drop_tlv_v *htt_stats_buf = tag_buf; 3439 u8 *buf = stats_req->buf; 3440 u32 len = stats_req->buf_len; 3441 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3442 u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_FW_DROP_REASON_MAX); 3443 3444 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_MPDU_DROP_TLV_V:\n"); 3445 3446 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_mpdu_drop, "fw_mpdu_drop", 3447 num_elems, "\n\n"); 3448 3449 if (len >= buf_len) 3450 buf[buf_len - 1] = 0; 3451 else 3452 buf[len] = 0; 3453 3454 stats_req->buf_len = len; 3455} 3456 3457static inline void 3458htt_print_rx_pdev_fw_stats_phy_err_tlv(const void *tag_buf, 3459 struct debug_htt_stats_req *stats_req) 3460{ 3461 const struct htt_rx_pdev_fw_stats_phy_err_tlv *htt_stats_buf = tag_buf; 3462 u8 *buf = stats_req->buf; 3463 u32 len = stats_req->buf_len; 3464 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3465 3466 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_PHY_ERR_TLV:\n"); 3467 len += scnprintf(buf + len, buf_len - len, "mac_id__word = %u\n", 3468 htt_stats_buf->mac_id__word); 3469 len += scnprintf(buf + len, buf_len - len, "total_phy_err_nct = %u\n", 3470 htt_stats_buf->total_phy_err_cnt); 3471 3472 PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_err, "phy_errs", 3473 HTT_STATS_PHY_ERR_MAX, "\n\n"); 3474 3475 if (len >= buf_len) 3476 buf[buf_len - 1] = 0; 3477 else 3478 buf[len] = 0; 3479 3480 stats_req->buf_len = len; 3481} 3482 3483static inline void 3484htt_print_pdev_cca_stats_hist_tlv(const void *tag_buf, 3485 struct debug_htt_stats_req *stats_req) 3486{ 3487 const struct htt_pdev_cca_stats_hist_v1_tlv *htt_stats_buf = tag_buf; 3488 u8 *buf = stats_req->buf; 3489 u32 len = stats_req->buf_len; 3490 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3491 3492 len += scnprintf(buf + len, buf_len - len, "\nHTT_PDEV_CCA_STATS_HIST_TLV:\n"); 3493 len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n", 3494 htt_stats_buf->chan_num); 3495 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n", 3496 htt_stats_buf->num_records); 3497 len += scnprintf(buf + len, buf_len - len, "valid_cca_counters_bitmap = 0x%x\n", 3498 htt_stats_buf->valid_cca_counters_bitmap); 3499 len += scnprintf(buf + len, buf_len - len, "collection_interval = %u\n\n", 3500 htt_stats_buf->collection_interval); 3501 3502 len += scnprintf(buf + len, buf_len - len, 3503 "HTT_PDEV_STATS_CCA_COUNTERS_TLV:(in usec)\n"); 3504 len += scnprintf(buf + len, buf_len - len, 3505 "| tx_frame| rx_frame| rx_clear| my_rx_frame| cnt| med_rx_idle| med_tx_idle_global| cca_obss|\n"); 3506 3507 if (len >= buf_len) 3508 buf[buf_len - 1] = 0; 3509 else 3510 buf[len] = 0; 3511 3512 stats_req->buf_len = len; 3513} 3514 3515static inline void 3516htt_print_pdev_stats_cca_counters_tlv(const void *tag_buf, 3517 struct debug_htt_stats_req *stats_req) 3518{ 3519 const struct htt_pdev_stats_cca_counters_tlv *htt_stats_buf = tag_buf; 3520 u8 *buf = stats_req->buf; 3521 u32 len = stats_req->buf_len; 3522 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3523 3524 len += scnprintf(buf + len, buf_len - len, 3525 "|%10u| %10u| %10u| %11u| %10u| %11u| %18u| %10u|\n", 3526 htt_stats_buf->tx_frame_usec, 3527 htt_stats_buf->rx_frame_usec, 3528 htt_stats_buf->rx_clear_usec, 3529 htt_stats_buf->my_rx_frame_usec, 3530 htt_stats_buf->usec_cnt, 3531 htt_stats_buf->med_rx_idle_usec, 3532 htt_stats_buf->med_tx_idle_global_usec, 3533 htt_stats_buf->cca_obss_usec); 3534 3535 if (len >= buf_len) 3536 buf[buf_len - 1] = 0; 3537 else 3538 buf[len] = 0; 3539 3540 stats_req->buf_len = len; 3541} 3542 3543static inline void htt_print_hw_stats_whal_tx_tlv(const void *tag_buf, 3544 struct debug_htt_stats_req *stats_req) 3545{ 3546 const struct htt_hw_stats_whal_tx_tlv *htt_stats_buf = tag_buf; 3547 u8 *buf = stats_req->buf; 3548 u32 len = stats_req->buf_len; 3549 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3550 3551 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WHAL_TX_TLV:\n"); 3552 len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n", 3553 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word)); 3554 len += scnprintf(buf + len, buf_len - len, "last_unpause_ppdu_id = %u\n", 3555 htt_stats_buf->last_unpause_ppdu_id); 3556 len += scnprintf(buf + len, buf_len - len, "hwsch_unpause_wait_tqm_write = %u\n", 3557 htt_stats_buf->hwsch_unpause_wait_tqm_write); 3558 len += scnprintf(buf + len, buf_len - len, "hwsch_dummy_tlv_skipped = %u\n", 3559 htt_stats_buf->hwsch_dummy_tlv_skipped); 3560 len += scnprintf(buf + len, buf_len - len, 3561 "hwsch_misaligned_offset_received = %u\n", 3562 htt_stats_buf->hwsch_misaligned_offset_received); 3563 len += scnprintf(buf + len, buf_len - len, "hwsch_reset_count = %u\n", 3564 htt_stats_buf->hwsch_reset_count); 3565 len += scnprintf(buf + len, buf_len - len, "hwsch_dev_reset_war = %u\n", 3566 htt_stats_buf->hwsch_dev_reset_war); 3567 len += scnprintf(buf + len, buf_len - len, "hwsch_delayed_pause = %u\n", 3568 htt_stats_buf->hwsch_delayed_pause); 3569 len += scnprintf(buf + len, buf_len - len, "hwsch_long_delayed_pause = %u\n", 3570 htt_stats_buf->hwsch_long_delayed_pause); 3571 len += scnprintf(buf + len, buf_len - len, "sch_rx_ppdu_no_response = %u\n", 3572 htt_stats_buf->sch_rx_ppdu_no_response); 3573 len += scnprintf(buf + len, buf_len - len, "sch_selfgen_response = %u\n", 3574 htt_stats_buf->sch_selfgen_response); 3575 len += scnprintf(buf + len, buf_len - len, "sch_rx_sifs_resp_trigger= %u\n\n", 3576 htt_stats_buf->sch_rx_sifs_resp_trigger); 3577 3578 if (len >= buf_len) 3579 buf[buf_len - 1] = 0; 3580 else 3581 buf[len] = 0; 3582 3583 stats_req->buf_len = len; 3584} 3585 3586static inline void 3587htt_print_pdev_stats_twt_sessions_tlv(const void *tag_buf, 3588 struct debug_htt_stats_req *stats_req) 3589{ 3590 const struct htt_pdev_stats_twt_sessions_tlv *htt_stats_buf = tag_buf; 3591 u8 *buf = stats_req->buf; 3592 u32 len = stats_req->buf_len; 3593 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3594 3595 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_STATS_TWT_SESSIONS_TLV:\n"); 3596 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 3597 htt_stats_buf->pdev_id); 3598 len += scnprintf(buf + len, buf_len - len, "num_sessions = %u\n\n", 3599 htt_stats_buf->num_sessions); 3600 3601 if (len >= buf_len) 3602 buf[buf_len - 1] = 0; 3603 else 3604 buf[len] = 0; 3605 3606 stats_req->buf_len = len; 3607} 3608 3609static inline void 3610htt_print_pdev_stats_twt_session_tlv(const void *tag_buf, 3611 struct debug_htt_stats_req *stats_req) 3612{ 3613 const struct htt_pdev_stats_twt_session_tlv *htt_stats_buf = tag_buf; 3614 u8 *buf = stats_req->buf; 3615 u32 len = stats_req->buf_len; 3616 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3617 3618 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_STATS_TWT_SESSION_TLV:\n"); 3619 len += scnprintf(buf + len, buf_len - len, "vdev_id = %u\n", 3620 htt_stats_buf->vdev_id); 3621 len += scnprintf(buf + len, buf_len - len, 3622 "peer_mac = %02lx:%02lx:%02lx:%02lx:%02lx:%02lx\n", 3623 FIELD_GET(HTT_MAC_ADDR_L32_0, 3624 htt_stats_buf->peer_mac.mac_addr_l32), 3625 FIELD_GET(HTT_MAC_ADDR_L32_1, 3626 htt_stats_buf->peer_mac.mac_addr_l32), 3627 FIELD_GET(HTT_MAC_ADDR_L32_2, 3628 htt_stats_buf->peer_mac.mac_addr_l32), 3629 FIELD_GET(HTT_MAC_ADDR_L32_3, 3630 htt_stats_buf->peer_mac.mac_addr_l32), 3631 FIELD_GET(HTT_MAC_ADDR_H16_0, 3632 htt_stats_buf->peer_mac.mac_addr_h16), 3633 FIELD_GET(HTT_MAC_ADDR_H16_1, 3634 htt_stats_buf->peer_mac.mac_addr_h16)); 3635 len += scnprintf(buf + len, buf_len - len, "flow_id_flags = %u\n", 3636 htt_stats_buf->flow_id_flags); 3637 len += scnprintf(buf + len, buf_len - len, "dialog_id = %u\n", 3638 htt_stats_buf->dialog_id); 3639 len += scnprintf(buf + len, buf_len - len, "wake_dura_us = %u\n", 3640 htt_stats_buf->wake_dura_us); 3641 len += scnprintf(buf + len, buf_len - len, "wake_intvl_us = %u\n", 3642 htt_stats_buf->wake_intvl_us); 3643 len += scnprintf(buf + len, buf_len - len, "sp_offset_us = %u\n\n", 3644 htt_stats_buf->sp_offset_us); 3645 3646 if (len >= buf_len) 3647 buf[buf_len - 1] = 0; 3648 else 3649 buf[len] = 0; 3650 3651 stats_req->buf_len = len; 3652} 3653 3654static inline void 3655htt_print_pdev_obss_pd_stats_tlv_v(const void *tag_buf, 3656 struct debug_htt_stats_req *stats_req) 3657{ 3658 const struct htt_pdev_obss_pd_stats_tlv *htt_stats_buf = tag_buf; 3659 u8 *buf = stats_req->buf; 3660 u32 len = stats_req->buf_len; 3661 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3662 3663 len += scnprintf(buf + len, buf_len - len, "OBSS Tx success PPDU = %u\n", 3664 htt_stats_buf->num_obss_tx_ppdu_success); 3665 len += scnprintf(buf + len, buf_len - len, "OBSS Tx failures PPDU = %u\n", 3666 htt_stats_buf->num_obss_tx_ppdu_failure); 3667 len += scnprintf(buf + len, buf_len - len, "Non-SRG Opportunities = %u\n", 3668 htt_stats_buf->num_non_srg_opportunities); 3669 len += scnprintf(buf + len, buf_len - len, "Non-SRG tried PPDU = %u\n", 3670 htt_stats_buf->num_non_srg_ppdu_tried); 3671 len += scnprintf(buf + len, buf_len - len, "Non-SRG success PPDU = %u\n", 3672 htt_stats_buf->num_non_srg_ppdu_success); 3673 len += scnprintf(buf + len, buf_len - len, "SRG Opportunities = %u\n", 3674 htt_stats_buf->num_srg_opportunities); 3675 len += scnprintf(buf + len, buf_len - len, "SRG tried PPDU = %u\n", 3676 htt_stats_buf->num_srg_ppdu_tried); 3677 len += scnprintf(buf + len, buf_len - len, "SRG success PPDU = %u\n\n", 3678 htt_stats_buf->num_srg_ppdu_success); 3679 3680 if (len >= buf_len) 3681 buf[buf_len - 1] = 0; 3682 else 3683 buf[len] = 0; 3684 3685 stats_req->buf_len = len; 3686} 3687 3688static inline void htt_print_backpressure_stats_tlv_v(const u32 *tag_buf, 3689 u8 *data) 3690{ 3691 struct debug_htt_stats_req *stats_req = 3692 (struct debug_htt_stats_req *)data; 3693 struct htt_ring_backpressure_stats_tlv *htt_stats_buf = 3694 (struct htt_ring_backpressure_stats_tlv *)tag_buf; 3695 int i; 3696 u8 *buf = stats_req->buf; 3697 u32 len = stats_req->buf_len; 3698 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3699 3700 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 3701 htt_stats_buf->pdev_id); 3702 len += scnprintf(buf + len, buf_len - len, "current_head_idx = %u\n", 3703 htt_stats_buf->current_head_idx); 3704 len += scnprintf(buf + len, buf_len - len, "current_tail_idx = %u\n", 3705 htt_stats_buf->current_tail_idx); 3706 len += scnprintf(buf + len, buf_len - len, "num_htt_msgs_sent = %u\n", 3707 htt_stats_buf->num_htt_msgs_sent); 3708 len += scnprintf(buf + len, buf_len - len, 3709 "backpressure_time_ms = %u\n", 3710 htt_stats_buf->backpressure_time_ms); 3711 3712 for (i = 0; i < 5; i++) 3713 len += scnprintf(buf + len, buf_len - len, 3714 "backpressure_hist_%u = %u\n", 3715 i + 1, htt_stats_buf->backpressure_hist[i]); 3716 3717 len += scnprintf(buf + len, buf_len - len, 3718 "============================\n"); 3719 3720 if (len >= buf_len) { 3721 buf[buf_len - 1] = 0; 3722 stats_req->buf_len = buf_len - 1; 3723 } else { 3724 buf[len] = 0; 3725 stats_req->buf_len = len; 3726 } 3727} 3728 3729static inline 3730void htt_print_pdev_tx_rate_txbf_stats_tlv(const void *tag_buf, 3731 struct debug_htt_stats_req *stats_req) 3732{ 3733 const struct htt_pdev_txrate_txbf_stats_tlv *htt_stats_buf = tag_buf; 3734 u8 *buf = stats_req->buf; 3735 u32 len = stats_req->buf_len; 3736 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3737 int i; 3738 3739 len += scnprintf(buf + len, buf_len - len, 3740 "HTT_STATS_PDEV_TX_RATE_TXBF_STATS:\n"); 3741 3742 len += scnprintf(buf + len, buf_len - len, "tx_ol_mcs = "); 3743 for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++) 3744 len += scnprintf(buf + len, buf_len - len, 3745 "%d:%u,", i, htt_stats_buf->tx_su_ol_mcs[i]); 3746 len--; 3747 3748 len += scnprintf(buf + len, buf_len - len, "\ntx_ibf_mcs = "); 3749 for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++) 3750 len += scnprintf(buf + len, buf_len - len, 3751 "%d:%u,", i, htt_stats_buf->tx_su_ibf_mcs[i]); 3752 len--; 3753 3754 len += scnprintf(buf + len, buf_len - len, "\ntx_txbf_mcs ="); 3755 for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++) 3756 len += scnprintf(buf + len, buf_len - len, 3757 "%d:%u,", i, htt_stats_buf->tx_su_txbf_mcs[i]); 3758 len--; 3759 3760 len += scnprintf(buf + len, buf_len - len, "\ntx_ol_nss = "); 3761 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++) 3762 len += scnprintf(buf + len, buf_len - len, 3763 "%d:%u,", i, htt_stats_buf->tx_su_ol_nss[i]); 3764 len--; 3765 3766 len += scnprintf(buf + len, buf_len - len, "\ntx_ibf_nss = "); 3767 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++) 3768 len += scnprintf(buf + len, buf_len - len, 3769 "%d:%u,", i, htt_stats_buf->tx_su_ibf_nss[i]); 3770 len--; 3771 3772 len += scnprintf(buf + len, buf_len - len, "\ntx_txbf_nss = "); 3773 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++) 3774 len += scnprintf(buf + len, buf_len - len, 3775 "%d:%u,", i, htt_stats_buf->tx_su_txbf_nss[i]); 3776 len--; 3777 3778 len += scnprintf(buf + len, buf_len - len, "\ntx_ol_bw = "); 3779 for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++) 3780 len += scnprintf(buf + len, buf_len - len, 3781 "%d:%u,", i, htt_stats_buf->tx_su_ol_bw[i]); 3782 len--; 3783 3784 len += scnprintf(buf + len, buf_len - len, "\ntx_ibf_bw = "); 3785 for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++) 3786 len += scnprintf(buf + len, buf_len - len, 3787 "%d:%u,", i, htt_stats_buf->tx_su_ibf_bw[i]); 3788 len--; 3789 3790 len += scnprintf(buf + len, buf_len - len, "\ntx_txbf_bw = "); 3791 for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++) 3792 len += scnprintf(buf + len, buf_len - len, 3793 "%d:%u,", i, htt_stats_buf->tx_su_txbf_bw[i]); 3794 len--; 3795 3796 len += scnprintf(buf + len, buf_len - len, "\n"); 3797 3798 stats_req->buf_len = len; 3799} 3800 3801static inline 3802void htt_print_txbf_ofdma_ndpa_stats_tlv(const void *tag_buf, 3803 struct debug_htt_stats_req *stats_req) 3804{ 3805 const struct htt_txbf_ofdma_ndpa_stats_tlv *htt_stats_buf = tag_buf; 3806 u8 *buf = stats_req->buf; 3807 u32 len = stats_req->buf_len; 3808 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3809 int i; 3810 3811 len += scnprintf(buf + len, buf_len - len, 3812 "HTT_TXBF_OFDMA_NDPA_STATS_TLV:\n"); 3813 3814 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) { 3815 len += scnprintf(buf + len, buf_len - len, 3816 "ax_ofdma_ndpa_queued_user%d = %u\n", 3817 i, htt_stats_buf->ax_ofdma_ndpa_queued[i]); 3818 len += scnprintf(buf + len, buf_len - len, 3819 "ax_ofdma_ndpa_tried_user%d = %u\n", 3820 i, htt_stats_buf->ax_ofdma_ndpa_tried[i]); 3821 len += scnprintf(buf + len, buf_len - len, 3822 "ax_ofdma_ndpa_flushed_user%d = %u\n", 3823 i, htt_stats_buf->ax_ofdma_ndpa_flushed[i]); 3824 len += scnprintf(buf + len, buf_len - len, 3825 "ax_ofdma_ndpa_err_user%d = %u\n", 3826 i, htt_stats_buf->ax_ofdma_ndpa_err[i]); 3827 len += scnprintf(buf + len, buf_len - len, "\n"); 3828 } 3829 3830 stats_req->buf_len = len; 3831} 3832 3833static inline 3834void htt_print_txbf_ofdma_ndp_stats_tlv(const void *tag_buf, 3835 struct debug_htt_stats_req *stats_req) 3836{ 3837 const struct htt_txbf_ofdma_ndp_stats_tlv *htt_stats_buf = tag_buf; 3838 u8 *buf = stats_req->buf; 3839 u32 len = stats_req->buf_len; 3840 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3841 int i; 3842 3843 len += scnprintf(buf + len, buf_len - len, 3844 "HTT_TXBF_OFDMA_NDP_STATS_TLV:\n"); 3845 3846 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) { 3847 len += scnprintf(buf + len, buf_len - len, 3848 "ax_ofdma_ndp_queued_user%d = %u\n", 3849 i, htt_stats_buf->ax_ofdma_ndp_queued[i]); 3850 len += scnprintf(buf + len, buf_len - len, 3851 "ax_ofdma_ndp_tried_user%d = %u\n", 3852 i, htt_stats_buf->ax_ofdma_ndp_tried[i]); 3853 len += scnprintf(buf + len, buf_len - len, 3854 "ax_ofdma_ndp_flushed_user%d = %u\n", 3855 i, htt_stats_buf->ax_ofdma_ndp_flushed[i]); 3856 len += scnprintf(buf + len, buf_len - len, 3857 "ax_ofdma_ndp_err_user%d = %u\n", 3858 i, htt_stats_buf->ax_ofdma_ndp_err[i]); 3859 len += scnprintf(buf + len, buf_len - len, "\n"); 3860 } 3861 3862 stats_req->buf_len = len; 3863} 3864 3865static inline 3866void htt_print_txbf_ofdma_brp_stats_tlv(const void *tag_buf, 3867 struct debug_htt_stats_req *stats_req) 3868{ 3869 const struct htt_txbf_ofdma_brp_stats_tlv *htt_stats_buf = tag_buf; 3870 u8 *buf = stats_req->buf; 3871 u32 len = stats_req->buf_len; 3872 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3873 int i; 3874 3875 len += scnprintf(buf + len, buf_len - len, 3876 "HTT_TXBF_OFDMA_BRP_STATS_TLV:\n"); 3877 3878 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) { 3879 len += scnprintf(buf + len, buf_len - len, 3880 "ax_ofdma_brpoll_queued_user%d = %u\n", 3881 i, htt_stats_buf->ax_ofdma_brpoll_queued[i]); 3882 len += scnprintf(buf + len, buf_len - len, 3883 "ax_ofdma_brpoll_tried_user%d = %u\n", 3884 i, htt_stats_buf->ax_ofdma_brpoll_tried[i]); 3885 len += scnprintf(buf + len, buf_len - len, 3886 "ax_ofdma_brpoll_flushed_user%d = %u\n", 3887 i, htt_stats_buf->ax_ofdma_brpoll_flushed[i]); 3888 len += scnprintf(buf + len, buf_len - len, 3889 "ax_ofdma_brp_err_user%d = %u\n", 3890 i, htt_stats_buf->ax_ofdma_brp_err[i]); 3891 len += scnprintf(buf + len, buf_len - len, 3892 "ax_ofdma_brp_err_num_cbf_rcvd_user%d = %u\n", 3893 i, htt_stats_buf->ax_ofdma_brp_err_num_cbf_rcvd[i]); 3894 len += scnprintf(buf + len, buf_len - len, "\n"); 3895 } 3896 3897 stats_req->buf_len = len; 3898} 3899 3900static inline 3901void htt_print_txbf_ofdma_steer_stats_tlv(const void *tag_buf, 3902 struct debug_htt_stats_req *stats_req) 3903{ 3904 const struct htt_txbf_ofdma_steer_stats_tlv *htt_stats_buf = tag_buf; 3905 u8 *buf = stats_req->buf; 3906 u32 len = stats_req->buf_len; 3907 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3908 int i; 3909 3910 len += scnprintf(buf + len, buf_len - len, 3911 "HTT_TXBF_OFDMA_STEER_STATS_TLV:\n"); 3912 3913 for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) { 3914 len += scnprintf(buf + len, buf_len - len, 3915 "ax_ofdma_num_ppdu_steer_user%d = %u\n", 3916 i, htt_stats_buf->ax_ofdma_num_ppdu_steer[i]); 3917 len += scnprintf(buf + len, buf_len - len, 3918 "ax_ofdma_num_ppdu_ol_user%d = %u\n", 3919 i, htt_stats_buf->ax_ofdma_num_ppdu_ol[i]); 3920 len += scnprintf(buf + len, buf_len - len, 3921 "ax_ofdma_num_usrs_prefetch_user%d = %u\n", 3922 i, htt_stats_buf->ax_ofdma_num_usrs_prefetch[i]); 3923 len += scnprintf(buf + len, buf_len - len, 3924 "ax_ofdma_num_usrs_sound_user%d = %u\n", 3925 i, htt_stats_buf->ax_ofdma_num_usrs_sound[i]); 3926 len += scnprintf(buf + len, buf_len - len, 3927 "ax_ofdma_num_usrs_force_sound_user%d = %u\n", 3928 i, htt_stats_buf->ax_ofdma_num_usrs_force_sound[i]); 3929 len += scnprintf(buf + len, buf_len - len, "\n"); 3930 } 3931 3932 stats_req->buf_len = len; 3933} 3934 3935static inline 3936void htt_print_phy_counters_tlv(const void *tag_buf, 3937 struct debug_htt_stats_req *stats_req) 3938{ 3939 const struct htt_phy_counters_tlv *htt_stats_buf = tag_buf; 3940 u8 *buf = stats_req->buf; 3941 u32 len = stats_req->buf_len; 3942 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3943 int i; 3944 3945 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_COUNTERS_TLV:\n"); 3946 len += scnprintf(buf + len, buf_len - len, "rx_ofdma_timing_err_cnt = %u\n", 3947 htt_stats_buf->rx_ofdma_timing_err_cnt); 3948 len += scnprintf(buf + len, buf_len - len, "rx_cck_fail_cnt = %u\n", 3949 htt_stats_buf->rx_cck_fail_cnt); 3950 len += scnprintf(buf + len, buf_len - len, "mactx_abort_cnt = %u\n", 3951 htt_stats_buf->mactx_abort_cnt); 3952 len += scnprintf(buf + len, buf_len - len, "macrx_abort_cnt = %u\n", 3953 htt_stats_buf->macrx_abort_cnt); 3954 len += scnprintf(buf + len, buf_len - len, "phytx_abort_cnt = %u\n", 3955 htt_stats_buf->phytx_abort_cnt); 3956 len += scnprintf(buf + len, buf_len - len, "phyrx_abort_cnt = %u\n", 3957 htt_stats_buf->phyrx_abort_cnt); 3958 len += scnprintf(buf + len, buf_len - len, "phyrx_defer_abort_cnt = %u\n", 3959 htt_stats_buf->phyrx_defer_abort_cnt); 3960 len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_lstf_event_cnt = %u\n", 3961 htt_stats_buf->rx_gain_adj_lstf_event_cnt); 3962 len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_non_legacy_cnt = %u\n", 3963 htt_stats_buf->rx_gain_adj_non_legacy_cnt); 3964 3965 for (i = 0; i < HTT_MAX_RX_PKT_CNT; i++) 3966 len += scnprintf(buf + len, buf_len - len, "rx_pkt_cnt[%d] = %u\n", 3967 i, htt_stats_buf->rx_pkt_cnt[i]); 3968 3969 for (i = 0; i < HTT_MAX_RX_PKT_CRC_PASS_CNT; i++) 3970 len += scnprintf(buf + len, buf_len - len, 3971 "rx_pkt_crc_pass_cnt[%d] = %u\n", 3972 i, htt_stats_buf->rx_pkt_crc_pass_cnt[i]); 3973 3974 for (i = 0; i < HTT_MAX_PER_BLK_ERR_CNT; i++) 3975 len += scnprintf(buf + len, buf_len - len, 3976 "per_blk_err_cnt[%d] = %u\n", 3977 i, htt_stats_buf->per_blk_err_cnt[i]); 3978 3979 for (i = 0; i < HTT_MAX_RX_OTA_ERR_CNT; i++) 3980 len += scnprintf(buf + len, buf_len - len, 3981 "rx_ota_err_cnt[%d] = %u\n", 3982 i, htt_stats_buf->rx_ota_err_cnt[i]); 3983 3984 stats_req->buf_len = len; 3985} 3986 3987static inline 3988void htt_print_phy_stats_tlv(const void *tag_buf, 3989 struct debug_htt_stats_req *stats_req) 3990{ 3991 const struct htt_phy_stats_tlv *htt_stats_buf = tag_buf; 3992 u8 *buf = stats_req->buf; 3993 u32 len = stats_req->buf_len; 3994 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 3995 int i; 3996 3997 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_STATS_TLV:\n"); 3998 3999 for (i = 0; i < HTT_STATS_MAX_CHAINS; i++) 4000 len += scnprintf(buf + len, buf_len - len, "nf_chain[%d] = %d\n", 4001 i, htt_stats_buf->nf_chain[i]); 4002 4003 len += scnprintf(buf + len, buf_len - len, "false_radar_cnt = %u\n", 4004 htt_stats_buf->false_radar_cnt); 4005 len += scnprintf(buf + len, buf_len - len, "radar_cs_cnt = %u\n", 4006 htt_stats_buf->radar_cs_cnt); 4007 len += scnprintf(buf + len, buf_len - len, "ani_level = %d\n", 4008 htt_stats_buf->ani_level); 4009 len += scnprintf(buf + len, buf_len - len, "fw_run_time = %u\n", 4010 htt_stats_buf->fw_run_time); 4011 4012 stats_req->buf_len = len; 4013} 4014 4015static inline void 4016htt_print_phy_reset_counters_tlv(const void *tag_buf, 4017 u16 tag_len, 4018 struct debug_htt_stats_req *stats_req) 4019{ 4020 const struct htt_phy_reset_counters_tlv *htt_stats_buf = tag_buf; 4021 u8 *buf = stats_req->buf; 4022 u32 len = stats_req->buf_len; 4023 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 4024 4025 if (tag_len < sizeof(*htt_stats_buf)) 4026 return; 4027 4028 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_COUNTERS_TLV:\n"); 4029 4030 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 4031 htt_stats_buf->pdev_id); 4032 len += scnprintf(buf + len, buf_len - len, "cf_active_low_fail_cnt = %u\n", 4033 htt_stats_buf->cf_active_low_fail_cnt); 4034 len += scnprintf(buf + len, buf_len - len, "cf_active_low_pass_cnt = %u\n", 4035 htt_stats_buf->cf_active_low_pass_cnt); 4036 len += scnprintf(buf + len, buf_len - len, "phy_off_through_vreg_cnt = %u\n", 4037 htt_stats_buf->phy_off_through_vreg_cnt); 4038 len += scnprintf(buf + len, buf_len - len, "force_calibration_cnt = %u\n", 4039 htt_stats_buf->force_calibration_cnt); 4040 len += scnprintf(buf + len, buf_len - len, "rf_mode_switch_phy_off_cnt = %u\n", 4041 htt_stats_buf->rf_mode_switch_phy_off_cnt); 4042 4043 stats_req->buf_len = len; 4044} 4045 4046static inline void 4047htt_print_phy_reset_stats_tlv(const void *tag_buf, 4048 u16 tag_len, 4049 struct debug_htt_stats_req *stats_req) 4050{ 4051 const struct htt_phy_reset_stats_tlv *htt_stats_buf = tag_buf; 4052 u8 *buf = stats_req->buf; 4053 u32 len = stats_req->buf_len; 4054 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 4055 4056 if (tag_len < sizeof(*htt_stats_buf)) 4057 return; 4058 4059 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_STATS_TLV:\n"); 4060 4061 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 4062 htt_stats_buf->pdev_id); 4063 len += scnprintf(buf + len, buf_len - len, "chan_mhz = %u\n", 4064 htt_stats_buf->chan_mhz); 4065 len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq1 = %u\n", 4066 htt_stats_buf->chan_band_center_freq1); 4067 len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq2 = %u\n", 4068 htt_stats_buf->chan_band_center_freq2); 4069 len += scnprintf(buf + len, buf_len - len, "chan_phy_mode = %u\n", 4070 htt_stats_buf->chan_phy_mode); 4071 len += scnprintf(buf + len, buf_len - len, "chan_flags = 0x%0x\n", 4072 htt_stats_buf->chan_flags); 4073 len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n", 4074 htt_stats_buf->chan_num); 4075 len += scnprintf(buf + len, buf_len - len, "reset_cause = 0x%0x\n", 4076 htt_stats_buf->reset_cause); 4077 len += scnprintf(buf + len, buf_len - len, "prev_reset_cause = 0x%0x\n", 4078 htt_stats_buf->prev_reset_cause); 4079 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_src = 0x%0x\n", 4080 htt_stats_buf->phy_warm_reset_src); 4081 len += scnprintf(buf + len, buf_len - len, "rx_gain_tbl_mode = %d\n", 4082 htt_stats_buf->rx_gain_tbl_mode); 4083 len += scnprintf(buf + len, buf_len - len, "xbar_val = 0x%0x\n", 4084 htt_stats_buf->xbar_val); 4085 len += scnprintf(buf + len, buf_len - len, "force_calibration = %u\n", 4086 htt_stats_buf->force_calibration); 4087 len += scnprintf(buf + len, buf_len - len, "phyrf_mode = %u\n", 4088 htt_stats_buf->phyrf_mode); 4089 len += scnprintf(buf + len, buf_len - len, "phy_homechan = %u\n", 4090 htt_stats_buf->phy_homechan); 4091 len += scnprintf(buf + len, buf_len - len, "phy_tx_ch_mask = 0x%0x\n", 4092 htt_stats_buf->phy_tx_ch_mask); 4093 len += scnprintf(buf + len, buf_len - len, "phy_rx_ch_mask = 0x%0x\n", 4094 htt_stats_buf->phy_rx_ch_mask); 4095 len += scnprintf(buf + len, buf_len - len, "phybb_ini_mask = 0x%0x\n", 4096 htt_stats_buf->phybb_ini_mask); 4097 len += scnprintf(buf + len, buf_len - len, "phyrf_ini_mask = 0x%0x\n", 4098 htt_stats_buf->phyrf_ini_mask); 4099 len += scnprintf(buf + len, buf_len - len, "phy_dfs_en_mask = 0x%0x\n", 4100 htt_stats_buf->phy_dfs_en_mask); 4101 len += scnprintf(buf + len, buf_len - len, "phy_sscan_en_mask = 0x%0x\n", 4102 htt_stats_buf->phy_sscan_en_mask); 4103 len += scnprintf(buf + len, buf_len - len, "phy_synth_sel_mask = 0x%0x\n", 4104 htt_stats_buf->phy_synth_sel_mask); 4105 len += scnprintf(buf + len, buf_len - len, "phy_adfs_freq = %u\n", 4106 htt_stats_buf->phy_adfs_freq); 4107 len += scnprintf(buf + len, buf_len - len, "cck_fir_settings = 0x%0x\n", 4108 htt_stats_buf->cck_fir_settings); 4109 len += scnprintf(buf + len, buf_len - len, "phy_dyn_pri_chan = %u\n", 4110 htt_stats_buf->phy_dyn_pri_chan); 4111 len += scnprintf(buf + len, buf_len - len, "cca_thresh = 0x%0x\n", 4112 htt_stats_buf->cca_thresh); 4113 len += scnprintf(buf + len, buf_len - len, "dyn_cca_status = %u\n", 4114 htt_stats_buf->dyn_cca_status); 4115 len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_hw = 0x%x\n", 4116 htt_stats_buf->rxdesense_thresh_hw); 4117 len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_sw = 0x%x\n", 4118 htt_stats_buf->rxdesense_thresh_sw); 4119 4120 stats_req->buf_len = len; 4121} 4122 4123static inline 4124void htt_print_peer_ctrl_path_txrx_stats_tlv(const void *tag_buf, 4125 struct debug_htt_stats_req *stats_req) 4126{ 4127 const struct htt_peer_ctrl_path_txrx_stats_tlv *htt_stat_buf = tag_buf; 4128 u8 *buf = stats_req->buf; 4129 u32 len = stats_req->buf_len; 4130 u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE; 4131 int i; 4132 const char *mgmt_frm_type[ATH11K_STATS_MGMT_FRM_TYPE_MAX - 1] = { 4133 "assoc_req", "assoc_resp", 4134 "reassoc_req", "reassoc_resp", 4135 "probe_req", "probe_resp", 4136 "timing_advertisement", "reserved", 4137 "beacon", "atim", "disassoc", 4138 "auth", "deauth", "action", "action_no_ack"}; 4139 4140 len += scnprintf(buf + len, buf_len - len, 4141 "HTT_STATS_PEER_CTRL_PATH_TXRX_STATS_TAG:\n"); 4142 len += scnprintf(buf + len, buf_len - len, 4143 "peer_mac_addr = %02x:%02x:%02x:%02x:%02x:%02x\n", 4144 htt_stat_buf->peer_mac_addr[0], htt_stat_buf->peer_mac_addr[1], 4145 htt_stat_buf->peer_mac_addr[2], htt_stat_buf->peer_mac_addr[3], 4146 htt_stat_buf->peer_mac_addr[4], htt_stat_buf->peer_mac_addr[5]); 4147 4148 len += scnprintf(buf + len, buf_len - len, "peer_tx_mgmt_subtype:\n"); 4149 for (i = 0; i < ATH11K_STATS_MGMT_FRM_TYPE_MAX - 1; i++) 4150 len += scnprintf(buf + len, buf_len - len, "%s:%u\n", 4151 mgmt_frm_type[i], 4152 htt_stat_buf->peer_rx_mgmt_subtype[i]); 4153 4154 len += scnprintf(buf + len, buf_len - len, "peer_rx_mgmt_subtype:\n"); 4155 for (i = 0; i < ATH11K_STATS_MGMT_FRM_TYPE_MAX - 1; i++) 4156 len += scnprintf(buf + len, buf_len - len, "%s:%u\n", 4157 mgmt_frm_type[i], 4158 htt_stat_buf->peer_rx_mgmt_subtype[i]); 4159 4160 len += scnprintf(buf + len, buf_len - len, "\n"); 4161 4162 stats_req->buf_len = len; 4163} 4164 4165static int ath11k_dbg_htt_ext_stats_parse(struct ath11k_base *ab, 4166 u16 tag, u16 len, const void *tag_buf, 4167 void *user_data) 4168{ 4169 struct debug_htt_stats_req *stats_req = user_data; 4170 4171 switch (tag) { 4172 case HTT_STATS_TX_PDEV_CMN_TAG: 4173 htt_print_tx_pdev_stats_cmn_tlv(tag_buf, stats_req); 4174 break; 4175 case HTT_STATS_TX_PDEV_UNDERRUN_TAG: 4176 htt_print_tx_pdev_stats_urrn_tlv_v(tag_buf, len, stats_req); 4177 break; 4178 case HTT_STATS_TX_PDEV_SIFS_TAG: 4179 htt_print_tx_pdev_stats_sifs_tlv_v(tag_buf, len, stats_req); 4180 break; 4181 case HTT_STATS_TX_PDEV_FLUSH_TAG: 4182 htt_print_tx_pdev_stats_flush_tlv_v(tag_buf, len, stats_req); 4183 break; 4184 case HTT_STATS_TX_PDEV_PHY_ERR_TAG: 4185 htt_print_tx_pdev_stats_phy_err_tlv_v(tag_buf, len, stats_req); 4186 break; 4187 case HTT_STATS_TX_PDEV_SIFS_HIST_TAG: 4188 htt_print_tx_pdev_stats_sifs_hist_tlv_v(tag_buf, len, stats_req); 4189 break; 4190 4191 case HTT_STATS_TX_PDEV_TX_PPDU_STATS_TAG: 4192 htt_print_tx_pdev_stats_tx_ppdu_stats_tlv_v(tag_buf, stats_req); 4193 break; 4194 4195 case HTT_STATS_TX_PDEV_TRIED_MPDU_CNT_HIST_TAG: 4196 htt_print_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v(tag_buf, len, 4197 stats_req); 4198 break; 4199 4200 case HTT_STATS_STRING_TAG: 4201 htt_print_stats_string_tlv(tag_buf, len, stats_req); 4202 break; 4203 4204 case HTT_STATS_TX_HWQ_CMN_TAG: 4205 htt_print_tx_hwq_stats_cmn_tlv(tag_buf, stats_req); 4206 break; 4207 4208 case HTT_STATS_TX_HWQ_DIFS_LATENCY_TAG: 4209 htt_print_tx_hwq_difs_latency_stats_tlv_v(tag_buf, len, stats_req); 4210 break; 4211 4212 case HTT_STATS_TX_HWQ_CMD_RESULT_TAG: 4213 htt_print_tx_hwq_cmd_result_stats_tlv_v(tag_buf, len, stats_req); 4214 break; 4215 4216 case HTT_STATS_TX_HWQ_CMD_STALL_TAG: 4217 htt_print_tx_hwq_cmd_stall_stats_tlv_v(tag_buf, len, stats_req); 4218 break; 4219 4220 case HTT_STATS_TX_HWQ_FES_STATUS_TAG: 4221 htt_print_tx_hwq_fes_result_stats_tlv_v(tag_buf, len, stats_req); 4222 break; 4223 4224 case HTT_STATS_TX_HWQ_TRIED_MPDU_CNT_HIST_TAG: 4225 htt_print_tx_hwq_tried_mpdu_cnt_hist_tlv_v(tag_buf, len, stats_req); 4226 break; 4227 4228 case HTT_STATS_TX_HWQ_TXOP_USED_CNT_HIST_TAG: 4229 htt_print_tx_hwq_txop_used_cnt_hist_tlv_v(tag_buf, len, stats_req); 4230 break; 4231 case HTT_STATS_TX_TQM_GEN_MPDU_TAG: 4232 htt_print_tx_tqm_gen_mpdu_stats_tlv_v(tag_buf, len, stats_req); 4233 break; 4234 4235 case HTT_STATS_TX_TQM_LIST_MPDU_TAG: 4236 htt_print_tx_tqm_list_mpdu_stats_tlv_v(tag_buf, len, stats_req); 4237 break; 4238 4239 case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG: 4240 htt_print_tx_tqm_list_mpdu_cnt_tlv_v(tag_buf, len, stats_req); 4241 break; 4242 4243 case HTT_STATS_TX_TQM_CMN_TAG: 4244 htt_print_tx_tqm_cmn_stats_tlv(tag_buf, stats_req); 4245 break; 4246 4247 case HTT_STATS_TX_TQM_PDEV_TAG: 4248 htt_print_tx_tqm_pdev_stats_tlv_v(tag_buf, stats_req); 4249 break; 4250 4251 case HTT_STATS_TX_TQM_CMDQ_STATUS_TAG: 4252 htt_print_tx_tqm_cmdq_status_tlv(tag_buf, stats_req); 4253 break; 4254 4255 case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG: 4256 htt_print_tx_de_eapol_packets_stats_tlv(tag_buf, stats_req); 4257 break; 4258 4259 case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG: 4260 htt_print_tx_de_classify_failed_stats_tlv(tag_buf, stats_req); 4261 break; 4262 4263 case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG: 4264 htt_print_tx_de_classify_stats_tlv(tag_buf, stats_req); 4265 break; 4266 4267 case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG: 4268 htt_print_tx_de_classify_status_stats_tlv(tag_buf, stats_req); 4269 break; 4270 4271 case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG: 4272 htt_print_tx_de_enqueue_packets_stats_tlv(tag_buf, stats_req); 4273 break; 4274 4275 case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG: 4276 htt_print_tx_de_enqueue_discard_stats_tlv(tag_buf, stats_req); 4277 break; 4278 4279 case HTT_STATS_TX_DE_FW2WBM_RING_FULL_HIST_TAG: 4280 htt_print_tx_de_fw2wbm_ring_full_hist_tlv(tag_buf, len, stats_req); 4281 break; 4282 4283 case HTT_STATS_TX_DE_CMN_TAG: 4284 htt_print_tx_de_cmn_stats_tlv(tag_buf, stats_req); 4285 break; 4286 4287 case HTT_STATS_RING_IF_TAG: 4288 htt_print_ring_if_stats_tlv(tag_buf, stats_req); 4289 break; 4290 4291 case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG: 4292 htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, stats_req); 4293 break; 4294 4295 case HTT_STATS_SFM_CMN_TAG: 4296 htt_print_sfm_cmn_tlv(tag_buf, stats_req); 4297 break; 4298 4299 case HTT_STATS_SRING_STATS_TAG: 4300 htt_print_sring_stats_tlv(tag_buf, stats_req); 4301 break; 4302 4303 case HTT_STATS_RX_PDEV_FW_STATS_TAG: 4304 htt_print_rx_pdev_fw_stats_tlv(tag_buf, stats_req); 4305 break; 4306 4307 case HTT_STATS_RX_PDEV_FW_RING_MPDU_ERR_TAG: 4308 htt_print_rx_pdev_fw_ring_mpdu_err_tlv_v(tag_buf, stats_req); 4309 break; 4310 4311 case HTT_STATS_RX_PDEV_FW_MPDU_DROP_TAG: 4312 htt_print_rx_pdev_fw_mpdu_drop_tlv_v(tag_buf, len, stats_req); 4313 break; 4314 4315 case HTT_STATS_RX_SOC_FW_STATS_TAG: 4316 htt_print_rx_soc_fw_stats_tlv(tag_buf, stats_req); 4317 break; 4318 4319 case HTT_STATS_RX_SOC_FW_REFILL_RING_EMPTY_TAG: 4320 htt_print_rx_soc_fw_refill_ring_empty_tlv_v(tag_buf, len, stats_req); 4321 break; 4322 4323 case HTT_STATS_RX_SOC_FW_REFILL_RING_NUM_REFILL_TAG: 4324 htt_print_rx_soc_fw_refill_ring_num_refill_tlv_v( 4325 tag_buf, len, stats_req); 4326 break; 4327 case HTT_STATS_RX_REFILL_RXDMA_ERR_TAG: 4328 htt_print_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v( 4329 tag_buf, len, stats_req); 4330 break; 4331 4332 case HTT_STATS_RX_REFILL_REO_ERR_TAG: 4333 htt_print_rx_soc_fw_refill_ring_num_reo_err_tlv_v( 4334 tag_buf, len, stats_req); 4335 break; 4336 4337 case HTT_STATS_RX_REO_RESOURCE_STATS_TAG: 4338 htt_print_rx_reo_debug_stats_tlv_v( 4339 tag_buf, stats_req); 4340 break; 4341 case HTT_STATS_RX_PDEV_FW_STATS_PHY_ERR_TAG: 4342 htt_print_rx_pdev_fw_stats_phy_err_tlv(tag_buf, stats_req); 4343 break; 4344 4345 case HTT_STATS_TX_PDEV_RATE_STATS_TAG: 4346 htt_print_tx_pdev_rate_stats_tlv(tag_buf, stats_req); 4347 break; 4348 4349 case HTT_STATS_RX_PDEV_RATE_STATS_TAG: 4350 htt_print_rx_pdev_rate_stats_tlv(tag_buf, stats_req); 4351 break; 4352 4353 case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG: 4354 htt_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf, stats_req); 4355 break; 4356 case HTT_STATS_TX_SCHED_CMN_TAG: 4357 htt_print_stats_tx_sched_cmn_tlv(tag_buf, stats_req); 4358 break; 4359 4360 case HTT_STATS_TX_PDEV_MPDU_STATS_TAG: 4361 htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf, stats_req); 4362 break; 4363 4364 case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG: 4365 htt_print_sched_txq_cmd_posted_tlv_v(tag_buf, len, stats_req); 4366 break; 4367 4368 case HTT_STATS_RING_IF_CMN_TAG: 4369 htt_print_ring_if_cmn_tlv(tag_buf, stats_req); 4370 break; 4371 4372 case HTT_STATS_SFM_CLIENT_USER_TAG: 4373 htt_print_sfm_client_user_tlv_v(tag_buf, len, stats_req); 4374 break; 4375 4376 case HTT_STATS_SFM_CLIENT_TAG: 4377 htt_print_sfm_client_tlv(tag_buf, stats_req); 4378 break; 4379 4380 case HTT_STATS_TX_TQM_ERROR_STATS_TAG: 4381 htt_print_tx_tqm_error_stats_tlv(tag_buf, stats_req); 4382 break; 4383 4384 case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG: 4385 htt_print_sched_txq_cmd_reaped_tlv_v(tag_buf, len, stats_req); 4386 break; 4387 4388 case HTT_STATS_SRING_CMN_TAG: 4389 htt_print_sring_cmn_tlv(tag_buf, stats_req); 4390 break; 4391 4392 case HTT_STATS_TX_SOUNDING_STATS_TAG: 4393 htt_print_tx_sounding_stats_tlv(tag_buf, stats_req); 4394 break; 4395 4396 case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG: 4397 htt_print_tx_selfgen_ac_err_stats_tlv(tag_buf, stats_req); 4398 break; 4399 4400 case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG: 4401 htt_print_tx_selfgen_cmn_stats_tlv(tag_buf, stats_req); 4402 break; 4403 4404 case HTT_STATS_TX_SELFGEN_AC_STATS_TAG: 4405 htt_print_tx_selfgen_ac_stats_tlv(tag_buf, stats_req); 4406 break; 4407 4408 case HTT_STATS_TX_SELFGEN_AX_STATS_TAG: 4409 htt_print_tx_selfgen_ax_stats_tlv(tag_buf, stats_req); 4410 break; 4411 4412 case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG: 4413 htt_print_tx_selfgen_ax_err_stats_tlv(tag_buf, stats_req); 4414 break; 4415 4416 case HTT_STATS_TX_HWQ_MUMIMO_SCH_STATS_TAG: 4417 htt_print_tx_hwq_mu_mimo_sch_stats_tlv(tag_buf, stats_req); 4418 break; 4419 4420 case HTT_STATS_TX_HWQ_MUMIMO_MPDU_STATS_TAG: 4421 htt_print_tx_hwq_mu_mimo_mpdu_stats_tlv(tag_buf, stats_req); 4422 break; 4423 4424 case HTT_STATS_TX_HWQ_MUMIMO_CMN_STATS_TAG: 4425 htt_print_tx_hwq_mu_mimo_cmn_stats_tlv(tag_buf, stats_req); 4426 break; 4427 4428 case HTT_STATS_HW_INTR_MISC_TAG: 4429 htt_print_hw_stats_intr_misc_tlv(tag_buf, stats_req); 4430 break; 4431 4432 case HTT_STATS_HW_WD_TIMEOUT_TAG: 4433 htt_print_hw_stats_wd_timeout_tlv(tag_buf, stats_req); 4434 break; 4435 4436 case HTT_STATS_HW_PDEV_ERRS_TAG: 4437 htt_print_hw_stats_pdev_errs_tlv(tag_buf, stats_req); 4438 break; 4439 4440 case HTT_STATS_COUNTER_NAME_TAG: 4441 htt_print_counter_tlv(tag_buf, stats_req); 4442 break; 4443 4444 case HTT_STATS_TX_TID_DETAILS_TAG: 4445 htt_print_tx_tid_stats_tlv(tag_buf, stats_req); 4446 break; 4447 4448 case HTT_STATS_TX_TID_DETAILS_V1_TAG: 4449 htt_print_tx_tid_stats_v1_tlv(tag_buf, stats_req); 4450 break; 4451 4452 case HTT_STATS_RX_TID_DETAILS_TAG: 4453 htt_print_rx_tid_stats_tlv(tag_buf, stats_req); 4454 break; 4455 4456 case HTT_STATS_PEER_STATS_CMN_TAG: 4457 htt_print_peer_stats_cmn_tlv(tag_buf, stats_req); 4458 break; 4459 4460 case HTT_STATS_PEER_DETAILS_TAG: 4461 htt_print_peer_details_tlv(tag_buf, stats_req); 4462 break; 4463 4464 case HTT_STATS_PEER_MSDU_FLOWQ_TAG: 4465 htt_print_msdu_flow_stats_tlv(tag_buf, stats_req); 4466 break; 4467 4468 case HTT_STATS_PEER_TX_RATE_STATS_TAG: 4469 htt_print_tx_peer_rate_stats_tlv(tag_buf, stats_req); 4470 break; 4471 4472 case HTT_STATS_PEER_RX_RATE_STATS_TAG: 4473 htt_print_rx_peer_rate_stats_tlv(tag_buf, stats_req); 4474 break; 4475 4476 case HTT_STATS_TX_DE_COMPL_STATS_TAG: 4477 htt_print_tx_de_compl_stats_tlv(tag_buf, stats_req); 4478 break; 4479 4480 case HTT_STATS_PDEV_CCA_1SEC_HIST_TAG: 4481 case HTT_STATS_PDEV_CCA_100MSEC_HIST_TAG: 4482 case HTT_STATS_PDEV_CCA_STAT_CUMULATIVE_TAG: 4483 htt_print_pdev_cca_stats_hist_tlv(tag_buf, stats_req); 4484 break; 4485 4486 case HTT_STATS_PDEV_CCA_COUNTERS_TAG: 4487 htt_print_pdev_stats_cca_counters_tlv(tag_buf, stats_req); 4488 break; 4489 4490 case HTT_STATS_WHAL_TX_TAG: 4491 htt_print_hw_stats_whal_tx_tlv(tag_buf, stats_req); 4492 break; 4493 4494 case HTT_STATS_PDEV_TWT_SESSIONS_TAG: 4495 htt_print_pdev_stats_twt_sessions_tlv(tag_buf, stats_req); 4496 break; 4497 4498 case HTT_STATS_PDEV_TWT_SESSION_TAG: 4499 htt_print_pdev_stats_twt_session_tlv(tag_buf, stats_req); 4500 break; 4501 4502 case HTT_STATS_SCHED_TXQ_SCHED_ORDER_SU_TAG: 4503 htt_print_sched_txq_sched_order_su_tlv_v(tag_buf, len, stats_req); 4504 break; 4505 4506 case HTT_STATS_SCHED_TXQ_SCHED_INELIGIBILITY_TAG: 4507 htt_print_sched_txq_sched_ineligibility_tlv_v(tag_buf, len, stats_req); 4508 break; 4509 4510 case HTT_STATS_PDEV_OBSS_PD_TAG: 4511 htt_print_pdev_obss_pd_stats_tlv_v(tag_buf, stats_req); 4512 break; 4513 case HTT_STATS_RING_BACKPRESSURE_STATS_TAG: 4514 htt_print_backpressure_stats_tlv_v(tag_buf, user_data); 4515 break; 4516 case HTT_STATS_PDEV_TX_RATE_TXBF_STATS_TAG: 4517 htt_print_pdev_tx_rate_txbf_stats_tlv(tag_buf, stats_req); 4518 break; 4519 case HTT_STATS_TXBF_OFDMA_NDPA_STATS_TAG: 4520 htt_print_txbf_ofdma_ndpa_stats_tlv(tag_buf, stats_req); 4521 break; 4522 case HTT_STATS_TXBF_OFDMA_NDP_STATS_TAG: 4523 htt_print_txbf_ofdma_ndp_stats_tlv(tag_buf, stats_req); 4524 break; 4525 case HTT_STATS_TXBF_OFDMA_BRP_STATS_TAG: 4526 htt_print_txbf_ofdma_brp_stats_tlv(tag_buf, stats_req); 4527 break; 4528 case HTT_STATS_TXBF_OFDMA_STEER_STATS_TAG: 4529 htt_print_txbf_ofdma_steer_stats_tlv(tag_buf, stats_req); 4530 break; 4531 case HTT_STATS_PHY_COUNTERS_TAG: 4532 htt_print_phy_counters_tlv(tag_buf, stats_req); 4533 break; 4534 case HTT_STATS_PHY_STATS_TAG: 4535 htt_print_phy_stats_tlv(tag_buf, stats_req); 4536 break; 4537 case HTT_STATS_PHY_RESET_COUNTERS_TAG: 4538 htt_print_phy_reset_counters_tlv(tag_buf, len, stats_req); 4539 break; 4540 case HTT_STATS_PHY_RESET_STATS_TAG: 4541 htt_print_phy_reset_stats_tlv(tag_buf, len, stats_req); 4542 break; 4543 case HTT_STATS_PEER_CTRL_PATH_TXRX_STATS_TAG: 4544 htt_print_peer_ctrl_path_txrx_stats_tlv(tag_buf, stats_req); 4545 break; 4546 default: 4547 break; 4548 } 4549 4550 return 0; 4551} 4552 4553void ath11k_debugfs_htt_ext_stats_handler(struct ath11k_base *ab, 4554 struct sk_buff *skb) 4555{ 4556 struct ath11k_htt_extd_stats_msg *msg; 4557 struct debug_htt_stats_req *stats_req; 4558 struct ath11k *ar; 4559 u32 len; 4560 u64 cookie; 4561 int ret; 4562 bool send_completion = false; 4563 u8 pdev_id; 4564 4565 msg = (struct ath11k_htt_extd_stats_msg *)skb->data; 4566 cookie = msg->cookie; 4567 4568 if (FIELD_GET(HTT_STATS_COOKIE_MSB, cookie) != HTT_STATS_MAGIC_VALUE) { 4569 ath11k_warn(ab, "received invalid htt ext stats event\n"); 4570 return; 4571 } 4572 4573 pdev_id = FIELD_GET(HTT_STATS_COOKIE_LSB, cookie); 4574 rcu_read_lock(); 4575 ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id); 4576 rcu_read_unlock(); 4577 if (!ar) { 4578 ath11k_warn(ab, "failed to get ar for pdev_id %d\n", pdev_id); 4579 return; 4580 } 4581 4582 stats_req = ar->debug.htt_stats.stats_req; 4583 if (!stats_req) 4584 return; 4585 4586 spin_lock_bh(&ar->debug.htt_stats.lock); 4587 4588 stats_req->done = FIELD_GET(HTT_T2H_EXT_STATS_INFO1_DONE, msg->info1); 4589 if (stats_req->done) 4590 send_completion = true; 4591 4592 spin_unlock_bh(&ar->debug.htt_stats.lock); 4593 4594 len = FIELD_GET(HTT_T2H_EXT_STATS_INFO1_LENGTH, msg->info1); 4595 ret = ath11k_dp_htt_tlv_iter(ab, msg->data, len, 4596 ath11k_dbg_htt_ext_stats_parse, 4597 stats_req); 4598 if (ret) 4599 ath11k_warn(ab, "Failed to parse tlv %d\n", ret); 4600 4601 if (send_completion) 4602 complete(&stats_req->cmpln); 4603} 4604 4605static ssize_t ath11k_read_htt_stats_type(struct file *file, 4606 char __user *user_buf, 4607 size_t count, loff_t *ppos) 4608{ 4609 struct ath11k *ar = file->private_data; 4610 char buf[32]; 4611 size_t len; 4612 4613 len = scnprintf(buf, sizeof(buf), "%u\n", ar->debug.htt_stats.type); 4614 4615 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 4616} 4617 4618static ssize_t ath11k_write_htt_stats_type(struct file *file, 4619 const char __user *user_buf, 4620 size_t count, loff_t *ppos) 4621{ 4622 struct ath11k *ar = file->private_data; 4623 u8 type; 4624 int ret; 4625 4626 ret = kstrtou8_from_user(user_buf, count, 0, &type); 4627 if (ret) 4628 return ret; 4629 4630 if (type >= ATH11K_DBG_HTT_NUM_EXT_STATS) 4631 return -E2BIG; 4632 4633 if (type == ATH11K_DBG_HTT_EXT_STATS_RESET) 4634 return -EPERM; 4635 4636 ar->debug.htt_stats.type = type; 4637 4638 ret = count; 4639 4640 return ret; 4641} 4642 4643static const struct file_operations fops_htt_stats_type = { 4644 .read = ath11k_read_htt_stats_type, 4645 .write = ath11k_write_htt_stats_type, 4646 .open = simple_open, 4647 .owner = THIS_MODULE, 4648 .llseek = default_llseek, 4649}; 4650 4651static int ath11k_prep_htt_stats_cfg_params(struct ath11k *ar, u8 type, 4652 const u8 *mac_addr, 4653 struct htt_ext_stats_cfg_params *cfg_params) 4654{ 4655 if (!cfg_params) 4656 return -EINVAL; 4657 4658 switch (type) { 4659 case ATH11K_DBG_HTT_EXT_STATS_PDEV_TX_HWQ: 4660 case ATH11K_DBG_HTT_EXT_STATS_TX_MU_HWQ: 4661 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_HWQS; 4662 break; 4663 case ATH11K_DBG_HTT_EXT_STATS_PDEV_TX_SCHED: 4664 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_TXQS; 4665 break; 4666 case ATH11K_DBG_HTT_EXT_STATS_TQM_CMDQ: 4667 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_CMDQS; 4668 break; 4669 case ATH11K_DBG_HTT_EXT_STATS_PEER_INFO: 4670 cfg_params->cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR; 4671 cfg_params->cfg0 |= FIELD_PREP(GENMASK(15, 1), 4672 HTT_PEER_STATS_REQ_MODE_FLUSH_TQM); 4673 cfg_params->cfg1 = HTT_STAT_DEFAULT_PEER_REQ_TYPE; 4674 cfg_params->cfg2 |= FIELD_PREP(GENMASK(7, 0), mac_addr[0]); 4675 cfg_params->cfg2 |= FIELD_PREP(GENMASK(15, 8), mac_addr[1]); 4676 cfg_params->cfg2 |= FIELD_PREP(GENMASK(23, 16), mac_addr[2]); 4677 cfg_params->cfg2 |= FIELD_PREP(GENMASK(31, 24), mac_addr[3]); 4678 cfg_params->cfg3 |= FIELD_PREP(GENMASK(7, 0), mac_addr[4]); 4679 cfg_params->cfg3 |= FIELD_PREP(GENMASK(15, 8), mac_addr[5]); 4680 break; 4681 case ATH11K_DBG_HTT_EXT_STATS_RING_IF_INFO: 4682 case ATH11K_DBG_HTT_EXT_STATS_SRNG_INFO: 4683 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_RINGS; 4684 break; 4685 case ATH11K_DBG_HTT_EXT_STATS_ACTIVE_PEERS_LIST: 4686 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_PEERS; 4687 break; 4688 case ATH11K_DBG_HTT_EXT_STATS_PDEV_CCA_STATS: 4689 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_CCA_CUMULATIVE; 4690 break; 4691 case ATH11K_DBG_HTT_EXT_STATS_TX_SOUNDING_INFO: 4692 cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_VDEVS; 4693 break; 4694 case ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS: 4695 cfg_params->cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR; 4696 cfg_params->cfg1 |= FIELD_PREP(GENMASK(7, 0), mac_addr[0]); 4697 cfg_params->cfg1 |= FIELD_PREP(GENMASK(15, 8), mac_addr[1]); 4698 cfg_params->cfg1 |= FIELD_PREP(GENMASK(23, 16), mac_addr[2]); 4699 cfg_params->cfg1 |= FIELD_PREP(GENMASK(31, 24), mac_addr[3]); 4700 cfg_params->cfg2 |= FIELD_PREP(GENMASK(7, 0), mac_addr[4]); 4701 cfg_params->cfg2 |= FIELD_PREP(GENMASK(15, 8), mac_addr[5]); 4702 break; 4703 default: 4704 break; 4705 } 4706 4707 return 0; 4708} 4709 4710int ath11k_debugfs_htt_stats_req(struct ath11k *ar) 4711{ 4712 struct debug_htt_stats_req *stats_req = ar->debug.htt_stats.stats_req; 4713 u8 type = stats_req->type; 4714 u64 cookie = 0; 4715 int ret, pdev_id = ar->pdev->pdev_id; 4716 struct htt_ext_stats_cfg_params cfg_params = {}; 4717 4718 init_completion(&stats_req->cmpln); 4719 4720 stats_req->done = false; 4721 stats_req->pdev_id = pdev_id; 4722 4723 cookie = FIELD_PREP(HTT_STATS_COOKIE_MSB, HTT_STATS_MAGIC_VALUE) | 4724 FIELD_PREP(HTT_STATS_COOKIE_LSB, pdev_id); 4725 4726 ret = ath11k_prep_htt_stats_cfg_params(ar, type, stats_req->peer_addr, 4727 &cfg_params); 4728 if (ret) { 4729 ath11k_warn(ar->ab, "failed to set htt stats cfg params: %d\n", ret); 4730 return ret; 4731 } 4732 4733 ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar, type, &cfg_params, cookie); 4734 if (ret) { 4735 ath11k_warn(ar->ab, "failed to send htt stats request: %d\n", ret); 4736 return ret; 4737 } 4738 4739 while (!wait_for_completion_timeout(&stats_req->cmpln, 3 * HZ)) { 4740 spin_lock_bh(&ar->debug.htt_stats.lock); 4741 if (!stats_req->done) { 4742 stats_req->done = true; 4743 spin_unlock_bh(&ar->debug.htt_stats.lock); 4744 ath11k_warn(ar->ab, "stats request timed out\n"); 4745 return -ETIMEDOUT; 4746 } 4747 spin_unlock_bh(&ar->debug.htt_stats.lock); 4748 } 4749 4750 return 0; 4751} 4752 4753static int ath11k_open_htt_stats(struct inode *inode, struct file *file) 4754{ 4755 struct ath11k *ar = inode->i_private; 4756 struct debug_htt_stats_req *stats_req; 4757 u8 type = ar->debug.htt_stats.type; 4758 int ret; 4759 4760 if (type == ATH11K_DBG_HTT_EXT_STATS_RESET || 4761 type == ATH11K_DBG_HTT_EXT_STATS_PEER_INFO || 4762 type == ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS) 4763 return -EPERM; 4764 4765 mutex_lock(&ar->conf_mutex); 4766 4767 if (ar->state != ATH11K_STATE_ON) { 4768 ret = -ENETDOWN; 4769 goto err_unlock; 4770 } 4771 4772 if (ar->debug.htt_stats.stats_req) { 4773 ret = -EAGAIN; 4774 goto err_unlock; 4775 } 4776 4777 stats_req = vzalloc(sizeof(*stats_req) + ATH11K_HTT_STATS_BUF_SIZE); 4778 if (!stats_req) { 4779 ret = -ENOMEM; 4780 goto err_unlock; 4781 } 4782 4783 ar->debug.htt_stats.stats_req = stats_req; 4784 stats_req->type = type; 4785 4786 ret = ath11k_debugfs_htt_stats_req(ar); 4787 if (ret < 0) 4788 goto out; 4789 4790 file->private_data = stats_req; 4791 4792 mutex_unlock(&ar->conf_mutex); 4793 4794 return 0; 4795out: 4796 vfree(stats_req); 4797 ar->debug.htt_stats.stats_req = NULL; 4798err_unlock: 4799 mutex_unlock(&ar->conf_mutex); 4800 4801 return ret; 4802} 4803 4804static int ath11k_release_htt_stats(struct inode *inode, struct file *file) 4805{ 4806 struct ath11k *ar = inode->i_private; 4807 4808 mutex_lock(&ar->conf_mutex); 4809 vfree(file->private_data); 4810 ar->debug.htt_stats.stats_req = NULL; 4811 mutex_unlock(&ar->conf_mutex); 4812 4813 return 0; 4814} 4815 4816static ssize_t ath11k_read_htt_stats(struct file *file, 4817 char __user *user_buf, 4818 size_t count, loff_t *ppos) 4819{ 4820 struct debug_htt_stats_req *stats_req = file->private_data; 4821 char *buf; 4822 u32 length = 0; 4823 4824 buf = stats_req->buf; 4825 length = min_t(u32, stats_req->buf_len, ATH11K_HTT_STATS_BUF_SIZE); 4826 return simple_read_from_buffer(user_buf, count, ppos, buf, length); 4827} 4828 4829static const struct file_operations fops_dump_htt_stats = { 4830 .open = ath11k_open_htt_stats, 4831 .release = ath11k_release_htt_stats, 4832 .read = ath11k_read_htt_stats, 4833 .owner = THIS_MODULE, 4834 .llseek = default_llseek, 4835}; 4836 4837static ssize_t ath11k_read_htt_stats_reset(struct file *file, 4838 char __user *user_buf, 4839 size_t count, loff_t *ppos) 4840{ 4841 struct ath11k *ar = file->private_data; 4842 char buf[32]; 4843 size_t len; 4844 4845 len = scnprintf(buf, sizeof(buf), "%u\n", ar->debug.htt_stats.reset); 4846 4847 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 4848} 4849 4850static ssize_t ath11k_write_htt_stats_reset(struct file *file, 4851 const char __user *user_buf, 4852 size_t count, loff_t *ppos) 4853{ 4854 struct ath11k *ar = file->private_data; 4855 u8 type; 4856 struct htt_ext_stats_cfg_params cfg_params = {}; 4857 int ret; 4858 4859 ret = kstrtou8_from_user(user_buf, count, 0, &type); 4860 if (ret) 4861 return ret; 4862 4863 if (type >= ATH11K_DBG_HTT_NUM_EXT_STATS || 4864 type == ATH11K_DBG_HTT_EXT_STATS_RESET) 4865 return -E2BIG; 4866 4867 mutex_lock(&ar->conf_mutex); 4868 cfg_params.cfg0 = HTT_STAT_DEFAULT_RESET_START_OFFSET; 4869 cfg_params.cfg1 = 1 << (cfg_params.cfg0 + type); 4870 ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar, 4871 ATH11K_DBG_HTT_EXT_STATS_RESET, 4872 &cfg_params, 4873 0ULL); 4874 if (ret) { 4875 ath11k_warn(ar->ab, "failed to send htt stats request: %d\n", ret); 4876 mutex_unlock(&ar->conf_mutex); 4877 return ret; 4878 } 4879 4880 ar->debug.htt_stats.reset = type; 4881 mutex_unlock(&ar->conf_mutex); 4882 4883 ret = count; 4884 4885 return ret; 4886} 4887 4888static const struct file_operations fops_htt_stats_reset = { 4889 .read = ath11k_read_htt_stats_reset, 4890 .write = ath11k_write_htt_stats_reset, 4891 .open = simple_open, 4892 .owner = THIS_MODULE, 4893 .llseek = default_llseek, 4894}; 4895 4896void ath11k_debugfs_htt_stats_init(struct ath11k *ar) 4897{ 4898 spin_lock_init(&ar->debug.htt_stats.lock); 4899 debugfs_create_file("htt_stats_type", 0600, ar->debug.debugfs_pdev, 4900 ar, &fops_htt_stats_type); 4901 debugfs_create_file("htt_stats", 0400, ar->debug.debugfs_pdev, 4902 ar, &fops_dump_htt_stats); 4903 debugfs_create_file("htt_stats_reset", 0600, ar->debug.debugfs_pdev, 4904 ar, &fops_htt_stats_reset); 4905}
~/
Read-only file preview.