1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved. 5 */ 6 7 #include <linux/vmalloc.h> 8 #include "core.h" 9 #include "debug.h" 10 #include "debugfs_htt_stats.h" 11 #include "dp_tx.h" 12 #include "dp_rx.h" 13 14 static u32 15 print_array_to_buf_index(u8 *buf, u32 offset, const char *header, u32 stats_index, 16 const __le32 *array, u32 array_len, const char *footer) 17 { 18 int index = 0; 19 u8 i; 20 21 if (header) { 22 index += scnprintf(buf + offset, 23 ATH12K_HTT_STATS_BUF_SIZE - offset, 24 "%s = ", header); 25 } 26 for (i = 0; i < array_len; i++) { 27 index += scnprintf(buf + offset + index, 28 (ATH12K_HTT_STATS_BUF_SIZE - offset) - index, 29 " %u:%u,", stats_index++, le32_to_cpu(array[i])); 30 } 31 /* To overwrite the last trailing comma */ 32 index--; 33 *(buf + offset + index) = '\0'; 34 35 if (footer) { 36 index += scnprintf(buf + offset + index, 37 (ATH12K_HTT_STATS_BUF_SIZE - offset) - index, 38 "%s", footer); 39 } 40 return index; 41 } 42 43 static u32 44 print_array_to_buf(u8 *buf, u32 offset, const char *header, 45 const __le32 *array, u32 array_len, const char *footer) 46 { 47 return print_array_to_buf_index(buf, offset, header, 0, array, array_len, 48 footer); 49 } 50 51 static const char *ath12k_htt_ax_tx_rx_ru_size_to_str(u8 ru_size) 52 { 53 switch (ru_size) { 54 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_26: 55 return "26"; 56 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_52: 57 return "52"; 58 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_106: 59 return "106"; 60 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_242: 61 return "242"; 62 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_484: 63 return "484"; 64 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_996: 65 return "996"; 66 case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_996x2: 67 return "996x2"; 68 default: 69 return "unknown"; 70 } 71 } 72 73 static const char *ath12k_htt_be_tx_rx_ru_size_to_str(u8 ru_size) 74 { 75 switch (ru_size) { 76 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_26: 77 return "26"; 78 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_52: 79 return "52"; 80 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_52_26: 81 return "52+26"; 82 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_106: 83 return "106"; 84 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_106_26: 85 return "106+26"; 86 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_242: 87 return "242"; 88 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_484: 89 return "484"; 90 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_484_242: 91 return "484+242"; 92 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996: 93 return "996"; 94 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996_484: 95 return "996+484"; 96 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996_484_242: 97 return "996+484+242"; 98 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x2: 99 return "996x2"; 100 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x2_484: 101 return "996x2+484"; 102 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x3: 103 return "996x3"; 104 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x3_484: 105 return "996x3+484"; 106 case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x4: 107 return "996x4"; 108 default: 109 return "unknown"; 110 } 111 } 112 113 static const char* 114 ath12k_tx_ru_size_to_str(enum ath12k_htt_stats_ru_type ru_type, u8 ru_size) 115 { 116 if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY) 117 return ath12k_htt_ax_tx_rx_ru_size_to_str(ru_size); 118 else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU) 119 return ath12k_htt_be_tx_rx_ru_size_to_str(ru_size); 120 else 121 return "unknown"; 122 } 123 124 static void 125 htt_print_tx_pdev_stats_cmn_tlv(const void *tag_buf, u16 tag_len, 126 struct debug_htt_stats_req *stats_req) 127 { 128 const struct ath12k_htt_tx_pdev_stats_cmn_tlv *htt_stats_buf = tag_buf; 129 u8 *buf = stats_req->buf; 130 u32 len = stats_req->buf_len; 131 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 132 u32 mac_id_word; 133 134 if (tag_len < sizeof(*htt_stats_buf)) 135 return; 136 137 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 138 139 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n"); 140 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 141 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 142 len += scnprintf(buf + len, buf_len - len, "comp_delivered = %u\n", 143 le32_to_cpu(htt_stats_buf->comp_delivered)); 144 len += scnprintf(buf + len, buf_len - len, "self_triggers = %u\n", 145 le32_to_cpu(htt_stats_buf->self_triggers)); 146 len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n", 147 le32_to_cpu(htt_stats_buf->hw_queued)); 148 len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n", 149 le32_to_cpu(htt_stats_buf->hw_reaped)); 150 len += scnprintf(buf + len, buf_len - len, "underrun = %u\n", 151 le32_to_cpu(htt_stats_buf->underrun)); 152 len += scnprintf(buf + len, buf_len - len, "hw_paused = %u\n", 153 le32_to_cpu(htt_stats_buf->hw_paused)); 154 len += scnprintf(buf + len, buf_len - len, "hw_flush = %u\n", 155 le32_to_cpu(htt_stats_buf->hw_flush)); 156 len += scnprintf(buf + len, buf_len - len, "hw_filt = %u\n", 157 le32_to_cpu(htt_stats_buf->hw_filt)); 158 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n", 159 le32_to_cpu(htt_stats_buf->tx_abort)); 160 len += scnprintf(buf + len, buf_len - len, "ppdu_ok = %u\n", 161 le32_to_cpu(htt_stats_buf->ppdu_ok)); 162 len += scnprintf(buf + len, buf_len - len, "mpdu_requeued = %u\n", 163 le32_to_cpu(htt_stats_buf->mpdu_requed)); 164 len += scnprintf(buf + len, buf_len - len, "tx_xretry = %u\n", 165 le32_to_cpu(htt_stats_buf->tx_xretry)); 166 len += scnprintf(buf + len, buf_len - len, "data_rc = %u\n", 167 le32_to_cpu(htt_stats_buf->data_rc)); 168 len += scnprintf(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n", 169 le32_to_cpu(htt_stats_buf->mpdu_dropped_xretry)); 170 len += scnprintf(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n", 171 le32_to_cpu(htt_stats_buf->illgl_rate_phy_err)); 172 len += scnprintf(buf + len, buf_len - len, "cont_xretry = %u\n", 173 le32_to_cpu(htt_stats_buf->cont_xretry)); 174 len += scnprintf(buf + len, buf_len - len, "tx_timeout = %u\n", 175 le32_to_cpu(htt_stats_buf->tx_timeout)); 176 len += scnprintf(buf + len, buf_len - len, "tx_time_dur_data = %u\n", 177 le32_to_cpu(htt_stats_buf->tx_time_dur_data)); 178 len += scnprintf(buf + len, buf_len - len, "pdev_resets = %u\n", 179 le32_to_cpu(htt_stats_buf->pdev_resets)); 180 len += scnprintf(buf + len, buf_len - len, "phy_underrun = %u\n", 181 le32_to_cpu(htt_stats_buf->phy_underrun)); 182 len += scnprintf(buf + len, buf_len - len, "txop_ovf = %u\n", 183 le32_to_cpu(htt_stats_buf->txop_ovf)); 184 len += scnprintf(buf + len, buf_len - len, "seq_posted = %u\n", 185 le32_to_cpu(htt_stats_buf->seq_posted)); 186 len += scnprintf(buf + len, buf_len - len, "seq_failed_queueing = %u\n", 187 le32_to_cpu(htt_stats_buf->seq_failed_queueing)); 188 len += scnprintf(buf + len, buf_len - len, "seq_completed = %u\n", 189 le32_to_cpu(htt_stats_buf->seq_completed)); 190 len += scnprintf(buf + len, buf_len - len, "seq_restarted = %u\n", 191 le32_to_cpu(htt_stats_buf->seq_restarted)); 192 len += scnprintf(buf + len, buf_len - len, "seq_txop_repost_stop = %u\n", 193 le32_to_cpu(htt_stats_buf->seq_txop_repost_stop)); 194 len += scnprintf(buf + len, buf_len - len, "next_seq_cancel = %u\n", 195 le32_to_cpu(htt_stats_buf->next_seq_cancel)); 196 len += scnprintf(buf + len, buf_len - len, "dl_mu_mimo_seq_posted = %u\n", 197 le32_to_cpu(htt_stats_buf->mu_seq_posted)); 198 len += scnprintf(buf + len, buf_len - len, "dl_mu_ofdma_seq_posted = %u\n", 199 le32_to_cpu(htt_stats_buf->mu_ofdma_seq_posted)); 200 len += scnprintf(buf + len, buf_len - len, "ul_mu_mimo_seq_posted = %u\n", 201 le32_to_cpu(htt_stats_buf->ul_mumimo_seq_posted)); 202 len += scnprintf(buf + len, buf_len - len, "ul_mu_ofdma_seq_posted = %u\n", 203 le32_to_cpu(htt_stats_buf->ul_ofdma_seq_posted)); 204 len += scnprintf(buf + len, buf_len - len, "mu_mimo_peer_blacklisted = %u\n", 205 le32_to_cpu(htt_stats_buf->num_mu_peer_blacklisted)); 206 len += scnprintf(buf + len, buf_len - len, "seq_qdepth_repost_stop = %u\n", 207 le32_to_cpu(htt_stats_buf->seq_qdepth_repost_stop)); 208 len += scnprintf(buf + len, buf_len - len, "seq_min_msdu_repost_stop = %u\n", 209 le32_to_cpu(htt_stats_buf->seq_min_msdu_repost_stop)); 210 len += scnprintf(buf + len, buf_len - len, "mu_seq_min_msdu_repost_stop = %u\n", 211 le32_to_cpu(htt_stats_buf->mu_seq_min_msdu_repost_stop)); 212 len += scnprintf(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n", 213 le32_to_cpu(htt_stats_buf->seq_switch_hw_paused)); 214 len += scnprintf(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n", 215 le32_to_cpu(htt_stats_buf->next_seq_posted_dsr)); 216 len += scnprintf(buf + len, buf_len - len, "seq_posted_isr = %u\n", 217 le32_to_cpu(htt_stats_buf->seq_posted_isr)); 218 len += scnprintf(buf + len, buf_len - len, "seq_ctrl_cached = %u\n", 219 le32_to_cpu(htt_stats_buf->seq_ctrl_cached)); 220 len += scnprintf(buf + len, buf_len - len, "mpdu_count_tqm = %u\n", 221 le32_to_cpu(htt_stats_buf->mpdu_count_tqm)); 222 len += scnprintf(buf + len, buf_len - len, "msdu_count_tqm = %u\n", 223 le32_to_cpu(htt_stats_buf->msdu_count_tqm)); 224 len += scnprintf(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n", 225 le32_to_cpu(htt_stats_buf->mpdu_removed_tqm)); 226 len += scnprintf(buf + len, buf_len - len, "msdu_removed_tqm = %u\n", 227 le32_to_cpu(htt_stats_buf->msdu_removed_tqm)); 228 len += scnprintf(buf + len, buf_len - len, "remove_mpdus_max_retries = %u\n", 229 le32_to_cpu(htt_stats_buf->remove_mpdus_max_retries)); 230 len += scnprintf(buf + len, buf_len - len, "mpdus_sw_flush = %u\n", 231 le32_to_cpu(htt_stats_buf->mpdus_sw_flush)); 232 len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n", 233 le32_to_cpu(htt_stats_buf->mpdus_hw_filter)); 234 len += scnprintf(buf + len, buf_len - len, "mpdus_truncated = %u\n", 235 le32_to_cpu(htt_stats_buf->mpdus_truncated)); 236 len += scnprintf(buf + len, buf_len - len, "mpdus_ack_failed = %u\n", 237 le32_to_cpu(htt_stats_buf->mpdus_ack_failed)); 238 len += scnprintf(buf + len, buf_len - len, "mpdus_expired = %u\n", 239 le32_to_cpu(htt_stats_buf->mpdus_expired)); 240 len += scnprintf(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n", 241 le32_to_cpu(htt_stats_buf->mpdus_seq_hw_retry)); 242 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 243 le32_to_cpu(htt_stats_buf->ack_tlv_proc)); 244 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n", 245 le32_to_cpu(htt_stats_buf->coex_abort_mpdu_cnt_valid)); 246 len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n", 247 le32_to_cpu(htt_stats_buf->coex_abort_mpdu_cnt)); 248 len += scnprintf(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n", 249 le32_to_cpu(htt_stats_buf->num_total_ppdus_tried_ota)); 250 len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n", 251 le32_to_cpu(htt_stats_buf->num_data_ppdus_tried_ota)); 252 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n", 253 le32_to_cpu(htt_stats_buf->local_ctrl_mgmt_enqued)); 254 len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n", 255 le32_to_cpu(htt_stats_buf->local_ctrl_mgmt_freed)); 256 len += scnprintf(buf + len, buf_len - len, "local_data_enqued = %u\n", 257 le32_to_cpu(htt_stats_buf->local_data_enqued)); 258 len += scnprintf(buf + len, buf_len - len, "local_data_freed = %u\n", 259 le32_to_cpu(htt_stats_buf->local_data_freed)); 260 len += scnprintf(buf + len, buf_len - len, "mpdu_tried = %u\n", 261 le32_to_cpu(htt_stats_buf->mpdu_tried)); 262 len += scnprintf(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n", 263 le32_to_cpu(htt_stats_buf->isr_wait_seq_posted)); 264 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n", 265 le32_to_cpu(htt_stats_buf->tx_active_dur_us_low)); 266 len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n", 267 le32_to_cpu(htt_stats_buf->tx_active_dur_us_high)); 268 len += scnprintf(buf + len, buf_len - len, "fes_offsets_err_cnt = %u\n\n", 269 le32_to_cpu(htt_stats_buf->fes_offsets_err_cnt)); 270 271 stats_req->buf_len = len; 272 } 273 274 static void 275 htt_print_tx_pdev_stats_urrn_tlv(const void *tag_buf, 276 u16 tag_len, 277 struct debug_htt_stats_req *stats_req) 278 { 279 const struct ath12k_htt_tx_pdev_stats_urrn_tlv *htt_stats_buf = tag_buf; 280 u8 *buf = stats_req->buf; 281 u32 len = stats_req->buf_len; 282 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 283 u16 num_elems = min_t(u16, (tag_len >> 2), 284 HTT_TX_PDEV_MAX_URRN_STATS); 285 286 len += scnprintf(buf + len, buf_len - len, 287 "HTT_TX_PDEV_STATS_URRN_TLV:\n"); 288 289 len += print_array_to_buf(buf, len, "urrn_stats", htt_stats_buf->urrn_stats, 290 num_elems, "\n\n"); 291 292 stats_req->buf_len = len; 293 } 294 295 static void 296 htt_print_tx_pdev_stats_flush_tlv(const void *tag_buf, 297 u16 tag_len, 298 struct debug_htt_stats_req *stats_req) 299 { 300 const struct ath12k_htt_tx_pdev_stats_flush_tlv *htt_stats_buf = tag_buf; 301 u8 *buf = stats_req->buf; 302 u32 len = stats_req->buf_len; 303 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 304 u16 num_elems = min_t(u16, (tag_len >> 2), 305 ATH12K_HTT_TX_PDEV_MAX_FLUSH_REASON_STATS); 306 307 len += scnprintf(buf + len, buf_len - len, 308 "HTT_TX_PDEV_STATS_FLUSH_TLV:\n"); 309 310 len += print_array_to_buf(buf, len, "flush_errs", htt_stats_buf->flush_errs, 311 num_elems, "\n\n"); 312 313 stats_req->buf_len = len; 314 } 315 316 static void 317 htt_print_tx_pdev_stats_sifs_tlv(const void *tag_buf, 318 u16 tag_len, 319 struct debug_htt_stats_req *stats_req) 320 { 321 const struct ath12k_htt_tx_pdev_stats_sifs_tlv *htt_stats_buf = tag_buf; 322 u8 *buf = stats_req->buf; 323 u32 len = stats_req->buf_len; 324 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 325 u16 num_elems = min_t(u16, (tag_len >> 2), 326 ATH12K_HTT_TX_PDEV_MAX_SIFS_BURST_STATS); 327 328 len += scnprintf(buf + len, buf_len - len, 329 "HTT_TX_PDEV_STATS_SIFS_TLV:\n"); 330 331 len += print_array_to_buf(buf, len, "sifs_status", htt_stats_buf->sifs_status, 332 num_elems, "\n\n"); 333 334 stats_req->buf_len = len; 335 } 336 337 static void 338 htt_print_tx_pdev_mu_ppdu_dist_stats_tlv(const void *tag_buf, u16 tag_len, 339 struct debug_htt_stats_req *stats_req) 340 { 341 const struct ath12k_htt_tx_pdev_mu_ppdu_dist_stats_tlv *htt_stats_buf = tag_buf; 342 char *mode; 343 u8 j, hw_mode, i, str_buf_len; 344 u8 *buf = stats_req->buf; 345 u32 len = stats_req->buf_len; 346 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 347 u32 stats_value; 348 u8 max_ppdu = ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST; 349 u8 max_sched = ATH12K_HTT_STATS_MAX_NUM_SCHED_STATUS; 350 char str_buf[ATH12K_HTT_MAX_STRING_LEN]; 351 352 if (tag_len < sizeof(*htt_stats_buf)) 353 return; 354 355 hw_mode = le32_to_cpu(htt_stats_buf->hw_mode); 356 357 switch (hw_mode) { 358 case ATH12K_HTT_STATS_HWMODE_AC: 359 len += scnprintf(buf + len, buf_len - len, 360 "HTT_TX_PDEV_AC_MU_PPDU_DISTRIBUTION_STATS:\n"); 361 mode = "ac"; 362 break; 363 case ATH12K_HTT_STATS_HWMODE_AX: 364 len += scnprintf(buf + len, buf_len - len, 365 "HTT_TX_PDEV_AX_MU_PPDU_DISTRIBUTION_STATS:\n"); 366 mode = "ax"; 367 break; 368 case ATH12K_HTT_STATS_HWMODE_BE: 369 len += scnprintf(buf + len, buf_len - len, 370 "HTT_TX_PDEV_BE_MU_PPDU_DISTRIBUTION_STATS:\n"); 371 mode = "be"; 372 break; 373 default: 374 return; 375 } 376 377 for (i = 0; i < ATH12K_HTT_STATS_NUM_NR_BINS ; i++) { 378 len += scnprintf(buf + len, buf_len - len, 379 "%s_mu_mimo_num_seq_posted_nr%u = %u\n", mode, 380 ((i + 1) * 4), htt_stats_buf->num_seq_posted[i]); 381 str_buf_len = 0; 382 memset(str_buf, 0x0, sizeof(str_buf)); 383 for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST ; j++) { 384 stats_value = le32_to_cpu(htt_stats_buf->num_ppdu_posted_per_burst 385 [i * max_ppdu + j]); 386 str_buf_len += scnprintf(&str_buf[str_buf_len], 387 ATH12K_HTT_MAX_STRING_LEN - str_buf_len, 388 " %u:%u,", j, stats_value); 389 } 390 /* To overwrite the last trailing comma */ 391 str_buf[str_buf_len - 1] = '\0'; 392 len += scnprintf(buf + len, buf_len - len, 393 "%s_mu_mimo_num_ppdu_posted_per_burst_nr%u = %s\n", 394 mode, ((i + 1) * 4), str_buf); 395 str_buf_len = 0; 396 memset(str_buf, 0x0, sizeof(str_buf)); 397 for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST ; j++) { 398 stats_value = le32_to_cpu(htt_stats_buf->num_ppdu_cmpl_per_burst 399 [i * max_ppdu + j]); 400 str_buf_len += scnprintf(&str_buf[str_buf_len], 401 ATH12K_HTT_MAX_STRING_LEN - str_buf_len, 402 " %u:%u,", j, stats_value); 403 } 404 /* To overwrite the last trailing comma */ 405 str_buf[str_buf_len - 1] = '\0'; 406 len += scnprintf(buf + len, buf_len - len, 407 "%s_mu_mimo_num_ppdu_completed_per_burst_nr%u = %s\n", 408 mode, ((i + 1) * 4), str_buf); 409 str_buf_len = 0; 410 memset(str_buf, 0x0, sizeof(str_buf)); 411 for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_SCHED_STATUS ; j++) { 412 stats_value = le32_to_cpu(htt_stats_buf->num_seq_term_status 413 [i * max_sched + j]); 414 str_buf_len += scnprintf(&str_buf[str_buf_len], 415 ATH12K_HTT_MAX_STRING_LEN - str_buf_len, 416 " %u:%u,", j, stats_value); 417 } 418 /* To overwrite the last trailing comma */ 419 str_buf[str_buf_len - 1] = '\0'; 420 len += scnprintf(buf + len, buf_len - len, 421 "%s_mu_mimo_num_seq_term_status_nr%u = %s\n\n", 422 mode, ((i + 1) * 4), str_buf); 423 } 424 425 stats_req->buf_len = len; 426 } 427 428 static void 429 htt_print_tx_pdev_stats_sifs_hist_tlv(const void *tag_buf, 430 u16 tag_len, 431 struct debug_htt_stats_req *stats_req) 432 { 433 const struct ath12k_htt_tx_pdev_stats_sifs_hist_tlv *htt_stats_buf = tag_buf; 434 u8 *buf = stats_req->buf; 435 u32 len = stats_req->buf_len; 436 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 437 u16 num_elems = min_t(u16, (tag_len >> 2), 438 ATH12K_HTT_TX_PDEV_MAX_SIFS_BURST_HIST_STATS); 439 440 len += scnprintf(buf + len, buf_len - len, 441 "HTT_TX_PDEV_STATS_SIFS_HIST_TLV:\n"); 442 443 len += print_array_to_buf(buf, len, "sifs_hist_status", 444 htt_stats_buf->sifs_hist_status, num_elems, "\n\n"); 445 446 stats_req->buf_len = len; 447 } 448 449 static void 450 htt_print_pdev_ctrl_path_tx_stats_tlv(const void *tag_buf, u16 tag_len, 451 struct debug_htt_stats_req *stats_req) 452 { 453 const struct ath12k_htt_pdev_ctrl_path_tx_stats_tlv *htt_stats_buf = tag_buf; 454 u8 *buf = stats_req->buf; 455 u32 len = stats_req->buf_len; 456 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 457 458 if (len < sizeof(*htt_stats_buf)) 459 return; 460 461 len += scnprintf(buf + len, buf_len - len, 462 "HTT_TX_PDEV_STATS_CTRL_PATH_TX_STATS:\n"); 463 len += print_array_to_buf(buf, len, "fw_tx_mgmt_subtype", 464 htt_stats_buf->fw_tx_mgmt_subtype, 465 ATH12K_HTT_STATS_SUBTYPE_MAX, "\n\n"); 466 467 stats_req->buf_len = len; 468 } 469 470 static void 471 ath12k_htt_print_stats_tx_sched_cmn_tlv(const void *tag_buf, 472 u16 tag_len, 473 struct debug_htt_stats_req *stats_req) 474 { 475 const struct ath12k_htt_stats_tx_sched_cmn_tlv *htt_stats_buf = tag_buf; 476 u8 *buf = stats_req->buf; 477 u32 len = stats_req->buf_len; 478 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 479 u32 mac_id_word; 480 481 if (tag_len < sizeof(*htt_stats_buf)) 482 return; 483 484 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 485 486 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_TX_SCHED_CMN_TLV:\n"); 487 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 488 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 489 len += scnprintf(buf + len, buf_len - len, "current_timestamp = %u\n\n", 490 le32_to_cpu(htt_stats_buf->current_timestamp)); 491 492 stats_req->buf_len = len; 493 } 494 495 static void 496 ath12k_htt_print_tx_pdev_stats_sched_per_txq_tlv(const void *tag_buf, 497 u16 tag_len, 498 struct debug_htt_stats_req *stats_req) 499 { 500 const struct ath12k_htt_tx_pdev_stats_sched_per_txq_tlv *htt_stats_buf = tag_buf; 501 u8 *buf = stats_req->buf; 502 u32 len = stats_req->buf_len; 503 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 504 u32 mac_id_word; 505 506 if (tag_len < sizeof(*htt_stats_buf)) 507 return; 508 509 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 510 511 len += scnprintf(buf + len, buf_len - len, 512 "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:\n"); 513 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 514 u32_get_bits(mac_id_word, 515 ATH12K_HTT_TX_PDEV_STATS_SCHED_PER_TXQ_MAC_ID)); 516 len += scnprintf(buf + len, buf_len - len, "txq_id = %u\n", 517 u32_get_bits(mac_id_word, 518 ATH12K_HTT_TX_PDEV_STATS_SCHED_PER_TXQ_ID)); 519 len += scnprintf(buf + len, buf_len - len, "sched_policy = %u\n", 520 le32_to_cpu(htt_stats_buf->sched_policy)); 521 len += scnprintf(buf + len, buf_len - len, 522 "last_sched_cmd_posted_timestamp = %u\n", 523 le32_to_cpu(htt_stats_buf->last_sched_cmd_posted_timestamp)); 524 len += scnprintf(buf + len, buf_len - len, 525 "last_sched_cmd_compl_timestamp = %u\n", 526 le32_to_cpu(htt_stats_buf->last_sched_cmd_compl_timestamp)); 527 len += scnprintf(buf + len, buf_len - len, "sched_2_tac_lwm_count = %u\n", 528 le32_to_cpu(htt_stats_buf->sched_2_tac_lwm_count)); 529 len += scnprintf(buf + len, buf_len - len, "sched_2_tac_ring_full = %u\n", 530 le32_to_cpu(htt_stats_buf->sched_2_tac_ring_full)); 531 len += scnprintf(buf + len, buf_len - len, "sched_cmd_post_failure = %u\n", 532 le32_to_cpu(htt_stats_buf->sched_cmd_post_failure)); 533 len += scnprintf(buf + len, buf_len - len, "num_active_tids = %u\n", 534 le32_to_cpu(htt_stats_buf->num_active_tids)); 535 len += scnprintf(buf + len, buf_len - len, "num_ps_schedules = %u\n", 536 le32_to_cpu(htt_stats_buf->num_ps_schedules)); 537 len += scnprintf(buf + len, buf_len - len, "sched_cmds_pending = %u\n", 538 le32_to_cpu(htt_stats_buf->sched_cmds_pending)); 539 len += scnprintf(buf + len, buf_len - len, "num_tid_register = %u\n", 540 le32_to_cpu(htt_stats_buf->num_tid_register)); 541 len += scnprintf(buf + len, buf_len - len, "num_tid_unregister = %u\n", 542 le32_to_cpu(htt_stats_buf->num_tid_unregister)); 543 len += scnprintf(buf + len, buf_len - len, "num_qstats_queried = %u\n", 544 le32_to_cpu(htt_stats_buf->num_qstats_queried)); 545 len += scnprintf(buf + len, buf_len - len, "qstats_update_pending = %u\n", 546 le32_to_cpu(htt_stats_buf->qstats_update_pending)); 547 len += scnprintf(buf + len, buf_len - len, "last_qstats_query_timestamp = %u\n", 548 le32_to_cpu(htt_stats_buf->last_qstats_query_timestamp)); 549 len += scnprintf(buf + len, buf_len - len, "num_tqm_cmdq_full = %u\n", 550 le32_to_cpu(htt_stats_buf->num_tqm_cmdq_full)); 551 len += scnprintf(buf + len, buf_len - len, "num_de_sched_algo_trigger = %u\n", 552 le32_to_cpu(htt_stats_buf->num_de_sched_algo_trigger)); 553 len += scnprintf(buf + len, buf_len - len, "num_rt_sched_algo_trigger = %u\n", 554 le32_to_cpu(htt_stats_buf->num_rt_sched_algo_trigger)); 555 len += scnprintf(buf + len, buf_len - len, "num_tqm_sched_algo_trigger = %u\n", 556 le32_to_cpu(htt_stats_buf->num_tqm_sched_algo_trigger)); 557 len += scnprintf(buf + len, buf_len - len, "notify_sched = %u\n", 558 le32_to_cpu(htt_stats_buf->notify_sched)); 559 len += scnprintf(buf + len, buf_len - len, "dur_based_sendn_term = %u\n", 560 le32_to_cpu(htt_stats_buf->dur_based_sendn_term)); 561 len += scnprintf(buf + len, buf_len - len, "su_notify2_sched = %u\n", 562 le32_to_cpu(htt_stats_buf->su_notify2_sched)); 563 len += scnprintf(buf + len, buf_len - len, "su_optimal_queued_msdus_sched = %u\n", 564 le32_to_cpu(htt_stats_buf->su_optimal_queued_msdus_sched)); 565 len += scnprintf(buf + len, buf_len - len, "su_delay_timeout_sched = %u\n", 566 le32_to_cpu(htt_stats_buf->su_delay_timeout_sched)); 567 len += scnprintf(buf + len, buf_len - len, "su_min_txtime_sched_delay = %u\n", 568 le32_to_cpu(htt_stats_buf->su_min_txtime_sched_delay)); 569 len += scnprintf(buf + len, buf_len - len, "su_no_delay = %u\n", 570 le32_to_cpu(htt_stats_buf->su_no_delay)); 571 len += scnprintf(buf + len, buf_len - len, "num_supercycles = %u\n", 572 le32_to_cpu(htt_stats_buf->num_supercycles)); 573 len += scnprintf(buf + len, buf_len - len, "num_subcycles_with_sort = %u\n", 574 le32_to_cpu(htt_stats_buf->num_subcycles_with_sort)); 575 len += scnprintf(buf + len, buf_len - len, "num_subcycles_no_sort = %u\n\n", 576 le32_to_cpu(htt_stats_buf->num_subcycles_no_sort)); 577 578 stats_req->buf_len = len; 579 } 580 581 static void 582 ath12k_htt_print_sched_txq_cmd_posted_tlv(const void *tag_buf, 583 u16 tag_len, 584 struct debug_htt_stats_req *stats_req) 585 { 586 const struct ath12k_htt_sched_txq_cmd_posted_tlv *htt_stats_buf = tag_buf; 587 u8 *buf = stats_req->buf; 588 u32 len = stats_req->buf_len; 589 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 590 u16 num_elements = tag_len >> 2; 591 592 len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV:\n"); 593 len += print_array_to_buf(buf, len, "sched_cmd_posted", 594 htt_stats_buf->sched_cmd_posted, num_elements, "\n\n"); 595 596 stats_req->buf_len = len; 597 } 598 599 static void 600 ath12k_htt_print_sched_txq_cmd_reaped_tlv(const void *tag_buf, 601 u16 tag_len, 602 struct debug_htt_stats_req *stats_req) 603 { 604 const struct ath12k_htt_sched_txq_cmd_reaped_tlv *htt_stats_buf = tag_buf; 605 u8 *buf = stats_req->buf; 606 u32 len = stats_req->buf_len; 607 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 608 u16 num_elements = tag_len >> 2; 609 610 len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_REAPED_TLV:\n"); 611 len += print_array_to_buf(buf, len, "sched_cmd_reaped", 612 htt_stats_buf->sched_cmd_reaped, num_elements, "\n\n"); 613 614 stats_req->buf_len = len; 615 } 616 617 static void 618 ath12k_htt_print_sched_txq_sched_order_su_tlv(const void *tag_buf, 619 u16 tag_len, 620 struct debug_htt_stats_req *stats_req) 621 { 622 const struct ath12k_htt_sched_txq_sched_order_su_tlv *htt_stats_buf = tag_buf; 623 u8 *buf = stats_req->buf; 624 u32 len = stats_req->buf_len; 625 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 626 u32 sched_order_su_num_entries = min_t(u32, (tag_len >> 2), 627 ATH12K_HTT_TX_PDEV_NUM_SCHED_ORDER_LOG); 628 629 len += scnprintf(buf + len, buf_len - len, 630 "HTT_SCHED_TXQ_SCHED_ORDER_SU_TLV:\n"); 631 len += print_array_to_buf(buf, len, "sched_order_su", 632 htt_stats_buf->sched_order_su, 633 sched_order_su_num_entries, "\n\n"); 634 635 stats_req->buf_len = len; 636 } 637 638 static void 639 ath12k_htt_print_sched_txq_sched_ineligibility_tlv(const void *tag_buf, 640 u16 tag_len, 641 struct debug_htt_stats_req *stats_req) 642 { 643 const struct ath12k_htt_sched_txq_sched_ineligibility_tlv *htt_stats_buf = 644 tag_buf; 645 u8 *buf = stats_req->buf; 646 u32 len = stats_req->buf_len; 647 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 648 u32 sched_ineligibility_num_entries = tag_len >> 2; 649 650 len += scnprintf(buf + len, buf_len - len, 651 "HTT_SCHED_TXQ_SCHED_INELIGIBILITY:\n"); 652 len += print_array_to_buf(buf, len, "sched_ineligibility", 653 htt_stats_buf->sched_ineligibility, 654 sched_ineligibility_num_entries, "\n\n"); 655 656 stats_req->buf_len = len; 657 } 658 659 static void 660 ath12k_htt_print_sched_txq_supercycle_trigger_tlv(const void *tag_buf, 661 u16 tag_len, 662 struct debug_htt_stats_req *stats_req) 663 { 664 const struct ath12k_htt_sched_txq_supercycle_triggers_tlv *htt_stats_buf = 665 tag_buf; 666 u8 *buf = stats_req->buf; 667 u32 len = stats_req->buf_len; 668 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 669 u16 num_elems = min_t(u16, (tag_len >> 2), 670 ATH12K_HTT_SCHED_SUPERCYCLE_TRIGGER_MAX); 671 672 len += scnprintf(buf + len, buf_len - len, 673 "HTT_SCHED_TXQ_SUPERCYCLE_TRIGGER:\n"); 674 len += print_array_to_buf(buf, len, "supercycle_triggers", 675 htt_stats_buf->supercycle_triggers, num_elems, "\n\n"); 676 677 stats_req->buf_len = len; 678 } 679 680 static void 681 ath12k_htt_print_hw_stats_pdev_errs_tlv(const void *tag_buf, u16 tag_len, 682 struct debug_htt_stats_req *stats_req) 683 { 684 const struct ath12k_htt_hw_stats_pdev_errs_tlv *htt_buf = tag_buf; 685 u8 *buf = stats_req->buf; 686 u32 len = stats_req->buf_len; 687 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 688 u32 mac_id_word; 689 690 if (tag_len < sizeof(*htt_buf)) 691 return; 692 693 mac_id_word = le32_to_cpu(htt_buf->mac_id__word); 694 695 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n"); 696 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 697 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 698 len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n", 699 le32_to_cpu(htt_buf->tx_abort)); 700 len += scnprintf(buf + len, buf_len - len, "tx_abort_fail_count = %u\n", 701 le32_to_cpu(htt_buf->tx_abort_fail_count)); 702 len += scnprintf(buf + len, buf_len - len, "rx_abort = %u\n", 703 le32_to_cpu(htt_buf->rx_abort)); 704 len += scnprintf(buf + len, buf_len - len, "rx_abort_fail_count = %u\n", 705 le32_to_cpu(htt_buf->rx_abort_fail_count)); 706 len += scnprintf(buf + len, buf_len - len, "rx_flush_cnt = %u\n", 707 le32_to_cpu(htt_buf->rx_flush_cnt)); 708 len += scnprintf(buf + len, buf_len - len, "warm_reset = %u\n", 709 le32_to_cpu(htt_buf->warm_reset)); 710 len += scnprintf(buf + len, buf_len - len, "cold_reset = %u\n", 711 le32_to_cpu(htt_buf->cold_reset)); 712 len += scnprintf(buf + len, buf_len - len, "mac_cold_reset_restore_cal = %u\n", 713 le32_to_cpu(htt_buf->mac_cold_reset_restore_cal)); 714 len += scnprintf(buf + len, buf_len - len, "mac_cold_reset = %u\n", 715 le32_to_cpu(htt_buf->mac_cold_reset)); 716 len += scnprintf(buf + len, buf_len - len, "mac_warm_reset = %u\n", 717 le32_to_cpu(htt_buf->mac_warm_reset)); 718 len += scnprintf(buf + len, buf_len - len, "mac_only_reset = %u\n", 719 le32_to_cpu(htt_buf->mac_only_reset)); 720 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset = %u\n", 721 le32_to_cpu(htt_buf->phy_warm_reset)); 722 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_ucode_trig = %u\n", 723 le32_to_cpu(htt_buf->phy_warm_reset_ucode_trig)); 724 len += scnprintf(buf + len, buf_len - len, "mac_warm_reset_restore_cal = %u\n", 725 le32_to_cpu(htt_buf->mac_warm_reset_restore_cal)); 726 len += scnprintf(buf + len, buf_len - len, "mac_sfm_reset = %u\n", 727 le32_to_cpu(htt_buf->mac_sfm_reset)); 728 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_m3_ssr = %u\n", 729 le32_to_cpu(htt_buf->phy_warm_reset_m3_ssr)); 730 len += scnprintf(buf + len, buf_len - len, "fw_rx_rings_reset = %u\n", 731 le32_to_cpu(htt_buf->fw_rx_rings_reset)); 732 len += scnprintf(buf + len, buf_len - len, "tx_flush = %u\n", 733 le32_to_cpu(htt_buf->tx_flush)); 734 len += scnprintf(buf + len, buf_len - len, "tx_glb_reset = %u\n", 735 le32_to_cpu(htt_buf->tx_glb_reset)); 736 len += scnprintf(buf + len, buf_len - len, "tx_txq_reset = %u\n", 737 le32_to_cpu(htt_buf->tx_txq_reset)); 738 len += scnprintf(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n", 739 le32_to_cpu(htt_buf->rx_timeout_reset)); 740 741 len += scnprintf(buf + len, buf_len - len, "PDEV_PHY_WARM_RESET_REASONS:\n"); 742 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_reason_phy_m3 = %u\n", 743 le32_to_cpu(htt_buf->phy_warm_reset_reason_phy_m3)); 744 len += scnprintf(buf + len, buf_len - len, 745 "phy_warm_reset_reason_tx_hw_stuck = %u\n", 746 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_hw_stuck)); 747 len += scnprintf(buf + len, buf_len - len, 748 "phy_warm_reset_reason_num_cca_rx_frame_stuck = %u\n", 749 le32_to_cpu(htt_buf->phy_warm_reset_reason_num_rx_frame_stuck)); 750 len += scnprintf(buf + len, buf_len - len, 751 "phy_warm_reset_reason_wal_rx_recovery_rst_rx_busy = %u\n", 752 le32_to_cpu(htt_buf->phy_warm_reset_reason_wal_rx_rec_rx_busy)); 753 len += scnprintf(buf + len, buf_len - len, 754 "phy_warm_reset_reason_wal_rx_recovery_rst_mac_hang = %u\n", 755 le32_to_cpu(htt_buf->phy_warm_reset_reason_wal_rx_rec_mac_hng)); 756 len += scnprintf(buf + len, buf_len - len, 757 "phy_warm_reset_reason_mac_reset_converted_phy_reset = %u\n", 758 le32_to_cpu(htt_buf->phy_warm_reset_reason_mac_conv_phy_reset)); 759 len += scnprintf(buf + len, buf_len - len, 760 "phy_warm_reset_reason_tx_lifetime_expiry_cca_stuck = %u\n", 761 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_exp_cca_stuck)); 762 len += scnprintf(buf + len, buf_len - len, 763 "phy_warm_reset_reason_tx_consecutive_flush9_war = %u\n", 764 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_consec_flsh_war)); 765 len += scnprintf(buf + len, buf_len - len, 766 "phy_warm_reset_reason_tx_hwsch_reset_war = %u\n", 767 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_hwsch_reset_war)); 768 len += scnprintf(buf + len, buf_len - len, 769 "phy_warm_reset_reason_hwsch_wdog_or_cca_wdog_war = %u\n\n", 770 le32_to_cpu(htt_buf->phy_warm_reset_reason_hwsch_cca_wdog_war)); 771 772 len += scnprintf(buf + len, buf_len - len, "WAL_RX_RECOVERY_STATS:\n"); 773 len += scnprintf(buf + len, buf_len - len, 774 "wal_rx_recovery_rst_mac_hang_count = %u\n", 775 le32_to_cpu(htt_buf->wal_rx_recovery_rst_mac_hang_cnt)); 776 len += scnprintf(buf + len, buf_len - len, 777 "wal_rx_recovery_rst_known_sig_count = %u\n", 778 le32_to_cpu(htt_buf->wal_rx_recovery_rst_known_sig_cnt)); 779 len += scnprintf(buf + len, buf_len - len, 780 "wal_rx_recovery_rst_no_rx_count = %u\n", 781 le32_to_cpu(htt_buf->wal_rx_recovery_rst_no_rx_cnt)); 782 len += scnprintf(buf + len, buf_len - len, 783 "wal_rx_recovery_rst_no_rx_consecutive_count = %u\n", 784 le32_to_cpu(htt_buf->wal_rx_recovery_rst_no_rx_consec_cnt)); 785 len += scnprintf(buf + len, buf_len - len, 786 "wal_rx_recovery_rst_rx_busy_count = %u\n", 787 le32_to_cpu(htt_buf->wal_rx_recovery_rst_rx_busy_cnt)); 788 len += scnprintf(buf + len, buf_len - len, 789 "wal_rx_recovery_rst_phy_mac_hang_count = %u\n\n", 790 le32_to_cpu(htt_buf->wal_rx_recovery_rst_phy_mac_hang_cnt)); 791 792 len += scnprintf(buf + len, buf_len - len, "HTT_RX_DEST_DRAIN_STATS:\n"); 793 len += scnprintf(buf + len, buf_len - len, 794 "rx_dest_drain_rx_descs_leak_prevention_done = %u\n", 795 le32_to_cpu(htt_buf->rx_dest_drain_rx_descs_leak_prevented)); 796 len += scnprintf(buf + len, buf_len - len, 797 "rx_dest_drain_rx_descs_saved_cnt = %u\n", 798 le32_to_cpu(htt_buf->rx_dest_drain_rx_descs_saved_cnt)); 799 len += scnprintf(buf + len, buf_len - len, 800 "rx_dest_drain_rxdma2reo_leak_detected = %u\n", 801 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2reo_leak_detected)); 802 len += scnprintf(buf + len, buf_len - len, 803 "rx_dest_drain_rxdma2fw_leak_detected = %u\n", 804 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2fw_leak_detected)); 805 len += scnprintf(buf + len, buf_len - len, 806 "rx_dest_drain_rxdma2wbm_leak_detected = %u\n", 807 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2wbm_leak_detected)); 808 len += scnprintf(buf + len, buf_len - len, 809 "rx_dest_drain_rxdma1_2sw_leak_detected = %u\n", 810 le32_to_cpu(htt_buf->rx_dest_drain_rxdma1_2sw_leak_detected)); 811 len += scnprintf(buf + len, buf_len - len, 812 "rx_dest_drain_rx_drain_ok_mac_idle = %u\n", 813 le32_to_cpu(htt_buf->rx_dest_drain_rx_drain_ok_mac_idle)); 814 len += scnprintf(buf + len, buf_len - len, 815 "rx_dest_drain_ok_mac_not_idle = %u\n", 816 le32_to_cpu(htt_buf->rx_dest_drain_ok_mac_not_idle)); 817 len += scnprintf(buf + len, buf_len - len, 818 "rx_dest_drain_prerequisite_invld = %u\n", 819 le32_to_cpu(htt_buf->rx_dest_drain_prerequisite_invld)); 820 len += scnprintf(buf + len, buf_len - len, 821 "rx_dest_drain_skip_for_non_lmac_reset = %u\n", 822 le32_to_cpu(htt_buf->rx_dest_drain_skip_non_lmac_reset)); 823 len += scnprintf(buf + len, buf_len - len, 824 "rx_dest_drain_hw_fifo_not_empty_post_drain_wait = %u\n\n", 825 le32_to_cpu(htt_buf->rx_dest_drain_hw_fifo_notempty_post_wait)); 826 827 stats_req->buf_len = len; 828 } 829 830 static void 831 ath12k_htt_print_hw_stats_intr_misc_tlv(const void *tag_buf, u16 tag_len, 832 struct debug_htt_stats_req *stats_req) 833 { 834 const struct ath12k_htt_hw_stats_intr_misc_tlv *htt_stats_buf = tag_buf; 835 u8 *buf = stats_req->buf; 836 u32 len = stats_req->buf_len; 837 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 838 839 if (tag_len < sizeof(*htt_stats_buf)) 840 return; 841 842 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_INTR_MISC_TLV:\n"); 843 len += scnprintf(buf + len, buf_len - len, "hw_intr_name = %s\n", 844 htt_stats_buf->hw_intr_name); 845 len += scnprintf(buf + len, buf_len - len, "mask = %u\n", 846 le32_to_cpu(htt_stats_buf->mask)); 847 len += scnprintf(buf + len, buf_len - len, "count = %u\n\n", 848 le32_to_cpu(htt_stats_buf->count)); 849 850 stats_req->buf_len = len; 851 } 852 853 static void 854 ath12k_htt_print_hw_stats_whal_tx_tlv(const void *tag_buf, u16 tag_len, 855 struct debug_htt_stats_req *stats_req) 856 { 857 const struct ath12k_htt_hw_stats_whal_tx_tlv *htt_stats_buf = tag_buf; 858 u8 *buf = stats_req->buf; 859 u32 len = stats_req->buf_len; 860 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 861 u32 mac_id_word; 862 863 if (tag_len < sizeof(*htt_stats_buf)) 864 return; 865 866 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 867 868 len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WHAL_TX_TLV:\n"); 869 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 870 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 871 len += scnprintf(buf + len, buf_len - len, "last_unpause_ppdu_id = %u\n", 872 le32_to_cpu(htt_stats_buf->last_unpause_ppdu_id)); 873 len += scnprintf(buf + len, buf_len - len, "hwsch_unpause_wait_tqm_write = %u\n", 874 le32_to_cpu(htt_stats_buf->hwsch_unpause_wait_tqm_write)); 875 len += scnprintf(buf + len, buf_len - len, "hwsch_dummy_tlv_skipped = %u\n", 876 le32_to_cpu(htt_stats_buf->hwsch_dummy_tlv_skipped)); 877 len += scnprintf(buf + len, buf_len - len, 878 "hwsch_misaligned_offset_received = %u\n", 879 le32_to_cpu(htt_stats_buf->hwsch_misaligned_offset_received)); 880 len += scnprintf(buf + len, buf_len - len, "hwsch_reset_count = %u\n", 881 le32_to_cpu(htt_stats_buf->hwsch_reset_count)); 882 len += scnprintf(buf + len, buf_len - len, "hwsch_dev_reset_war = %u\n", 883 le32_to_cpu(htt_stats_buf->hwsch_dev_reset_war)); 884 len += scnprintf(buf + len, buf_len - len, "hwsch_delayed_pause = %u\n", 885 le32_to_cpu(htt_stats_buf->hwsch_delayed_pause)); 886 len += scnprintf(buf + len, buf_len - len, "hwsch_long_delayed_pause = %u\n", 887 le32_to_cpu(htt_stats_buf->hwsch_long_delayed_pause)); 888 len += scnprintf(buf + len, buf_len - len, "sch_rx_ppdu_no_response = %u\n", 889 le32_to_cpu(htt_stats_buf->sch_rx_ppdu_no_response)); 890 len += scnprintf(buf + len, buf_len - len, "sch_selfgen_response = %u\n", 891 le32_to_cpu(htt_stats_buf->sch_selfgen_response)); 892 len += scnprintf(buf + len, buf_len - len, "sch_rx_sifs_resp_trigger= %u\n\n", 893 le32_to_cpu(htt_stats_buf->sch_rx_sifs_resp_trigger)); 894 895 stats_req->buf_len = len; 896 } 897 898 static void 899 ath12k_htt_print_hw_war_tlv(const void *tag_buf, u16 tag_len, 900 struct debug_htt_stats_req *stats_req) 901 { 902 const struct ath12k_htt_hw_war_stats_tlv *htt_stats_buf = tag_buf; 903 u8 *buf = stats_req->buf; 904 u32 len = stats_req->buf_len; 905 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 906 u16 fixed_len, array_len; 907 u8 i, array_words; 908 u32 mac_id; 909 910 if (tag_len < sizeof(*htt_stats_buf)) 911 return; 912 913 mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word); 914 fixed_len = sizeof(*htt_stats_buf); 915 array_len = tag_len - fixed_len; 916 array_words = array_len >> 2; 917 918 len += scnprintf(buf + len, buf_len - len, "HTT_HW_WAR_STATS_TLV:\n"); 919 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 920 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID)); 921 922 for (i = 0; i < array_words; i++) { 923 len += scnprintf(buf + len, buf_len - len, "hw_war %u = %u\n\n", 924 i, le32_to_cpu(htt_stats_buf->hw_wars[i])); 925 } 926 927 stats_req->buf_len = len; 928 } 929 930 static void 931 ath12k_htt_print_tx_tqm_cmn_stats_tlv(const void *tag_buf, u16 tag_len, 932 struct debug_htt_stats_req *stats_req) 933 { 934 const struct ath12k_htt_tx_tqm_cmn_stats_tlv *htt_stats_buf = tag_buf; 935 u8 *buf = stats_req->buf; 936 u32 len = stats_req->buf_len; 937 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 938 u32 mac_id_word; 939 940 if (tag_len < sizeof(*htt_stats_buf)) 941 return; 942 943 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 944 945 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMN_STATS_TLV:\n"); 946 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 947 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 948 len += scnprintf(buf + len, buf_len - len, "max_cmdq_id = %u\n", 949 le32_to_cpu(htt_stats_buf->max_cmdq_id)); 950 len += scnprintf(buf + len, buf_len - len, "list_mpdu_cnt_hist_intvl = %u\n", 951 le32_to_cpu(htt_stats_buf->list_mpdu_cnt_hist_intvl)); 952 len += scnprintf(buf + len, buf_len - len, "add_msdu = %u\n", 953 le32_to_cpu(htt_stats_buf->add_msdu)); 954 len += scnprintf(buf + len, buf_len - len, "q_empty = %u\n", 955 le32_to_cpu(htt_stats_buf->q_empty)); 956 len += scnprintf(buf + len, buf_len - len, "q_not_empty = %u\n", 957 le32_to_cpu(htt_stats_buf->q_not_empty)); 958 len += scnprintf(buf + len, buf_len - len, "drop_notification = %u\n", 959 le32_to_cpu(htt_stats_buf->drop_notification)); 960 len += scnprintf(buf + len, buf_len - len, "desc_threshold = %u\n", 961 le32_to_cpu(htt_stats_buf->desc_threshold)); 962 len += scnprintf(buf + len, buf_len - len, "hwsch_tqm_invalid_status = %u\n", 963 le32_to_cpu(htt_stats_buf->hwsch_tqm_invalid_status)); 964 len += scnprintf(buf + len, buf_len - len, "missed_tqm_gen_mpdus = %u\n", 965 le32_to_cpu(htt_stats_buf->missed_tqm_gen_mpdus)); 966 len += scnprintf(buf + len, buf_len - len, 967 "total_msduq_timestamp_updates = %u\n", 968 le32_to_cpu(htt_stats_buf->msduq_timestamp_updates)); 969 len += scnprintf(buf + len, buf_len - len, 970 "total_msduq_timestamp_updates_by_get_mpdu_head_info_cmd = %u\n", 971 le32_to_cpu(htt_stats_buf->msduq_updates_mpdu_head_info_cmd)); 972 len += scnprintf(buf + len, buf_len - len, 973 "total_msduq_timestamp_updates_by_emp_to_nonemp_status = %u\n", 974 le32_to_cpu(htt_stats_buf->msduq_updates_emp_to_nonemp_status)); 975 len += scnprintf(buf + len, buf_len - len, 976 "total_get_mpdu_head_info_cmds_by_sched_algo_la_query = %u\n", 977 le32_to_cpu(htt_stats_buf->get_mpdu_head_info_cmds_by_query)); 978 len += scnprintf(buf + len, buf_len - len, 979 "total_get_mpdu_head_info_cmds_by_tac = %u\n", 980 le32_to_cpu(htt_stats_buf->get_mpdu_head_info_cmds_by_tac)); 981 len += scnprintf(buf + len, buf_len - len, 982 "total_gen_mpdu_cmds_by_sched_algo_la_query = %u\n", 983 le32_to_cpu(htt_stats_buf->gen_mpdu_cmds_by_query)); 984 len += scnprintf(buf + len, buf_len - len, "active_tqm_tids = %u\n", 985 le32_to_cpu(htt_stats_buf->tqm_active_tids)); 986 len += scnprintf(buf + len, buf_len - len, "inactive_tqm_tids = %u\n", 987 le32_to_cpu(htt_stats_buf->tqm_inactive_tids)); 988 len += scnprintf(buf + len, buf_len - len, "tqm_active_msduq_flows = %u\n", 989 le32_to_cpu(htt_stats_buf->tqm_active_msduq_flows)); 990 len += scnprintf(buf + len, buf_len - len, "hi_prio_q_not_empty = %u\n\n", 991 le32_to_cpu(htt_stats_buf->high_prio_q_not_empty)); 992 993 stats_req->buf_len = len; 994 } 995 996 static void 997 ath12k_htt_print_tx_tqm_error_stats_tlv(const void *tag_buf, u16 tag_len, 998 struct debug_htt_stats_req *stats_req) 999 { 1000 const struct ath12k_htt_tx_tqm_error_stats_tlv *htt_stats_buf = tag_buf; 1001 u8 *buf = stats_req->buf; 1002 u32 len = stats_req->buf_len; 1003 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1004 1005 if (tag_len < sizeof(*htt_stats_buf)) 1006 return; 1007 1008 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_ERROR_STATS_TLV:\n"); 1009 len += scnprintf(buf + len, buf_len - len, "q_empty_failure = %u\n", 1010 le32_to_cpu(htt_stats_buf->q_empty_failure)); 1011 len += scnprintf(buf + len, buf_len - len, "q_not_empty_failure = %u\n", 1012 le32_to_cpu(htt_stats_buf->q_not_empty_failure)); 1013 len += scnprintf(buf + len, buf_len - len, "add_msdu_failure = %u\n\n", 1014 le32_to_cpu(htt_stats_buf->add_msdu_failure)); 1015 1016 len += scnprintf(buf + len, buf_len - len, "TQM_ERROR_RESET_STATS:\n"); 1017 len += scnprintf(buf + len, buf_len - len, "tqm_cache_ctl_err = %u\n", 1018 le32_to_cpu(htt_stats_buf->tqm_cache_ctl_err)); 1019 len += scnprintf(buf + len, buf_len - len, "tqm_soft_reset = %u\n", 1020 le32_to_cpu(htt_stats_buf->tqm_soft_reset)); 1021 len += scnprintf(buf + len, buf_len - len, 1022 "tqm_reset_total_num_in_use_link_descs = %u\n", 1023 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_link_descs)); 1024 len += scnprintf(buf + len, buf_len - len, 1025 "tqm_reset_worst_case_num_lost_link_descs = %u\n", 1026 le32_to_cpu(htt_stats_buf->tqm_reset_num_lost_link_descs)); 1027 len += scnprintf(buf + len, buf_len - len, 1028 "tqm_reset_worst_case_num_lost_host_tx_bufs_count = %u\n", 1029 le32_to_cpu(htt_stats_buf->tqm_reset_num_lost_host_tx_buf_cnt)); 1030 len += scnprintf(buf + len, buf_len - len, 1031 "tqm_reset_num_in_use_link_descs_internal_tqm = %u\n", 1032 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_internal_tqm)); 1033 len += scnprintf(buf + len, buf_len - len, 1034 "tqm_reset_num_in_use_link_descs_wbm_idle_link_ring = %u\n", 1035 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_idle_link_rng)); 1036 len += scnprintf(buf + len, buf_len - len, 1037 "tqm_reset_time_to_tqm_hang_delta_ms = %u\n", 1038 le32_to_cpu(htt_stats_buf->tqm_reset_time_to_tqm_hang_delta_ms)); 1039 len += scnprintf(buf + len, buf_len - len, "tqm_reset_recovery_time_ms = %u\n", 1040 le32_to_cpu(htt_stats_buf->tqm_reset_recovery_time_ms)); 1041 len += scnprintf(buf + len, buf_len - len, "tqm_reset_num_peers_hdl = %u\n", 1042 le32_to_cpu(htt_stats_buf->tqm_reset_num_peers_hdl)); 1043 len += scnprintf(buf + len, buf_len - len, 1044 "tqm_reset_cumm_dirty_hw_mpduq_proc_cnt = %u\n", 1045 le32_to_cpu(htt_stats_buf->tqm_reset_cumm_dirty_hw_mpduq_cnt)); 1046 len += scnprintf(buf + len, buf_len - len, 1047 "tqm_reset_cumm_dirty_hw_msduq_proc = %u\n", 1048 le32_to_cpu(htt_stats_buf->tqm_reset_cumm_dirty_hw_msduq_proc)); 1049 len += scnprintf(buf + len, buf_len - len, 1050 "tqm_reset_flush_cache_cmd_su_cnt = %u\n", 1051 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_su_cnt)); 1052 len += scnprintf(buf + len, buf_len - len, 1053 "tqm_reset_flush_cache_cmd_other_cnt = %u\n", 1054 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_other_cnt)); 1055 len += scnprintf(buf + len, buf_len - len, 1056 "tqm_reset_flush_cache_cmd_trig_type = %u\n", 1057 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_trig_type)); 1058 len += scnprintf(buf + len, buf_len - len, 1059 "tqm_reset_flush_cache_cmd_trig_cfg = %u\n", 1060 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_trig_cfg)); 1061 len += scnprintf(buf + len, buf_len - len, 1062 "tqm_reset_flush_cache_cmd_skip_cmd_status_null = %u\n\n", 1063 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cmd_skp_status_null)); 1064 1065 stats_req->buf_len = len; 1066 } 1067 1068 static void 1069 ath12k_htt_print_tx_tqm_gen_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 1070 struct debug_htt_stats_req *stats_req) 1071 { 1072 const struct ath12k_htt_tx_tqm_gen_mpdu_stats_tlv *htt_stats_buf = tag_buf; 1073 u8 *buf = stats_req->buf; 1074 u32 len = stats_req->buf_len; 1075 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1076 u16 num_elements = tag_len >> 2; 1077 1078 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_GEN_MPDU_STATS_TLV:\n"); 1079 len += print_array_to_buf(buf, len, "gen_mpdu_end_reason", 1080 htt_stats_buf->gen_mpdu_end_reason, num_elements, 1081 "\n\n"); 1082 1083 stats_req->buf_len = len; 1084 } 1085 1086 static void 1087 ath12k_htt_print_tx_tqm_list_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 1088 struct debug_htt_stats_req *stats_req) 1089 { 1090 const struct ath12k_htt_tx_tqm_list_mpdu_stats_tlv *htt_stats_buf = tag_buf; 1091 u8 *buf = stats_req->buf; 1092 u32 len = stats_req->buf_len; 1093 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1094 u16 num_elems = min_t(u16, (tag_len >> 2), 1095 ATH12K_HTT_TX_TQM_MAX_LIST_MPDU_END_REASON); 1096 1097 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_STATS_TLV:\n"); 1098 len += print_array_to_buf(buf, len, "list_mpdu_end_reason", 1099 htt_stats_buf->list_mpdu_end_reason, num_elems, "\n\n"); 1100 1101 stats_req->buf_len = len; 1102 } 1103 1104 static void 1105 ath12k_htt_print_tx_tqm_list_mpdu_cnt_tlv(const void *tag_buf, u16 tag_len, 1106 struct debug_htt_stats_req *stats_req) 1107 { 1108 const struct ath12k_htt_tx_tqm_list_mpdu_cnt_tlv *htt_stats_buf = tag_buf; 1109 u8 *buf = stats_req->buf; 1110 u32 len = stats_req->buf_len; 1111 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1112 u16 num_elems = min_t(u16, (tag_len >> 2), 1113 ATH12K_HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS); 1114 1115 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:\n"); 1116 len += print_array_to_buf(buf, len, "list_mpdu_cnt_hist", 1117 htt_stats_buf->list_mpdu_cnt_hist, num_elems, "\n\n"); 1118 1119 stats_req->buf_len = len; 1120 } 1121 1122 static void 1123 ath12k_htt_print_tx_tqm_pdev_stats_tlv(const void *tag_buf, u16 tag_len, 1124 struct debug_htt_stats_req *stats_req) 1125 { 1126 const struct ath12k_htt_tx_tqm_pdev_stats_tlv *htt_stats_buf = tag_buf; 1127 u8 *buf = stats_req->buf; 1128 u32 len = stats_req->buf_len; 1129 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1130 1131 if (tag_len < sizeof(*htt_stats_buf)) 1132 return; 1133 1134 len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_PDEV_STATS_TLV_V:\n"); 1135 len += scnprintf(buf + len, buf_len - len, "msdu_count = %u\n", 1136 le32_to_cpu(htt_stats_buf->msdu_count)); 1137 len += scnprintf(buf + len, buf_len - len, "mpdu_count = %u\n", 1138 le32_to_cpu(htt_stats_buf->mpdu_count)); 1139 len += scnprintf(buf + len, buf_len - len, "remove_msdu = %u\n", 1140 le32_to_cpu(htt_stats_buf->remove_msdu)); 1141 len += scnprintf(buf + len, buf_len - len, "remove_mpdu = %u\n", 1142 le32_to_cpu(htt_stats_buf->remove_mpdu)); 1143 len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl = %u\n", 1144 le32_to_cpu(htt_stats_buf->remove_msdu_ttl)); 1145 len += scnprintf(buf + len, buf_len - len, "send_bar = %u\n", 1146 le32_to_cpu(htt_stats_buf->send_bar)); 1147 len += scnprintf(buf + len, buf_len - len, "bar_sync = %u\n", 1148 le32_to_cpu(htt_stats_buf->bar_sync)); 1149 len += scnprintf(buf + len, buf_len - len, "notify_mpdu = %u\n", 1150 le32_to_cpu(htt_stats_buf->notify_mpdu)); 1151 len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n", 1152 le32_to_cpu(htt_stats_buf->sync_cmd)); 1153 len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n", 1154 le32_to_cpu(htt_stats_buf->write_cmd)); 1155 len += scnprintf(buf + len, buf_len - len, "hwsch_trigger = %u\n", 1156 le32_to_cpu(htt_stats_buf->hwsch_trigger)); 1157 len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 1158 le32_to_cpu(htt_stats_buf->ack_tlv_proc)); 1159 len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n", 1160 le32_to_cpu(htt_stats_buf->gen_mpdu_cmd)); 1161 len += scnprintf(buf + len, buf_len - len, "gen_list_cmd = %u\n", 1162 le32_to_cpu(htt_stats_buf->gen_list_cmd)); 1163 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n", 1164 le32_to_cpu(htt_stats_buf->remove_mpdu_cmd)); 1165 len += scnprintf(buf + len, buf_len - len, "remove_mpdu_tried_cmd = %u\n", 1166 le32_to_cpu(htt_stats_buf->remove_mpdu_tried_cmd)); 1167 len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n", 1168 le32_to_cpu(htt_stats_buf->mpdu_queue_stats_cmd)); 1169 len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n", 1170 le32_to_cpu(htt_stats_buf->mpdu_head_info_cmd)); 1171 len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n", 1172 le32_to_cpu(htt_stats_buf->msdu_flow_stats_cmd)); 1173 len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n", 1174 le32_to_cpu(htt_stats_buf->remove_msdu_cmd)); 1175 len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl_cmd = %u\n", 1176 le32_to_cpu(htt_stats_buf->remove_msdu_ttl_cmd)); 1177 len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n", 1178 le32_to_cpu(htt_stats_buf->flush_cache_cmd)); 1179 len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n", 1180 le32_to_cpu(htt_stats_buf->update_mpduq_cmd)); 1181 len += scnprintf(buf + len, buf_len - len, "enqueue = %u\n", 1182 le32_to_cpu(htt_stats_buf->enqueue)); 1183 len += scnprintf(buf + len, buf_len - len, "enqueue_notify = %u\n", 1184 le32_to_cpu(htt_stats_buf->enqueue_notify)); 1185 len += scnprintf(buf + len, buf_len - len, "notify_mpdu_at_head = %u\n", 1186 le32_to_cpu(htt_stats_buf->notify_mpdu_at_head)); 1187 len += scnprintf(buf + len, buf_len - len, "notify_mpdu_state_valid = %u\n", 1188 le32_to_cpu(htt_stats_buf->notify_mpdu_state_valid)); 1189 len += scnprintf(buf + len, buf_len - len, "sched_udp_notify1 = %u\n", 1190 le32_to_cpu(htt_stats_buf->sched_udp_notify1)); 1191 len += scnprintf(buf + len, buf_len - len, "sched_udp_notify2 = %u\n", 1192 le32_to_cpu(htt_stats_buf->sched_udp_notify2)); 1193 len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify1 = %u\n", 1194 le32_to_cpu(htt_stats_buf->sched_nonudp_notify1)); 1195 len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify2 = %u\n\n", 1196 le32_to_cpu(htt_stats_buf->sched_nonudp_notify2)); 1197 1198 stats_req->buf_len = len; 1199 } 1200 1201 static void 1202 ath12k_htt_print_tx_de_cmn_stats_tlv(const void *tag_buf, u16 tag_len, 1203 struct debug_htt_stats_req *stats_req) 1204 { 1205 const struct ath12k_htt_tx_de_cmn_stats_tlv *htt_stats_buf = tag_buf; 1206 u8 *buf = stats_req->buf; 1207 u32 len = stats_req->buf_len; 1208 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1209 u32 mac_id_word; 1210 1211 if (tag_len < sizeof(*htt_stats_buf)) 1212 return; 1213 1214 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 1215 1216 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CMN_STATS_TLV:\n"); 1217 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 1218 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 1219 len += scnprintf(buf + len, buf_len - len, "tcl2fw_entry_count = %u\n", 1220 le32_to_cpu(htt_stats_buf->tcl2fw_entry_count)); 1221 len += scnprintf(buf + len, buf_len - len, "not_to_fw = %u\n", 1222 le32_to_cpu(htt_stats_buf->not_to_fw)); 1223 len += scnprintf(buf + len, buf_len - len, "invalid_pdev_vdev_peer = %u\n", 1224 le32_to_cpu(htt_stats_buf->invalid_pdev_vdev_peer)); 1225 len += scnprintf(buf + len, buf_len - len, "tcl_res_invalid_addrx = %u\n", 1226 le32_to_cpu(htt_stats_buf->tcl_res_invalid_addrx)); 1227 len += scnprintf(buf + len, buf_len - len, "wbm2fw_entry_count = %u\n", 1228 le32_to_cpu(htt_stats_buf->wbm2fw_entry_count)); 1229 len += scnprintf(buf + len, buf_len - len, "invalid_pdev = %u\n", 1230 le32_to_cpu(htt_stats_buf->invalid_pdev)); 1231 len += scnprintf(buf + len, buf_len - len, "tcl_res_addrx_timeout = %u\n", 1232 le32_to_cpu(htt_stats_buf->tcl_res_addrx_timeout)); 1233 len += scnprintf(buf + len, buf_len - len, "invalid_vdev = %u\n", 1234 le32_to_cpu(htt_stats_buf->invalid_vdev)); 1235 len += scnprintf(buf + len, buf_len - len, "invalid_tcl_exp_frame_desc = %u\n", 1236 le32_to_cpu(htt_stats_buf->invalid_tcl_exp_frame_desc)); 1237 len += scnprintf(buf + len, buf_len - len, "vdev_id_mismatch_count = %u\n\n", 1238 le32_to_cpu(htt_stats_buf->vdev_id_mismatch_cnt)); 1239 1240 stats_req->buf_len = len; 1241 } 1242 1243 static void 1244 ath12k_htt_print_tx_de_eapol_packets_stats_tlv(const void *tag_buf, u16 tag_len, 1245 struct debug_htt_stats_req *stats_req) 1246 { 1247 const struct ath12k_htt_tx_de_eapol_packets_stats_tlv *htt_stats_buf = tag_buf; 1248 u8 *buf = stats_req->buf; 1249 u32 len = stats_req->buf_len; 1250 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1251 1252 if (tag_len < sizeof(*htt_stats_buf)) 1253 return; 1254 1255 len += scnprintf(buf + len, buf_len - len, 1256 "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:\n"); 1257 len += scnprintf(buf + len, buf_len - len, "m1_packets = %u\n", 1258 le32_to_cpu(htt_stats_buf->m1_packets)); 1259 len += scnprintf(buf + len, buf_len - len, "m2_packets = %u\n", 1260 le32_to_cpu(htt_stats_buf->m2_packets)); 1261 len += scnprintf(buf + len, buf_len - len, "m3_packets = %u\n", 1262 le32_to_cpu(htt_stats_buf->m3_packets)); 1263 len += scnprintf(buf + len, buf_len - len, "m4_packets = %u\n", 1264 le32_to_cpu(htt_stats_buf->m4_packets)); 1265 len += scnprintf(buf + len, buf_len - len, "g1_packets = %u\n", 1266 le32_to_cpu(htt_stats_buf->g1_packets)); 1267 len += scnprintf(buf + len, buf_len - len, "g2_packets = %u\n", 1268 le32_to_cpu(htt_stats_buf->g2_packets)); 1269 len += scnprintf(buf + len, buf_len - len, "rc4_packets = %u\n", 1270 le32_to_cpu(htt_stats_buf->rc4_packets)); 1271 len += scnprintf(buf + len, buf_len - len, "eap_packets = %u\n", 1272 le32_to_cpu(htt_stats_buf->eap_packets)); 1273 len += scnprintf(buf + len, buf_len - len, "eapol_start_packets = %u\n", 1274 le32_to_cpu(htt_stats_buf->eapol_start_packets)); 1275 len += scnprintf(buf + len, buf_len - len, "eapol_logoff_packets = %u\n", 1276 le32_to_cpu(htt_stats_buf->eapol_logoff_packets)); 1277 len += scnprintf(buf + len, buf_len - len, "eapol_encap_asf_packets = %u\n\n", 1278 le32_to_cpu(htt_stats_buf->eapol_encap_asf_packets)); 1279 1280 stats_req->buf_len = len; 1281 } 1282 1283 static void 1284 ath12k_htt_print_tx_de_classify_stats_tlv(const void *tag_buf, u16 tag_len, 1285 struct debug_htt_stats_req *stats_req) 1286 { 1287 const struct ath12k_htt_tx_de_classify_stats_tlv *htt_stats_buf = tag_buf; 1288 u8 *buf = stats_req->buf; 1289 u32 len = stats_req->buf_len; 1290 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1291 1292 if (tag_len < sizeof(*htt_stats_buf)) 1293 return; 1294 1295 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CLASSIFY_STATS_TLV:\n"); 1296 len += scnprintf(buf + len, buf_len - len, "arp_packets = %u\n", 1297 le32_to_cpu(htt_stats_buf->arp_packets)); 1298 len += scnprintf(buf + len, buf_len - len, "igmp_packets = %u\n", 1299 le32_to_cpu(htt_stats_buf->igmp_packets)); 1300 len += scnprintf(buf + len, buf_len - len, "dhcp_packets = %u\n", 1301 le32_to_cpu(htt_stats_buf->dhcp_packets)); 1302 len += scnprintf(buf + len, buf_len - len, "host_inspected = %u\n", 1303 le32_to_cpu(htt_stats_buf->host_inspected)); 1304 len += scnprintf(buf + len, buf_len - len, "htt_included = %u\n", 1305 le32_to_cpu(htt_stats_buf->htt_included)); 1306 len += scnprintf(buf + len, buf_len - len, "htt_valid_mcs = %u\n", 1307 le32_to_cpu(htt_stats_buf->htt_valid_mcs)); 1308 len += scnprintf(buf + len, buf_len - len, "htt_valid_nss = %u\n", 1309 le32_to_cpu(htt_stats_buf->htt_valid_nss)); 1310 len += scnprintf(buf + len, buf_len - len, "htt_valid_preamble_type = %u\n", 1311 le32_to_cpu(htt_stats_buf->htt_valid_preamble_type)); 1312 len += scnprintf(buf + len, buf_len - len, "htt_valid_chainmask = %u\n", 1313 le32_to_cpu(htt_stats_buf->htt_valid_chainmask)); 1314 len += scnprintf(buf + len, buf_len - len, "htt_valid_guard_interval = %u\n", 1315 le32_to_cpu(htt_stats_buf->htt_valid_guard_interval)); 1316 len += scnprintf(buf + len, buf_len - len, "htt_valid_retries = %u\n", 1317 le32_to_cpu(htt_stats_buf->htt_valid_retries)); 1318 len += scnprintf(buf + len, buf_len - len, "htt_valid_bw_info = %u\n", 1319 le32_to_cpu(htt_stats_buf->htt_valid_bw_info)); 1320 len += scnprintf(buf + len, buf_len - len, "htt_valid_power = %u\n", 1321 le32_to_cpu(htt_stats_buf->htt_valid_power)); 1322 len += scnprintf(buf + len, buf_len - len, "htt_valid_key_flags = 0x%x\n", 1323 le32_to_cpu(htt_stats_buf->htt_valid_key_flags)); 1324 len += scnprintf(buf + len, buf_len - len, "htt_valid_no_encryption = %u\n", 1325 le32_to_cpu(htt_stats_buf->htt_valid_no_encryption)); 1326 len += scnprintf(buf + len, buf_len - len, "fse_entry_count = %u\n", 1327 le32_to_cpu(htt_stats_buf->fse_entry_count)); 1328 len += scnprintf(buf + len, buf_len - len, "fse_priority_be = %u\n", 1329 le32_to_cpu(htt_stats_buf->fse_priority_be)); 1330 len += scnprintf(buf + len, buf_len - len, "fse_priority_high = %u\n", 1331 le32_to_cpu(htt_stats_buf->fse_priority_high)); 1332 len += scnprintf(buf + len, buf_len - len, "fse_priority_low = %u\n", 1333 le32_to_cpu(htt_stats_buf->fse_priority_low)); 1334 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_be = %u\n", 1335 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_be)); 1336 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_over_sub = %u\n", 1337 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_over_sub)); 1338 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_bursty = %u\n", 1339 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_bursty)); 1340 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_interactive = %u\n", 1341 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_interactive)); 1342 len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_periodic = %u\n", 1343 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_periodic)); 1344 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_alloc = %u\n", 1345 le32_to_cpu(htt_stats_buf->fse_hwqueue_alloc)); 1346 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_created = %u\n", 1347 le32_to_cpu(htt_stats_buf->fse_hwqueue_created)); 1348 len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_send_to_host = %u\n", 1349 le32_to_cpu(htt_stats_buf->fse_hwqueue_send_to_host)); 1350 len += scnprintf(buf + len, buf_len - len, "mcast_entry = %u\n", 1351 le32_to_cpu(htt_stats_buf->mcast_entry)); 1352 len += scnprintf(buf + len, buf_len - len, "bcast_entry = %u\n", 1353 le32_to_cpu(htt_stats_buf->bcast_entry)); 1354 len += scnprintf(buf + len, buf_len - len, "htt_update_peer_cache = %u\n", 1355 le32_to_cpu(htt_stats_buf->htt_update_peer_cache)); 1356 len += scnprintf(buf + len, buf_len - len, "htt_learning_frame = %u\n", 1357 le32_to_cpu(htt_stats_buf->htt_learning_frame)); 1358 len += scnprintf(buf + len, buf_len - len, "fse_invalid_peer = %u\n", 1359 le32_to_cpu(htt_stats_buf->fse_invalid_peer)); 1360 len += scnprintf(buf + len, buf_len - len, "mec_notify = %u\n\n", 1361 le32_to_cpu(htt_stats_buf->mec_notify)); 1362 1363 stats_req->buf_len = len; 1364 } 1365 1366 static void 1367 ath12k_htt_print_tx_de_classify_failed_stats_tlv(const void *tag_buf, u16 tag_len, 1368 struct debug_htt_stats_req *stats_req) 1369 { 1370 const struct ath12k_htt_tx_de_classify_failed_stats_tlv *htt_stats_buf = tag_buf; 1371 u8 *buf = stats_req->buf; 1372 u32 len = stats_req->buf_len; 1373 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1374 1375 if (tag_len < sizeof(*htt_stats_buf)) 1376 return; 1377 1378 len += scnprintf(buf + len, buf_len - len, 1379 "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:\n"); 1380 len += scnprintf(buf + len, buf_len - len, "ap_bss_peer_not_found = %u\n", 1381 le32_to_cpu(htt_stats_buf->ap_bss_peer_not_found)); 1382 len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_no_peer = %u\n", 1383 le32_to_cpu(htt_stats_buf->ap_bcast_mcast_no_peer)); 1384 len += scnprintf(buf + len, buf_len - len, "sta_delete_in_progress = %u\n", 1385 le32_to_cpu(htt_stats_buf->sta_delete_in_progress)); 1386 len += scnprintf(buf + len, buf_len - len, "ibss_no_bss_peer = %u\n", 1387 le32_to_cpu(htt_stats_buf->ibss_no_bss_peer)); 1388 len += scnprintf(buf + len, buf_len - len, "invalid_vdev_type = %u\n", 1389 le32_to_cpu(htt_stats_buf->invalid_vdev_type)); 1390 len += scnprintf(buf + len, buf_len - len, "invalid_ast_peer_entry = %u\n", 1391 le32_to_cpu(htt_stats_buf->invalid_ast_peer_entry)); 1392 len += scnprintf(buf + len, buf_len - len, "peer_entry_invalid = %u\n", 1393 le32_to_cpu(htt_stats_buf->peer_entry_invalid)); 1394 len += scnprintf(buf + len, buf_len - len, "ethertype_not_ip = %u\n", 1395 le32_to_cpu(htt_stats_buf->ethertype_not_ip)); 1396 len += scnprintf(buf + len, buf_len - len, "eapol_lookup_failed = %u\n", 1397 le32_to_cpu(htt_stats_buf->eapol_lookup_failed)); 1398 len += scnprintf(buf + len, buf_len - len, "qpeer_not_allow_data = %u\n", 1399 le32_to_cpu(htt_stats_buf->qpeer_not_allow_data)); 1400 len += scnprintf(buf + len, buf_len - len, "fse_tid_override = %u\n", 1401 le32_to_cpu(htt_stats_buf->fse_tid_override)); 1402 len += scnprintf(buf + len, buf_len - len, "ipv6_jumbogram_zero_length = %u\n", 1403 le32_to_cpu(htt_stats_buf->ipv6_jumbogram_zero_length)); 1404 len += scnprintf(buf + len, buf_len - len, "qos_to_non_qos_in_prog = %u\n", 1405 le32_to_cpu(htt_stats_buf->qos_to_non_qos_in_prog)); 1406 len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_eapol = %u\n", 1407 le32_to_cpu(htt_stats_buf->ap_bcast_mcast_eapol)); 1408 len += scnprintf(buf + len, buf_len - len, "unicast_on_ap_bss_peer = %u\n", 1409 le32_to_cpu(htt_stats_buf->unicast_on_ap_bss_peer)); 1410 len += scnprintf(buf + len, buf_len - len, "ap_vdev_invalid = %u\n", 1411 le32_to_cpu(htt_stats_buf->ap_vdev_invalid)); 1412 len += scnprintf(buf + len, buf_len - len, "incomplete_llc = %u\n", 1413 le32_to_cpu(htt_stats_buf->incomplete_llc)); 1414 len += scnprintf(buf + len, buf_len - len, "eapol_duplicate_m3 = %u\n", 1415 le32_to_cpu(htt_stats_buf->eapol_duplicate_m3)); 1416 len += scnprintf(buf + len, buf_len - len, "eapol_duplicate_m4 = %u\n\n", 1417 le32_to_cpu(htt_stats_buf->eapol_duplicate_m4)); 1418 1419 stats_req->buf_len = len; 1420 } 1421 1422 static void 1423 ath12k_htt_print_tx_de_classify_status_stats_tlv(const void *tag_buf, u16 tag_len, 1424 struct debug_htt_stats_req *stats_req) 1425 { 1426 const struct ath12k_htt_tx_de_classify_status_stats_tlv *htt_stats_buf = tag_buf; 1427 u8 *buf = stats_req->buf; 1428 u32 len = stats_req->buf_len; 1429 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1430 1431 if (tag_len < sizeof(*htt_stats_buf)) 1432 return; 1433 1434 len += scnprintf(buf + len, buf_len - len, 1435 "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:\n"); 1436 len += scnprintf(buf + len, buf_len - len, "eok = %u\n", 1437 le32_to_cpu(htt_stats_buf->eok)); 1438 len += scnprintf(buf + len, buf_len - len, "classify_done = %u\n", 1439 le32_to_cpu(htt_stats_buf->classify_done)); 1440 len += scnprintf(buf + len, buf_len - len, "lookup_failed = %u\n", 1441 le32_to_cpu(htt_stats_buf->lookup_failed)); 1442 len += scnprintf(buf + len, buf_len - len, "send_host_dhcp = %u\n", 1443 le32_to_cpu(htt_stats_buf->send_host_dhcp)); 1444 len += scnprintf(buf + len, buf_len - len, "send_host_mcast = %u\n", 1445 le32_to_cpu(htt_stats_buf->send_host_mcast)); 1446 len += scnprintf(buf + len, buf_len - len, "send_host_unknown_dest = %u\n", 1447 le32_to_cpu(htt_stats_buf->send_host_unknown_dest)); 1448 len += scnprintf(buf + len, buf_len - len, "send_host = %u\n", 1449 le32_to_cpu(htt_stats_buf->send_host)); 1450 len += scnprintf(buf + len, buf_len - len, "status_invalid = %u\n\n", 1451 le32_to_cpu(htt_stats_buf->status_invalid)); 1452 1453 stats_req->buf_len = len; 1454 } 1455 1456 static void 1457 ath12k_htt_print_tx_de_enqueue_packets_stats_tlv(const void *tag_buf, u16 tag_len, 1458 struct debug_htt_stats_req *stats_req) 1459 { 1460 const struct ath12k_htt_tx_de_enqueue_packets_stats_tlv *htt_stats_buf = tag_buf; 1461 u8 *buf = stats_req->buf; 1462 u32 len = stats_req->buf_len; 1463 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1464 1465 if (tag_len < sizeof(*htt_stats_buf)) 1466 return; 1467 1468 len += scnprintf(buf + len, buf_len - len, 1469 "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:\n"); 1470 len += scnprintf(buf + len, buf_len - len, "enqueued_pkts = %u\n", 1471 le32_to_cpu(htt_stats_buf->enqueued_pkts)); 1472 len += scnprintf(buf + len, buf_len - len, "to_tqm = %u\n", 1473 le32_to_cpu(htt_stats_buf->to_tqm)); 1474 len += scnprintf(buf + len, buf_len - len, "to_tqm_bypass = %u\n\n", 1475 le32_to_cpu(htt_stats_buf->to_tqm_bypass)); 1476 1477 stats_req->buf_len = len; 1478 } 1479 1480 static void 1481 ath12k_htt_print_tx_de_enqueue_discard_stats_tlv(const void *tag_buf, u16 tag_len, 1482 struct debug_htt_stats_req *stats_req) 1483 { 1484 const struct ath12k_htt_tx_de_enqueue_discard_stats_tlv *htt_stats_buf = tag_buf; 1485 u8 *buf = stats_req->buf; 1486 u32 len = stats_req->buf_len; 1487 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1488 1489 if (tag_len < sizeof(*htt_stats_buf)) 1490 return; 1491 1492 len += scnprintf(buf + len, buf_len - len, 1493 "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:\n"); 1494 len += scnprintf(buf + len, buf_len - len, "discarded_pkts = %u\n", 1495 le32_to_cpu(htt_stats_buf->discarded_pkts)); 1496 len += scnprintf(buf + len, buf_len - len, "local_frames = %u\n", 1497 le32_to_cpu(htt_stats_buf->local_frames)); 1498 len += scnprintf(buf + len, buf_len - len, "is_ext_msdu = %u\n\n", 1499 le32_to_cpu(htt_stats_buf->is_ext_msdu)); 1500 1501 stats_req->buf_len = len; 1502 } 1503 1504 static void 1505 ath12k_htt_print_tx_de_compl_stats_tlv(const void *tag_buf, u16 tag_len, 1506 struct debug_htt_stats_req *stats_req) 1507 { 1508 const struct ath12k_htt_tx_de_compl_stats_tlv *htt_stats_buf = tag_buf; 1509 u8 *buf = stats_req->buf; 1510 u32 len = stats_req->buf_len; 1511 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1512 1513 if (tag_len < sizeof(*htt_stats_buf)) 1514 return; 1515 1516 len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_COMPL_STATS_TLV:\n"); 1517 len += scnprintf(buf + len, buf_len - len, "tcl_dummy_frame = %u\n", 1518 le32_to_cpu(htt_stats_buf->tcl_dummy_frame)); 1519 len += scnprintf(buf + len, buf_len - len, "tqm_dummy_frame = %u\n", 1520 le32_to_cpu(htt_stats_buf->tqm_dummy_frame)); 1521 len += scnprintf(buf + len, buf_len - len, "tqm_notify_frame = %u\n", 1522 le32_to_cpu(htt_stats_buf->tqm_notify_frame)); 1523 len += scnprintf(buf + len, buf_len - len, "fw2wbm_enq = %u\n", 1524 le32_to_cpu(htt_stats_buf->fw2wbm_enq)); 1525 len += scnprintf(buf + len, buf_len - len, "tqm_bypass_frame = %u\n\n", 1526 le32_to_cpu(htt_stats_buf->tqm_bypass_frame)); 1527 1528 stats_req->buf_len = len; 1529 } 1530 1531 static void 1532 ath12k_htt_print_tx_selfgen_cmn_stats_tlv(const void *tag_buf, u16 tag_len, 1533 struct debug_htt_stats_req *stats_req) 1534 { 1535 const struct ath12k_htt_tx_selfgen_cmn_stats_tlv *htt_stats_buf = tag_buf; 1536 u8 *buf = stats_req->buf; 1537 u32 len = stats_req->buf_len; 1538 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1539 u32 mac_id_word; 1540 1541 if (tag_len < sizeof(*htt_stats_buf)) 1542 return; 1543 1544 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 1545 1546 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n"); 1547 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 1548 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 1549 len += scnprintf(buf + len, buf_len - len, "su_bar = %u\n", 1550 le32_to_cpu(htt_stats_buf->su_bar)); 1551 len += scnprintf(buf + len, buf_len - len, "rts = %u\n", 1552 le32_to_cpu(htt_stats_buf->rts)); 1553 len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n", 1554 le32_to_cpu(htt_stats_buf->cts2self)); 1555 len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n", 1556 le32_to_cpu(htt_stats_buf->qos_null)); 1557 len += scnprintf(buf + len, buf_len - len, "delayed_bar_1 = %u\n", 1558 le32_to_cpu(htt_stats_buf->delayed_bar_1)); 1559 len += scnprintf(buf + len, buf_len - len, "delayed_bar_2 = %u\n", 1560 le32_to_cpu(htt_stats_buf->delayed_bar_2)); 1561 len += scnprintf(buf + len, buf_len - len, "delayed_bar_3 = %u\n", 1562 le32_to_cpu(htt_stats_buf->delayed_bar_3)); 1563 len += scnprintf(buf + len, buf_len - len, "delayed_bar_4 = %u\n", 1564 le32_to_cpu(htt_stats_buf->delayed_bar_4)); 1565 len += scnprintf(buf + len, buf_len - len, "delayed_bar_5 = %u\n", 1566 le32_to_cpu(htt_stats_buf->delayed_bar_5)); 1567 len += scnprintf(buf + len, buf_len - len, "delayed_bar_6 = %u\n", 1568 le32_to_cpu(htt_stats_buf->delayed_bar_6)); 1569 len += scnprintf(buf + len, buf_len - len, "delayed_bar_7 = %u\n\n", 1570 le32_to_cpu(htt_stats_buf->delayed_bar_7)); 1571 1572 stats_req->buf_len = len; 1573 } 1574 1575 static void 1576 ath12k_htt_print_tx_selfgen_ac_stats_tlv(const void *tag_buf, u16 tag_len, 1577 struct debug_htt_stats_req *stats_req) 1578 { 1579 const struct ath12k_htt_tx_selfgen_ac_stats_tlv *htt_stats_buf = tag_buf; 1580 u8 *buf = stats_req->buf; 1581 u32 len = stats_req->buf_len; 1582 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1583 1584 if (tag_len < sizeof(*htt_stats_buf)) 1585 return; 1586 1587 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n"); 1588 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_tried = %u\n", 1589 le32_to_cpu(htt_stats_buf->ac_su_ndpa)); 1590 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_tried = %u\n", 1591 le32_to_cpu(htt_stats_buf->ac_su_ndp)); 1592 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_tried = %u\n", 1593 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndpa)); 1594 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_tried = %u\n", 1595 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndp)); 1596 len += print_array_to_buf_index(buf, len, "ac_mu_mimo_brpollX_tried = ", 1, 1597 htt_stats_buf->ac_mu_mimo_brpoll, 1598 ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS - 1, 1599 "\n\n"); 1600 1601 stats_req->buf_len = len; 1602 } 1603 1604 static void 1605 ath12k_htt_print_tx_selfgen_ax_stats_tlv(const void *tag_buf, u16 tag_len, 1606 struct debug_htt_stats_req *stats_req) 1607 { 1608 const struct ath12k_htt_tx_selfgen_ax_stats_tlv *htt_stats_buf = tag_buf; 1609 u8 *buf = stats_req->buf; 1610 u32 len = stats_req->buf_len; 1611 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1612 1613 if (tag_len < sizeof(*htt_stats_buf)) 1614 return; 1615 1616 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n"); 1617 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_tried = %u\n", 1618 le32_to_cpu(htt_stats_buf->ax_su_ndpa)); 1619 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_tried = %u\n", 1620 le32_to_cpu(htt_stats_buf->ax_su_ndp)); 1621 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_tried = %u\n", 1622 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndpa)); 1623 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_tried = %u\n", 1624 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndp)); 1625 len += print_array_to_buf_index(buf, len, "ax_mu_mimo_brpollX_tried = ", 1, 1626 htt_stats_buf->ax_mu_mimo_brpoll, 1627 ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS - 1, "\n"); 1628 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger = %u\n", 1629 le32_to_cpu(htt_stats_buf->ax_basic_trigger)); 1630 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_total_trigger = %u\n", 1631 le32_to_cpu(htt_stats_buf->ax_ulmumimo_trigger)); 1632 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger = %u\n", 1633 le32_to_cpu(htt_stats_buf->ax_bsr_trigger)); 1634 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n", 1635 le32_to_cpu(htt_stats_buf->ax_mu_bar_trigger)); 1636 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n\n", 1637 le32_to_cpu(htt_stats_buf->ax_mu_rts_trigger)); 1638 1639 stats_req->buf_len = len; 1640 } 1641 1642 static void 1643 ath12k_htt_print_tx_selfgen_be_stats_tlv(const void *tag_buf, u16 tag_len, 1644 struct debug_htt_stats_req *stats_req) 1645 { 1646 const struct ath12k_htt_tx_selfgen_be_stats_tlv *htt_stats_buf = tag_buf; 1647 u8 *buf = stats_req->buf; 1648 u32 len = stats_req->buf_len; 1649 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1650 1651 if (tag_len < sizeof(*htt_stats_buf)) 1652 return; 1653 1654 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_BE_STATS_TLV:\n"); 1655 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_queued = %u\n", 1656 le32_to_cpu(htt_stats_buf->be_su_ndpa_queued)); 1657 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_tried = %u\n", 1658 le32_to_cpu(htt_stats_buf->be_su_ndpa)); 1659 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_queued = %u\n", 1660 le32_to_cpu(htt_stats_buf->be_su_ndp_queued)); 1661 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_tried = %u\n", 1662 le32_to_cpu(htt_stats_buf->be_su_ndp)); 1663 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_queued = %u\n", 1664 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_queued)); 1665 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_tried = %u\n", 1666 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa)); 1667 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_queued = %u\n", 1668 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_queued)); 1669 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_tried = %u\n", 1670 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp)); 1671 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_queued = ", 1, 1672 htt_stats_buf->be_mu_mimo_brpoll_queued, 1673 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1674 "\n"); 1675 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_tried = ", 1, 1676 htt_stats_buf->be_mu_mimo_brpoll, 1677 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1678 "\n"); 1679 len += print_array_to_buf(buf, len, "be_ul_mumimo_trigger = ", 1680 htt_stats_buf->be_ul_mumimo_trigger, 1681 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n"); 1682 len += scnprintf(buf + len, buf_len - len, "be_basic_trigger = %u\n", 1683 le32_to_cpu(htt_stats_buf->be_basic_trigger)); 1684 len += scnprintf(buf + len, buf_len - len, "be_ulmumimo_total_trigger = %u\n", 1685 le32_to_cpu(htt_stats_buf->be_ulmumimo_trigger)); 1686 len += scnprintf(buf + len, buf_len - len, "be_bsr_trigger = %u\n", 1687 le32_to_cpu(htt_stats_buf->be_bsr_trigger)); 1688 len += scnprintf(buf + len, buf_len - len, "be_mu_bar_trigger = %u\n", 1689 le32_to_cpu(htt_stats_buf->be_mu_bar_trigger)); 1690 len += scnprintf(buf + len, buf_len - len, "be_mu_rts_trigger = %u\n\n", 1691 le32_to_cpu(htt_stats_buf->be_mu_rts_trigger)); 1692 1693 stats_req->buf_len = len; 1694 } 1695 1696 static void 1697 ath12k_htt_print_tx_selfgen_ac_err_stats_tlv(const void *tag_buf, u16 tag_len, 1698 struct debug_htt_stats_req *stats_req) 1699 { 1700 const struct ath12k_htt_tx_selfgen_ac_err_stats_tlv *htt_stats_buf = tag_buf; 1701 u8 *buf = stats_req->buf; 1702 u32 len = stats_req->buf_len; 1703 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1704 1705 if (tag_len < sizeof(*htt_stats_buf)) 1706 return; 1707 1708 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n"); 1709 len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_err = %u\n", 1710 le32_to_cpu(htt_stats_buf->ac_su_ndp_err)); 1711 len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n", 1712 le32_to_cpu(htt_stats_buf->ac_su_ndpa_err)); 1713 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n", 1714 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndpa_err)); 1715 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n", 1716 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndp_err)); 1717 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n", 1718 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp1_err)); 1719 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n", 1720 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp2_err)); 1721 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n", 1722 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp3_err)); 1723 1724 stats_req->buf_len = len; 1725 } 1726 1727 static void 1728 ath12k_htt_print_tx_selfgen_ax_err_stats_tlv(const void *tag_buf, u16 tag_len, 1729 struct debug_htt_stats_req *stats_req) 1730 { 1731 const struct ath12k_htt_tx_selfgen_ax_err_stats_tlv *htt_stats_buf = tag_buf; 1732 u8 *buf = stats_req->buf; 1733 u32 len = stats_req->buf_len; 1734 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1735 1736 if (tag_len < sizeof(*htt_stats_buf)) 1737 return; 1738 1739 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n"); 1740 len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_err = %u\n", 1741 le32_to_cpu(htt_stats_buf->ax_su_ndp_err)); 1742 len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n", 1743 le32_to_cpu(htt_stats_buf->ax_su_ndpa_err)); 1744 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n", 1745 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndpa_err)); 1746 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n", 1747 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndp_err)); 1748 len += print_array_to_buf_index(buf, len, "ax_mu_mimo_brpX_err", 1, 1749 htt_stats_buf->ax_mu_mimo_brp_err, 1750 ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS - 1, 1751 "\n"); 1752 len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger_err = %u\n", 1753 le32_to_cpu(htt_stats_buf->ax_basic_trigger_err)); 1754 len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_total_trigger_err = %u\n", 1755 le32_to_cpu(htt_stats_buf->ax_ulmumimo_trigger_err)); 1756 len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n", 1757 le32_to_cpu(htt_stats_buf->ax_bsr_trigger_err)); 1758 len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n", 1759 le32_to_cpu(htt_stats_buf->ax_mu_bar_trigger_err)); 1760 len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n\n", 1761 le32_to_cpu(htt_stats_buf->ax_mu_rts_trigger_err)); 1762 1763 stats_req->buf_len = len; 1764 } 1765 1766 static void 1767 ath12k_htt_print_tx_selfgen_be_err_stats_tlv(const void *tag_buf, u16 tag_len, 1768 struct debug_htt_stats_req *stats_req) 1769 { 1770 const struct ath12k_htt_tx_selfgen_be_err_stats_tlv *htt_stats_buf = tag_buf; 1771 u8 *buf = stats_req->buf; 1772 u32 len = stats_req->buf_len; 1773 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1774 1775 if (tag_len < sizeof(*htt_stats_buf)) 1776 return; 1777 1778 len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_BE_ERR_STATS_TLV:\n"); 1779 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_err = %u\n", 1780 le32_to_cpu(htt_stats_buf->be_su_ndp_err)); 1781 len += scnprintf(buf + len, buf_len - len, "be_su_ndp_flushed = %u\n", 1782 le32_to_cpu(htt_stats_buf->be_su_ndp_flushed)); 1783 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_err = %u\n", 1784 le32_to_cpu(htt_stats_buf->be_su_ndpa_err)); 1785 len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_flushed = %u\n", 1786 le32_to_cpu(htt_stats_buf->be_su_ndpa_flushed)); 1787 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_err = %u\n", 1788 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_err)); 1789 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_flushed = %u\n", 1790 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_flushed)); 1791 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_err = %u\n", 1792 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_err)); 1793 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_flushed = %u\n", 1794 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_flushed)); 1795 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpX_err", 1, 1796 htt_stats_buf->be_mu_mimo_brp_err, 1797 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1798 "\n"); 1799 len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_flushed", 1, 1800 htt_stats_buf->be_mu_mimo_brpoll_flushed, 1801 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1, 1802 "\n"); 1803 len += print_array_to_buf(buf, len, "be_mu_mimo_num_cbf_rcvd_on_brp_err", 1804 htt_stats_buf->be_mu_mimo_brp_err_num_cbf_rxd, 1805 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n"); 1806 len += print_array_to_buf(buf, len, "be_ul_mumimo_trigger_err", 1807 htt_stats_buf->be_ul_mumimo_trigger_err, 1808 ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n"); 1809 len += scnprintf(buf + len, buf_len - len, "be_basic_trigger_err = %u\n", 1810 le32_to_cpu(htt_stats_buf->be_basic_trigger_err)); 1811 len += scnprintf(buf + len, buf_len - len, "be_ulmumimo_total_trig_err = %u\n", 1812 le32_to_cpu(htt_stats_buf->be_ulmumimo_trigger_err)); 1813 len += scnprintf(buf + len, buf_len - len, "be_bsr_trigger_err = %u\n", 1814 le32_to_cpu(htt_stats_buf->be_bsr_trigger_err)); 1815 len += scnprintf(buf + len, buf_len - len, "be_mu_bar_trigger_err = %u\n", 1816 le32_to_cpu(htt_stats_buf->be_mu_bar_trigger_err)); 1817 len += scnprintf(buf + len, buf_len - len, "be_mu_rts_trigger_err = %u\n\n", 1818 le32_to_cpu(htt_stats_buf->be_mu_rts_trigger_err)); 1819 1820 stats_req->buf_len = len; 1821 } 1822 1823 static void 1824 ath12k_htt_print_tx_selfgen_ac_sched_status_stats_tlv(const void *tag_buf, u16 tag_len, 1825 struct debug_htt_stats_req *stats) 1826 { 1827 const struct ath12k_htt_tx_selfgen_ac_sched_status_stats_tlv *htt_stats_buf = 1828 tag_buf; 1829 u8 *buf = stats->buf; 1830 u32 len = stats->buf_len; 1831 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1832 1833 if (tag_len < sizeof(*htt_stats_buf)) 1834 return; 1835 1836 len += scnprintf(buf + len, buf_len - len, 1837 "HTT_TX_SELFGEN_AC_SCHED_STATUS_STATS_TLV:\n"); 1838 len += print_array_to_buf(buf, len, "ac_su_ndpa_sch_status", 1839 htt_stats_buf->ac_su_ndpa_sch_status, 1840 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1841 len += print_array_to_buf(buf, len, "ac_su_ndp_sch_status", 1842 htt_stats_buf->ac_su_ndp_sch_status, 1843 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1844 len += print_array_to_buf(buf, len, "ac_mu_mimo_ndpa_sch_status", 1845 htt_stats_buf->ac_mu_mimo_ndpa_sch_status, 1846 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1847 len += print_array_to_buf(buf, len, "ac_mu_mimo_ndp_sch_status", 1848 htt_stats_buf->ac_mu_mimo_ndp_sch_status, 1849 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1850 len += print_array_to_buf(buf, len, "ac_mu_mimo_brp_sch_status", 1851 htt_stats_buf->ac_mu_mimo_brp_sch_status, 1852 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1853 len += print_array_to_buf(buf, len, "ac_su_ndp_sch_flag_err", 1854 htt_stats_buf->ac_su_ndp_sch_flag_err, 1855 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1856 len += print_array_to_buf(buf, len, "ac_mu_mimo_ndp_sch_flag_err", 1857 htt_stats_buf->ac_mu_mimo_ndp_sch_flag_err, 1858 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1859 len += print_array_to_buf(buf, len, "ac_mu_mimo_brp_sch_flag_err", 1860 htt_stats_buf->ac_mu_mimo_brp_sch_flag_err, 1861 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n"); 1862 1863 stats->buf_len = len; 1864 } 1865 1866 static void 1867 ath12k_htt_print_tx_selfgen_ax_sched_status_stats_tlv(const void *tag_buf, u16 tag_len, 1868 struct debug_htt_stats_req *stats) 1869 { 1870 const struct ath12k_htt_tx_selfgen_ax_sched_status_stats_tlv *htt_stats_buf = 1871 tag_buf; 1872 u8 *buf = stats->buf; 1873 u32 len = stats->buf_len; 1874 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1875 1876 if (tag_len < sizeof(*htt_stats_buf)) 1877 return; 1878 1879 len += scnprintf(buf + len, buf_len - len, 1880 "HTT_TX_SELFGEN_AX_SCHED_STATUS_STATS_TLV:\n"); 1881 len += print_array_to_buf(buf, len, "ax_su_ndpa_sch_status", 1882 htt_stats_buf->ax_su_ndpa_sch_status, 1883 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1884 len += print_array_to_buf(buf, len, "ax_su_ndp_sch_status", 1885 htt_stats_buf->ax_su_ndp_sch_status, 1886 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1887 len += print_array_to_buf(buf, len, "ax_mu_mimo_ndpa_sch_status", 1888 htt_stats_buf->ax_mu_mimo_ndpa_sch_status, 1889 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1890 len += print_array_to_buf(buf, len, "ax_mu_mimo_ndp_sch_status", 1891 htt_stats_buf->ax_mu_mimo_ndp_sch_status, 1892 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1893 len += print_array_to_buf(buf, len, "ax_mu_brp_sch_status", 1894 htt_stats_buf->ax_mu_brp_sch_status, 1895 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1896 len += print_array_to_buf(buf, len, "ax_mu_bar_sch_status", 1897 htt_stats_buf->ax_mu_bar_sch_status, 1898 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1899 len += print_array_to_buf(buf, len, "ax_basic_trig_sch_status", 1900 htt_stats_buf->ax_basic_trig_sch_status, 1901 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1902 len += print_array_to_buf(buf, len, "ax_su_ndp_sch_flag_err", 1903 htt_stats_buf->ax_su_ndp_sch_flag_err, 1904 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1905 len += print_array_to_buf(buf, len, "ax_mu_mimo_ndp_sch_flag_err", 1906 htt_stats_buf->ax_mu_mimo_ndp_sch_flag_err, 1907 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1908 len += print_array_to_buf(buf, len, "ax_mu_brp_sch_flag_err", 1909 htt_stats_buf->ax_mu_brp_sch_flag_err, 1910 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1911 len += print_array_to_buf(buf, len, "ax_mu_bar_sch_flag_err", 1912 htt_stats_buf->ax_mu_bar_sch_flag_err, 1913 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1914 len += print_array_to_buf(buf, len, "ax_basic_trig_sch_flag_err", 1915 htt_stats_buf->ax_basic_trig_sch_flag_err, 1916 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1917 len += print_array_to_buf(buf, len, "ax_ulmumimo_trig_sch_status", 1918 htt_stats_buf->ax_ulmumimo_trig_sch_status, 1919 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1920 len += print_array_to_buf(buf, len, "ax_ulmumimo_trig_sch_flag_err", 1921 htt_stats_buf->ax_ulmumimo_trig_sch_flag_err, 1922 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n"); 1923 1924 stats->buf_len = len; 1925 } 1926 1927 static void 1928 ath12k_htt_print_tx_selfgen_be_sched_status_stats_tlv(const void *tag_buf, u16 tag_len, 1929 struct debug_htt_stats_req *stats) 1930 { 1931 const struct ath12k_htt_tx_selfgen_be_sched_status_stats_tlv *htt_stats_buf = 1932 tag_buf; 1933 u8 *buf = stats->buf; 1934 u32 len = stats->buf_len; 1935 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1936 1937 if (tag_len < sizeof(*htt_stats_buf)) 1938 return; 1939 1940 len += scnprintf(buf + len, buf_len - len, 1941 "HTT_TX_SELFGEN_BE_SCHED_STATUS_STATS_TLV:\n"); 1942 len += print_array_to_buf(buf, len, "be_su_ndpa_sch_status", 1943 htt_stats_buf->be_su_ndpa_sch_status, 1944 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1945 len += print_array_to_buf(buf, len, "be_su_ndp_sch_status", 1946 htt_stats_buf->be_su_ndp_sch_status, 1947 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1948 len += print_array_to_buf(buf, len, "be_mu_mimo_ndpa_sch_status", 1949 htt_stats_buf->be_mu_mimo_ndpa_sch_status, 1950 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1951 len += print_array_to_buf(buf, len, "be_mu_mimo_ndp_sch_status", 1952 htt_stats_buf->be_mu_mimo_ndp_sch_status, 1953 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1954 len += print_array_to_buf(buf, len, "be_mu_brp_sch_status", 1955 htt_stats_buf->be_mu_brp_sch_status, 1956 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1957 len += print_array_to_buf(buf, len, "be_mu_bar_sch_status", 1958 htt_stats_buf->be_mu_bar_sch_status, 1959 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1960 len += print_array_to_buf(buf, len, "be_basic_trig_sch_status", 1961 htt_stats_buf->be_basic_trig_sch_status, 1962 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1963 len += print_array_to_buf(buf, len, "be_su_ndp_sch_flag_err", 1964 htt_stats_buf->be_su_ndp_sch_flag_err, 1965 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1966 len += print_array_to_buf(buf, len, "be_mu_mimo_ndp_sch_flag_err", 1967 htt_stats_buf->be_mu_mimo_ndp_sch_flag_err, 1968 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1969 len += print_array_to_buf(buf, len, "be_mu_brp_sch_flag_err", 1970 htt_stats_buf->be_mu_brp_sch_flag_err, 1971 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1972 len += print_array_to_buf(buf, len, "be_mu_bar_sch_flag_err", 1973 htt_stats_buf->be_mu_bar_sch_flag_err, 1974 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1975 len += print_array_to_buf(buf, len, "be_basic_trig_sch_flag_err", 1976 htt_stats_buf->be_basic_trig_sch_flag_err, 1977 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n"); 1978 len += print_array_to_buf(buf, len, "be_basic_trig_sch_flag_err", 1979 htt_stats_buf->be_basic_trig_sch_flag_err, 1980 ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n"); 1981 len += print_array_to_buf(buf, len, "be_ulmumimo_trig_sch_flag_err", 1982 htt_stats_buf->be_ulmumimo_trig_sch_flag_err, 1983 ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n"); 1984 1985 stats->buf_len = len; 1986 } 1987 1988 static void 1989 ath12k_htt_print_stats_string_tlv(const void *tag_buf, u16 tag_len, 1990 struct debug_htt_stats_req *stats_req) 1991 { 1992 const struct ath12k_htt_stats_string_tlv *htt_stats_buf = tag_buf; 1993 u8 *buf = stats_req->buf; 1994 u32 len = stats_req->buf_len; 1995 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 1996 u8 i; 1997 u16 index = 0; 1998 u32 datum; 1999 char data[ATH12K_HTT_MAX_STRING_LEN] = {0}; 2000 2001 tag_len = tag_len >> 2; 2002 2003 len += scnprintf(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n"); 2004 for (i = 0; i < tag_len; i++) { 2005 datum = __le32_to_cpu(htt_stats_buf->data[i]); 2006 index += scnprintf(&data[index], ATH12K_HTT_MAX_STRING_LEN - index, 2007 "%.*s", 4, (char *)&datum); 2008 if (index >= ATH12K_HTT_MAX_STRING_LEN) 2009 break; 2010 } 2011 len += scnprintf(buf + len, buf_len - len, "data = %s\n\n", data); 2012 2013 stats_req->buf_len = len; 2014 } 2015 2016 static void 2017 ath12k_htt_print_sring_stats_tlv(const void *tag_buf, u16 tag_len, 2018 struct debug_htt_stats_req *stats_req) 2019 { 2020 const struct ath12k_htt_sring_stats_tlv *htt_stats_buf = tag_buf; 2021 u8 *buf = stats_req->buf; 2022 u32 len = stats_req->buf_len; 2023 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2024 u32 mac_id_word; 2025 u32 avail_words; 2026 u32 head_tail_ptr; 2027 u32 sring_stat; 2028 u32 tail_ptr; 2029 2030 if (tag_len < sizeof(*htt_stats_buf)) 2031 return; 2032 2033 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__ring_id__arena__ep); 2034 avail_words = __le32_to_cpu(htt_stats_buf->num_avail_words__num_valid_words); 2035 head_tail_ptr = __le32_to_cpu(htt_stats_buf->head_ptr__tail_ptr); 2036 sring_stat = __le32_to_cpu(htt_stats_buf->consumer_empty__producer_full); 2037 tail_ptr = __le32_to_cpu(htt_stats_buf->prefetch_count__internal_tail_ptr); 2038 2039 len += scnprintf(buf + len, buf_len - len, "HTT_SRING_STATS_TLV:\n"); 2040 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 2041 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_MAC_ID)); 2042 len += scnprintf(buf + len, buf_len - len, "ring_id = %u\n", 2043 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_RING_ID)); 2044 len += scnprintf(buf + len, buf_len - len, "arena = %u\n", 2045 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_ARENA)); 2046 len += scnprintf(buf + len, buf_len - len, "ep = %u\n", 2047 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_EP)); 2048 len += scnprintf(buf + len, buf_len - len, "base_addr_lsb = 0x%x\n", 2049 le32_to_cpu(htt_stats_buf->base_addr_lsb)); 2050 len += scnprintf(buf + len, buf_len - len, "base_addr_msb = 0x%x\n", 2051 le32_to_cpu(htt_stats_buf->base_addr_msb)); 2052 len += scnprintf(buf + len, buf_len - len, "ring_size = %u\n", 2053 le32_to_cpu(htt_stats_buf->ring_size)); 2054 len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n", 2055 le32_to_cpu(htt_stats_buf->elem_size)); 2056 len += scnprintf(buf + len, buf_len - len, "num_avail_words = %u\n", 2057 u32_get_bits(avail_words, 2058 ATH12K_HTT_SRING_STATS_NUM_AVAIL_WORDS)); 2059 len += scnprintf(buf + len, buf_len - len, "num_valid_words = %u\n", 2060 u32_get_bits(avail_words, 2061 ATH12K_HTT_SRING_STATS_NUM_VALID_WORDS)); 2062 len += scnprintf(buf + len, buf_len - len, "head_ptr = %u\n", 2063 u32_get_bits(head_tail_ptr, ATH12K_HTT_SRING_STATS_HEAD_PTR)); 2064 len += scnprintf(buf + len, buf_len - len, "tail_ptr = %u\n", 2065 u32_get_bits(head_tail_ptr, ATH12K_HTT_SRING_STATS_TAIL_PTR)); 2066 len += scnprintf(buf + len, buf_len - len, "consumer_empty = %u\n", 2067 u32_get_bits(sring_stat, 2068 ATH12K_HTT_SRING_STATS_CONSUMER_EMPTY)); 2069 len += scnprintf(buf + len, buf_len - len, "producer_full = %u\n", 2070 u32_get_bits(head_tail_ptr, 2071 ATH12K_HTT_SRING_STATS_PRODUCER_FULL)); 2072 len += scnprintf(buf + len, buf_len - len, "prefetch_count = %u\n", 2073 u32_get_bits(tail_ptr, ATH12K_HTT_SRING_STATS_PREFETCH_COUNT)); 2074 len += scnprintf(buf + len, buf_len - len, "internal_tail_ptr = %u\n\n", 2075 u32_get_bits(tail_ptr, 2076 ATH12K_HTT_SRING_STATS_INTERNAL_TAIL_PTR)); 2077 2078 stats_req->buf_len = len; 2079 } 2080 2081 static void 2082 ath12k_htt_print_sfm_cmn_tlv(const void *tag_buf, u16 tag_len, 2083 struct debug_htt_stats_req *stats_req) 2084 { 2085 const struct ath12k_htt_sfm_cmn_tlv *htt_stats_buf = tag_buf; 2086 u8 *buf = stats_req->buf; 2087 u32 len = stats_req->buf_len; 2088 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2089 u32 mac_id_word; 2090 2091 if (tag_len < sizeof(*htt_stats_buf)) 2092 return; 2093 2094 mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word); 2095 2096 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CMN_TLV:\n"); 2097 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 2098 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 2099 len += scnprintf(buf + len, buf_len - len, "buf_total = %u\n", 2100 le32_to_cpu(htt_stats_buf->buf_total)); 2101 len += scnprintf(buf + len, buf_len - len, "mem_empty = %u\n", 2102 le32_to_cpu(htt_stats_buf->mem_empty)); 2103 len += scnprintf(buf + len, buf_len - len, "deallocate_bufs = %u\n", 2104 le32_to_cpu(htt_stats_buf->deallocate_bufs)); 2105 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n", 2106 le32_to_cpu(htt_stats_buf->num_records)); 2107 2108 stats_req->buf_len = len; 2109 } 2110 2111 static void 2112 ath12k_htt_print_sfm_client_tlv(const void *tag_buf, u16 tag_len, 2113 struct debug_htt_stats_req *stats_req) 2114 { 2115 const struct ath12k_htt_sfm_client_tlv *htt_stats_buf = tag_buf; 2116 u8 *buf = stats_req->buf; 2117 u32 len = stats_req->buf_len; 2118 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2119 2120 if (tag_len < sizeof(*htt_stats_buf)) 2121 return; 2122 2123 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_TLV:\n"); 2124 len += scnprintf(buf + len, buf_len - len, "client_id = %u\n", 2125 le32_to_cpu(htt_stats_buf->client_id)); 2126 len += scnprintf(buf + len, buf_len - len, "buf_min = %u\n", 2127 le32_to_cpu(htt_stats_buf->buf_min)); 2128 len += scnprintf(buf + len, buf_len - len, "buf_max = %u\n", 2129 le32_to_cpu(htt_stats_buf->buf_max)); 2130 len += scnprintf(buf + len, buf_len - len, "buf_busy = %u\n", 2131 le32_to_cpu(htt_stats_buf->buf_busy)); 2132 len += scnprintf(buf + len, buf_len - len, "buf_alloc = %u\n", 2133 le32_to_cpu(htt_stats_buf->buf_alloc)); 2134 len += scnprintf(buf + len, buf_len - len, "buf_avail = %u\n", 2135 le32_to_cpu(htt_stats_buf->buf_avail)); 2136 len += scnprintf(buf + len, buf_len - len, "num_users = %u\n\n", 2137 le32_to_cpu(htt_stats_buf->num_users)); 2138 2139 stats_req->buf_len = len; 2140 } 2141 2142 static void 2143 ath12k_htt_print_sfm_client_user_tlv(const void *tag_buf, u16 tag_len, 2144 struct debug_htt_stats_req *stats_req) 2145 { 2146 const struct ath12k_htt_sfm_client_user_tlv *htt_stats_buf = tag_buf; 2147 u8 *buf = stats_req->buf; 2148 u32 len = stats_req->buf_len; 2149 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2150 u16 num_elems = tag_len >> 2; 2151 2152 len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_USER_TLV:\n"); 2153 len += print_array_to_buf(buf, len, "dwords_used_by_user_n", 2154 htt_stats_buf->dwords_used_by_user_n, 2155 num_elems, "\n\n"); 2156 2157 stats_req->buf_len = len; 2158 } 2159 2160 static void 2161 ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(const void *tag_buf, u16 tag_len, 2162 struct debug_htt_stats_req *stats_req) 2163 { 2164 const struct ath12k_htt_tx_pdev_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf; 2165 u8 *buf = stats_req->buf; 2166 u32 len = stats_req->buf_len; 2167 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2168 u8 i; 2169 2170 if (tag_len < sizeof(*htt_stats_buf)) 2171 return; 2172 2173 len += scnprintf(buf + len, buf_len - len, 2174 "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n"); 2175 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n", 2176 le32_to_cpu(htt_stats_buf->mu_mimo_sch_posted)); 2177 len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n", 2178 le32_to_cpu(htt_stats_buf->mu_mimo_sch_failed)); 2179 len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n", 2180 le32_to_cpu(htt_stats_buf->mu_mimo_ppdu_posted)); 2181 len += scnprintf(buf + len, buf_len - len, 2182 "\nac_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0, 2183 le32_to_cpu(htt_stats_buf->ac_mu_mimo_per_grp_sz[0])); 2184 for (i = 1; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) { 2185 len += scnprintf(buf + len, buf_len - len, 2186 "ac_mu_mimo_sch_posted_per_group_index %u ", i); 2187 len += scnprintf(buf + len, buf_len - len, 2188 "(TOTAL STREAMS = %u) = %u\n", i + 1, 2189 le32_to_cpu(htt_stats_buf->ac_mu_mimo_per_grp_sz[i])); 2190 } 2191 2192 for (i = 0; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) { 2193 len += scnprintf(buf + len, buf_len - len, 2194 "ac_mu_mimo_sch_posted_per_group_index %u ", 2195 i + ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS); 2196 len += scnprintf(buf + len, buf_len - len, 2197 "(TOTAL STREAMS = %u) = %u\n", 2198 i + ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS + 1, 2199 le32_to_cpu(htt_stats_buf->ac_mu_mimo_grp_sz_ext[i])); 2200 } 2201 2202 len += scnprintf(buf + len, buf_len - len, 2203 "\nax_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0, 2204 le32_to_cpu(htt_stats_buf->ax_mu_mimo_per_grp_sz[0])); 2205 for (i = 1; i < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; i++) { 2206 len += scnprintf(buf + len, buf_len - len, 2207 "ax_mu_mimo_sch_posted_per_group_index %u ", i); 2208 len += scnprintf(buf + len, buf_len - len, 2209 "(TOTAL STREAMS = %u) = %u\n", i + 1, 2210 le32_to_cpu(htt_stats_buf->ax_mu_mimo_per_grp_sz[i])); 2211 } 2212 2213 len += scnprintf(buf + len, buf_len - len, 2214 "\nbe_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0, 2215 le32_to_cpu(htt_stats_buf->be_mu_mimo_per_grp_sz[0])); 2216 for (i = 1; i < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; i++) { 2217 len += scnprintf(buf + len, buf_len - len, 2218 "be_mu_mimo_sch_posted_per_group_index %u ", i); 2219 len += scnprintf(buf + len, buf_len - len, 2220 "(TOTAL STREAMS = %u) = %u\n", i + 1, 2221 le32_to_cpu(htt_stats_buf->be_mu_mimo_per_grp_sz[i])); 2222 } 2223 2224 len += scnprintf(buf + len, buf_len - len, "\n11ac MU_MIMO SCH STATS:\n"); 2225 for (i = 0; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) { 2226 len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_sch_nusers_"); 2227 len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i, 2228 le32_to_cpu(htt_stats_buf->ac_mu_mimo_sch_nusers[i])); 2229 } 2230 2231 len += scnprintf(buf + len, buf_len - len, "\n11ax MU_MIMO SCH STATS:\n"); 2232 for (i = 0; i < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; i++) { 2233 len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_sch_nusers_"); 2234 len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i, 2235 le32_to_cpu(htt_stats_buf->ax_mu_mimo_sch_nusers[i])); 2236 } 2237 2238 len += scnprintf(buf + len, buf_len - len, "\n11be MU_MIMO SCH STATS:\n"); 2239 for (i = 0; i < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; i++) { 2240 len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_sch_nusers_"); 2241 len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i, 2242 le32_to_cpu(htt_stats_buf->be_mu_mimo_sch_nusers[i])); 2243 } 2244 2245 len += scnprintf(buf + len, buf_len - len, "\n11ax OFDMA SCH STATS:\n"); 2246 for (i = 0; i < ATH12K_HTT_TX_NUM_OFDMA_USER_STATS; i++) { 2247 len += scnprintf(buf + len, buf_len - len, 2248 "ax_ofdma_sch_nusers_%u = %u\n", i, 2249 le32_to_cpu(htt_stats_buf->ax_ofdma_sch_nusers[i])); 2250 len += scnprintf(buf + len, buf_len - len, 2251 "ax_ul_ofdma_basic_sch_nusers_%u = %u\n", i, 2252 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_nusers[i])); 2253 len += scnprintf(buf + len, buf_len - len, 2254 "ax_ul_ofdma_bsr_sch_nusers_%u = %u\n", i, 2255 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_bsr_nusers[i])); 2256 len += scnprintf(buf + len, buf_len - len, 2257 "ax_ul_ofdma_bar_sch_nusers_%u = %u\n", i, 2258 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_bar_nusers[i])); 2259 len += scnprintf(buf + len, buf_len - len, 2260 "ax_ul_ofdma_brp_sch_nusers_%u = %u\n\n", i, 2261 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_brp_nusers[i])); 2262 } 2263 2264 len += scnprintf(buf + len, buf_len - len, "11ax UL MUMIMO SCH STATS:\n"); 2265 for (i = 0; i < ATH12K_HTT_TX_NUM_UL_MUMIMO_USER_STATS; i++) { 2266 len += scnprintf(buf + len, buf_len - len, 2267 "ax_ul_mumimo_basic_sch_nusers_%u = %u\n", i, 2268 le32_to_cpu(htt_stats_buf->ax_ul_mumimo_nusers[i])); 2269 len += scnprintf(buf + len, buf_len - len, 2270 "ax_ul_mumimo_brp_sch_nusers_%u = %u\n\n", i, 2271 le32_to_cpu(htt_stats_buf->ax_ul_mumimo_brp_nusers[i])); 2272 } 2273 2274 stats_req->buf_len = len; 2275 } 2276 2277 static void 2278 ath12k_htt_print_tx_pdev_mumimo_grp_stats_tlv(const void *tag_buf, u16 tag_len, 2279 struct debug_htt_stats_req *stats_req) 2280 { 2281 const struct ath12k_htt_tx_pdev_mumimo_grp_stats_tlv *htt_stats_buf = tag_buf; 2282 u8 *buf = stats_req->buf; 2283 u32 len = stats_req->buf_len; 2284 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2285 int j; 2286 2287 if (tag_len < sizeof(*htt_stats_buf)) 2288 return; 2289 2290 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_MUMIMO_GRP_STATS:\n"); 2291 len += print_array_to_buf(buf, len, 2292 "dl_mumimo_grp_tputs_observed (per bin = 300 mbps)", 2293 htt_stats_buf->dl_mumimo_grp_tputs, 2294 ATH12K_HTT_STATS_MUMIMO_TPUT_NUM_BINS, "\n"); 2295 len += print_array_to_buf(buf, len, "dl_mumimo_grp eligible", 2296 htt_stats_buf->dl_mumimo_grp_eligible, 2297 ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n"); 2298 len += print_array_to_buf(buf, len, "dl_mumimo_grp_ineligible", 2299 htt_stats_buf->dl_mumimo_grp_ineligible, 2300 ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n"); 2301 len += scnprintf(buf + len, buf_len - len, "dl_mumimo_grp_invalid:\n"); 2302 for (j = 0; j < ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ; j++) { 2303 len += scnprintf(buf + len, buf_len - len, "grp_id = %u", j); 2304 len += print_array_to_buf(buf, len, "", 2305 htt_stats_buf->dl_mumimo_grp_invalid, 2306 ATH12K_HTT_STATS_MAX_INVALID_REASON_CODE, 2307 "\n"); 2308 } 2309 2310 len += print_array_to_buf(buf, len, "ul_mumimo_grp_best_grp_size", 2311 htt_stats_buf->ul_mumimo_grp_best_grp_size, 2312 ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n"); 2313 len += print_array_to_buf(buf, len, "ul_mumimo_grp_best_num_usrs = ", 2314 htt_stats_buf->ul_mumimo_grp_best_usrs, 2315 ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS, "\n"); 2316 len += print_array_to_buf(buf, len, 2317 "ul_mumimo_grp_tputs_observed (per bin = 300 mbps)", 2318 htt_stats_buf->ul_mumimo_grp_tputs, 2319 ATH12K_HTT_STATS_MUMIMO_TPUT_NUM_BINS, "\n\n"); 2320 2321 stats_req->buf_len = len; 2322 } 2323 2324 static void 2325 ath12k_htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(const void *tag_buf, u16 tag_len, 2326 struct debug_htt_stats_req *stats_req) 2327 { 2328 const struct ath12k_htt_tx_pdev_mpdu_stats_tlv *htt_stats_buf = tag_buf; 2329 u8 *buf = stats_req->buf; 2330 u32 len = stats_req->buf_len; 2331 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2332 u32 user_index; 2333 u32 tx_sched_mode; 2334 2335 if (tag_len < sizeof(*htt_stats_buf)) 2336 return; 2337 2338 user_index = __le32_to_cpu(htt_stats_buf->user_index); 2339 tx_sched_mode = __le32_to_cpu(htt_stats_buf->tx_sched_mode); 2340 2341 if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_MIMO_AC) { 2342 if (!user_index) 2343 len += scnprintf(buf + len, buf_len - len, 2344 "HTT_TX_PDEV_MU_MIMO_AC_MPDU_STATS:\n"); 2345 2346 if (user_index < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS) { 2347 len += scnprintf(buf + len, buf_len - len, 2348 "ac_mu_mimo_mpdus_queued_usr_%u = %u\n", 2349 user_index, 2350 le32_to_cpu(htt_stats_buf->mpdus_queued_usr)); 2351 len += scnprintf(buf + len, buf_len - len, 2352 "ac_mu_mimo_mpdus_tried_usr_%u = %u\n", 2353 user_index, 2354 le32_to_cpu(htt_stats_buf->mpdus_tried_usr)); 2355 len += scnprintf(buf + len, buf_len - len, 2356 "ac_mu_mimo_mpdus_failed_usr_%u = %u\n", 2357 user_index, 2358 le32_to_cpu(htt_stats_buf->mpdus_failed_usr)); 2359 len += scnprintf(buf + len, buf_len - len, 2360 "ac_mu_mimo_mpdus_requeued_usr_%u = %u\n", 2361 user_index, 2362 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr)); 2363 len += scnprintf(buf + len, buf_len - len, 2364 "ac_mu_mimo_err_no_ba_usr_%u = %u\n", 2365 user_index, 2366 le32_to_cpu(htt_stats_buf->err_no_ba_usr)); 2367 len += scnprintf(buf + len, buf_len - len, 2368 "ac_mu_mimo_mpdu_underrun_usr_%u = %u\n", 2369 user_index, 2370 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr)); 2371 len += scnprintf(buf + len, buf_len - len, 2372 "ac_mu_mimo_ampdu_underrun_usr_%u = %u\n\n", 2373 user_index, 2374 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr)); 2375 } 2376 } 2377 2378 if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_MIMO_AX) { 2379 if (!user_index) 2380 len += scnprintf(buf + len, buf_len - len, 2381 "HTT_TX_PDEV_MU_MIMO_AX_MPDU_STATS:\n"); 2382 2383 if (user_index < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS) { 2384 len += scnprintf(buf + len, buf_len - len, 2385 "ax_mu_mimo_mpdus_queued_usr_%u = %u\n", 2386 user_index, 2387 le32_to_cpu(htt_stats_buf->mpdus_queued_usr)); 2388 len += scnprintf(buf + len, buf_len - len, 2389 "ax_mu_mimo_mpdus_tried_usr_%u = %u\n", 2390 user_index, 2391 le32_to_cpu(htt_stats_buf->mpdus_tried_usr)); 2392 len += scnprintf(buf + len, buf_len - len, 2393 "ax_mu_mimo_mpdus_failed_usr_%u = %u\n", 2394 user_index, 2395 le32_to_cpu(htt_stats_buf->mpdus_failed_usr)); 2396 len += scnprintf(buf + len, buf_len - len, 2397 "ax_mu_mimo_mpdus_requeued_usr_%u = %u\n", 2398 user_index, 2399 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr)); 2400 len += scnprintf(buf + len, buf_len - len, 2401 "ax_mu_mimo_err_no_ba_usr_%u = %u\n", 2402 user_index, 2403 le32_to_cpu(htt_stats_buf->err_no_ba_usr)); 2404 len += scnprintf(buf + len, buf_len - len, 2405 "ax_mu_mimo_mpdu_underrun_usr_%u = %u\n", 2406 user_index, 2407 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr)); 2408 len += scnprintf(buf + len, buf_len - len, 2409 "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n\n", 2410 user_index, 2411 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr)); 2412 } 2413 } 2414 2415 if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_OFDMA_AX) { 2416 if (!user_index) 2417 len += scnprintf(buf + len, buf_len - len, 2418 "HTT_TX_PDEV_AX_MU_OFDMA_MPDU_STATS:\n"); 2419 2420 if (user_index < ATH12K_HTT_TX_NUM_OFDMA_USER_STATS) { 2421 len += scnprintf(buf + len, buf_len - len, 2422 "ax_mu_ofdma_mpdus_queued_usr_%u = %u\n", 2423 user_index, 2424 le32_to_cpu(htt_stats_buf->mpdus_queued_usr)); 2425 len += scnprintf(buf + len, buf_len - len, 2426 "ax_mu_ofdma_mpdus_tried_usr_%u = %u\n", 2427 user_index, 2428 le32_to_cpu(htt_stats_buf->mpdus_tried_usr)); 2429 len += scnprintf(buf + len, buf_len - len, 2430 "ax_mu_ofdma_mpdus_failed_usr_%u = %u\n", 2431 user_index, 2432 le32_to_cpu(htt_stats_buf->mpdus_failed_usr)); 2433 len += scnprintf(buf + len, buf_len - len, 2434 "ax_mu_ofdma_mpdus_requeued_usr_%u = %u\n", 2435 user_index, 2436 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr)); 2437 len += scnprintf(buf + len, buf_len - len, 2438 "ax_mu_ofdma_err_no_ba_usr_%u = %u\n", 2439 user_index, 2440 le32_to_cpu(htt_stats_buf->err_no_ba_usr)); 2441 len += scnprintf(buf + len, buf_len - len, 2442 "ax_mu_ofdma_mpdu_underrun_usr_%u = %u\n", 2443 user_index, 2444 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr)); 2445 len += scnprintf(buf + len, buf_len - len, 2446 "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n\n", 2447 user_index, 2448 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr)); 2449 } 2450 } 2451 2452 stats_req->buf_len = len; 2453 } 2454 2455 static void 2456 ath12k_htt_print_pdev_cca_stats_hist_tlv(const void *tag_buf, u16 tag_len, 2457 struct debug_htt_stats_req *stats_req) 2458 { 2459 const struct ath12k_htt_pdev_cca_stats_hist_v1_tlv *htt_stats_buf = tag_buf; 2460 u8 *buf = stats_req->buf; 2461 u32 len = stats_req->buf_len; 2462 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2463 2464 if (tag_len < sizeof(*htt_stats_buf)) 2465 return; 2466 2467 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_CCA_STATS_HIST_TLV :\n"); 2468 len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n", 2469 le32_to_cpu(htt_stats_buf->chan_num)); 2470 len += scnprintf(buf + len, buf_len - len, "num_records = %u\n", 2471 le32_to_cpu(htt_stats_buf->num_records)); 2472 len += scnprintf(buf + len, buf_len - len, "valid_cca_counters_bitmap = 0x%x\n", 2473 le32_to_cpu(htt_stats_buf->valid_cca_counters_bitmap)); 2474 len += scnprintf(buf + len, buf_len - len, "collection_interval = %u\n\n", 2475 le32_to_cpu(htt_stats_buf->collection_interval)); 2476 2477 stats_req->buf_len = len; 2478 } 2479 2480 static void 2481 ath12k_htt_print_pdev_stats_cca_counters_tlv(const void *tag_buf, u16 tag_len, 2482 struct debug_htt_stats_req *stats_req) 2483 { 2484 const struct ath12k_htt_pdev_stats_cca_counters_tlv *htt_stats_buf = tag_buf; 2485 u8 *buf = stats_req->buf; 2486 u32 len = stats_req->buf_len; 2487 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2488 2489 if (tag_len < sizeof(*htt_stats_buf)) 2490 return; 2491 2492 len += scnprintf(buf + len, buf_len - len, 2493 "HTT_PDEV_STATS_CCA_COUNTERS_TLV:(in usec)\n"); 2494 len += scnprintf(buf + len, buf_len - len, "tx_frame_usec = %u\n", 2495 le32_to_cpu(htt_stats_buf->tx_frame_usec)); 2496 len += scnprintf(buf + len, buf_len - len, "rx_frame_usec = %u\n", 2497 le32_to_cpu(htt_stats_buf->rx_frame_usec)); 2498 len += scnprintf(buf + len, buf_len - len, "rx_clear_usec = %u\n", 2499 le32_to_cpu(htt_stats_buf->rx_clear_usec)); 2500 len += scnprintf(buf + len, buf_len - len, "my_rx_frame_usec = %u\n", 2501 le32_to_cpu(htt_stats_buf->my_rx_frame_usec)); 2502 len += scnprintf(buf + len, buf_len - len, "usec_cnt = %u\n", 2503 le32_to_cpu(htt_stats_buf->usec_cnt)); 2504 len += scnprintf(buf + len, buf_len - len, "med_rx_idle_usec = %u\n", 2505 le32_to_cpu(htt_stats_buf->med_rx_idle_usec)); 2506 len += scnprintf(buf + len, buf_len - len, "med_tx_idle_global_usec = %u\n", 2507 le32_to_cpu(htt_stats_buf->med_tx_idle_global_usec)); 2508 len += scnprintf(buf + len, buf_len - len, "cca_obss_usec = %u\n\n", 2509 le32_to_cpu(htt_stats_buf->cca_obss_usec)); 2510 2511 stats_req->buf_len = len; 2512 } 2513 2514 static void 2515 ath12k_htt_print_pdev_obss_pd_stats_tlv(const void *tag_buf, u16 tag_len, 2516 struct debug_htt_stats_req *stats_req) 2517 { 2518 const struct ath12k_htt_pdev_obss_pd_stats_tlv *htt_stats_buf = tag_buf; 2519 u8 *buf = stats_req->buf; 2520 u32 len = stats_req->buf_len; 2521 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2522 u8 i; 2523 static const char *access_cat_names[ATH12K_HTT_NUM_AC_WMM] = {"best effort", 2524 "background", 2525 "video", "voice"}; 2526 2527 if (tag_len < sizeof(*htt_stats_buf)) 2528 return; 2529 2530 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_STATS_TLV:\n"); 2531 len += scnprintf(buf + len, buf_len - len, "num_spatial_reuse_tx = %u\n", 2532 le32_to_cpu(htt_stats_buf->num_sr_tx_transmissions)); 2533 len += scnprintf(buf + len, buf_len - len, 2534 "num_spatial_reuse_opportunities = %u\n", 2535 le32_to_cpu(htt_stats_buf->num_spatial_reuse_opportunities)); 2536 len += scnprintf(buf + len, buf_len - len, "num_non_srg_opportunities = %u\n", 2537 le32_to_cpu(htt_stats_buf->num_non_srg_opportunities)); 2538 len += scnprintf(buf + len, buf_len - len, "num_non_srg_ppdu_tried = %u\n", 2539 le32_to_cpu(htt_stats_buf->num_non_srg_ppdu_tried)); 2540 len += scnprintf(buf + len, buf_len - len, "num_non_srg_ppdu_success = %u\n", 2541 le32_to_cpu(htt_stats_buf->num_non_srg_ppdu_success)); 2542 len += scnprintf(buf + len, buf_len - len, "num_srg_opportunities = %u\n", 2543 le32_to_cpu(htt_stats_buf->num_srg_opportunities)); 2544 len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_tried = %u\n", 2545 le32_to_cpu(htt_stats_buf->num_srg_ppdu_tried)); 2546 len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_success = %u\n", 2547 le32_to_cpu(htt_stats_buf->num_srg_ppdu_success)); 2548 len += scnprintf(buf + len, buf_len - len, "num_psr_opportunities = %u\n", 2549 le32_to_cpu(htt_stats_buf->num_psr_opportunities)); 2550 len += scnprintf(buf + len, buf_len - len, "num_psr_ppdu_tried = %u\n", 2551 le32_to_cpu(htt_stats_buf->num_psr_ppdu_tried)); 2552 len += scnprintf(buf + len, buf_len - len, "num_psr_ppdu_success = %u\n", 2553 le32_to_cpu(htt_stats_buf->num_psr_ppdu_success)); 2554 len += scnprintf(buf + len, buf_len - len, "min_duration_check_flush_cnt = %u\n", 2555 le32_to_cpu(htt_stats_buf->num_obss_min_dur_check_flush_cnt)); 2556 len += scnprintf(buf + len, buf_len - len, "sr_ppdu_abort_flush_cnt = %u\n\n", 2557 le32_to_cpu(htt_stats_buf->num_sr_ppdu_abort_flush_cnt)); 2558 2559 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_PER_AC_STATS:\n"); 2560 for (i = 0; i < ATH12K_HTT_NUM_AC_WMM; i++) { 2561 len += scnprintf(buf + len, buf_len - len, "Access Category %u (%s)\n", 2562 i, access_cat_names[i]); 2563 len += scnprintf(buf + len, buf_len - len, 2564 "num_non_srg_ppdu_tried = %u\n", 2565 le32_to_cpu(htt_stats_buf->num_non_srg_tried_per_ac[i])); 2566 len += scnprintf(buf + len, buf_len - len, 2567 "num_non_srg_ppdu_success = %u\n", 2568 le32_to_cpu(htt_stats_buf->num_non_srg_success_ac[i])); 2569 len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_tried = %u\n", 2570 le32_to_cpu(htt_stats_buf->num_srg_tried_per_ac[i])); 2571 len += scnprintf(buf + len, buf_len - len, 2572 "num_srg_ppdu_success = %u\n\n", 2573 le32_to_cpu(htt_stats_buf->num_srg_success_per_ac[i])); 2574 } 2575 2576 stats_req->buf_len = len; 2577 } 2578 2579 static void ath12k_htt_print_dlpager_entry(const struct ath12k_htt_pgs_info *pg_info, 2580 int idx, char *str_buf) 2581 { 2582 u64 page_timestamp; 2583 u16 index = 0; 2584 2585 page_timestamp = ath12k_le32hilo_to_u64(pg_info->ts_msb, pg_info->ts_lsb); 2586 2587 index += snprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index, 2588 "Index - %u ; Page Number - %u ; ", 2589 idx, le32_to_cpu(pg_info->page_num)); 2590 index += snprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index, 2591 "Num of pages - %u ; Timestamp - %lluus\n", 2592 le32_to_cpu(pg_info->num_pgs), page_timestamp); 2593 } 2594 2595 static void 2596 ath12k_htt_print_dlpager_stats_tlv(const void *tag_buf, u16 tag_len, 2597 struct debug_htt_stats_req *stats_req) 2598 { 2599 const struct ath12k_htt_dl_pager_stats_tlv *stat_buf = tag_buf; 2600 u32 len = stats_req->buf_len; 2601 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2602 u32 dword_lock, dword_unlock; 2603 int i; 2604 u8 *buf = stats_req->buf; 2605 u8 pg_locked; 2606 u8 pg_unlock; 2607 char str_buf[ATH12K_HTT_MAX_STRING_LEN] = {0}; 2608 2609 if (tag_len < sizeof(*stat_buf)) 2610 return; 2611 2612 dword_lock = le32_get_bits(stat_buf->info2, 2613 ATH12K_HTT_DLPAGER_TOTAL_LOCK_PAGES_INFO2); 2614 dword_unlock = le32_get_bits(stat_buf->info2, 2615 ATH12K_HTT_DLPAGER_TOTAL_FREE_PAGES_INFO2); 2616 2617 pg_locked = ATH12K_HTT_STATS_PAGE_LOCKED; 2618 pg_unlock = ATH12K_HTT_STATS_PAGE_UNLOCKED; 2619 2620 len += scnprintf(buf + len, buf_len - len, "HTT_DLPAGER_STATS_TLV:\n"); 2621 len += scnprintf(buf + len, buf_len - len, "ASYNC locked pages = %u\n", 2622 le32_get_bits(stat_buf->info0, 2623 ATH12K_HTT_DLPAGER_ASYNC_LOCK_PG_CNT_INFO0)); 2624 len += scnprintf(buf + len, buf_len - len, "SYNC locked pages = %u\n", 2625 le32_get_bits(stat_buf->info0, 2626 ATH12K_HTT_DLPAGER_SYNC_LOCK_PG_CNT_INFO0)); 2627 len += scnprintf(buf + len, buf_len - len, "Total locked pages = %u\n", 2628 le32_get_bits(stat_buf->info1, 2629 ATH12K_HTT_DLPAGER_TOTAL_LOCK_PAGES_INFO1)); 2630 len += scnprintf(buf + len, buf_len - len, "Total free pages = %u\n", 2631 le32_get_bits(stat_buf->info1, 2632 ATH12K_HTT_DLPAGER_TOTAL_FREE_PAGES_INFO1)); 2633 2634 len += scnprintf(buf + len, buf_len - len, "\nLOCKED PAGES HISTORY\n"); 2635 len += scnprintf(buf + len, buf_len - len, "last_locked_page_idx = %u\n", 2636 dword_lock ? dword_lock - 1 : (ATH12K_PAGER_MAX - 1)); 2637 2638 for (i = 0; i < ATH12K_PAGER_MAX; i++) { 2639 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 2640 ath12k_htt_print_dlpager_entry(&stat_buf->pgs_info[pg_locked][i], 2641 i, str_buf); 2642 len += scnprintf(buf + len, buf_len - len, "%s", str_buf); 2643 } 2644 2645 len += scnprintf(buf + len, buf_len - len, "\nUNLOCKED PAGES HISTORY\n"); 2646 len += scnprintf(buf + len, buf_len - len, "last_unlocked_page_idx = %u\n", 2647 dword_unlock ? dword_unlock - 1 : ATH12K_PAGER_MAX - 1); 2648 2649 for (i = 0; i < ATH12K_PAGER_MAX; i++) { 2650 memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN); 2651 ath12k_htt_print_dlpager_entry(&stat_buf->pgs_info[pg_unlock][i], 2652 i, str_buf); 2653 len += scnprintf(buf + len, buf_len - len, "%s", str_buf); 2654 } 2655 2656 len += scnprintf(buf + len, buf_len - len, "\n"); 2657 2658 stats_req->buf_len = len; 2659 } 2660 2661 static void 2662 ath12k_htt_print_phy_stats_tlv(const void *tag_buf, u16 tag_len, 2663 struct debug_htt_stats_req *stats_req) 2664 { 2665 const struct ath12k_htt_phy_stats_tlv *htt_stats_buf = tag_buf; 2666 u32 len = stats_req->buf_len; 2667 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2668 u8 *buf = stats_req->buf, i; 2669 2670 if (tag_len < sizeof(*htt_stats_buf)) 2671 return; 2672 2673 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_STATS_TLV:\n"); 2674 for (i = 0; i < ATH12K_HTT_STATS_MAX_CHAINS; i++) 2675 len += scnprintf(buf + len, buf_len - len, "bdf_nf_chain[%d] = %d\n", 2676 i, a_sle32_to_cpu(htt_stats_buf->nf_chain[i])); 2677 for (i = 0; i < ATH12K_HTT_STATS_MAX_CHAINS; i++) 2678 len += scnprintf(buf + len, buf_len - len, "runtime_nf_chain[%d] = %d\n", 2679 i, a_sle32_to_cpu(htt_stats_buf->runtime_nf_chain[i])); 2680 len += scnprintf(buf + len, buf_len - len, "false_radar_cnt = %u / %u (mins)\n", 2681 le32_to_cpu(htt_stats_buf->false_radar_cnt), 2682 le32_to_cpu(htt_stats_buf->fw_run_time)); 2683 len += scnprintf(buf + len, buf_len - len, "radar_cs_cnt = %u\n", 2684 le32_to_cpu(htt_stats_buf->radar_cs_cnt)); 2685 len += scnprintf(buf + len, buf_len - len, "ani_level = %d\n\n", 2686 a_sle32_to_cpu(htt_stats_buf->ani_level)); 2687 2688 stats_req->buf_len = len; 2689 } 2690 2691 static void 2692 ath12k_htt_print_phy_counters_tlv(const void *tag_buf, u16 tag_len, 2693 struct debug_htt_stats_req *stats_req) 2694 { 2695 const struct ath12k_htt_phy_counters_tlv *htt_stats_buf = tag_buf; 2696 u32 len = stats_req->buf_len; 2697 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2698 u8 *buf = stats_req->buf; 2699 2700 if (tag_len < sizeof(*htt_stats_buf)) 2701 return; 2702 2703 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_COUNTERS_TLV:\n"); 2704 len += scnprintf(buf + len, buf_len - len, "rx_ofdma_timing_err_cnt = %u\n", 2705 le32_to_cpu(htt_stats_buf->rx_ofdma_timing_err_cnt)); 2706 len += scnprintf(buf + len, buf_len - len, "rx_cck_fail_cnt = %u\n", 2707 le32_to_cpu(htt_stats_buf->rx_cck_fail_cnt)); 2708 len += scnprintf(buf + len, buf_len - len, "mactx_abort_cnt = %u\n", 2709 le32_to_cpu(htt_stats_buf->mactx_abort_cnt)); 2710 len += scnprintf(buf + len, buf_len - len, "macrx_abort_cnt = %u\n", 2711 le32_to_cpu(htt_stats_buf->macrx_abort_cnt)); 2712 len += scnprintf(buf + len, buf_len - len, "phytx_abort_cnt = %u\n", 2713 le32_to_cpu(htt_stats_buf->phytx_abort_cnt)); 2714 len += scnprintf(buf + len, buf_len - len, "phyrx_abort_cnt = %u\n", 2715 le32_to_cpu(htt_stats_buf->phyrx_abort_cnt)); 2716 len += scnprintf(buf + len, buf_len - len, "phyrx_defer_abort_cnt = %u\n", 2717 le32_to_cpu(htt_stats_buf->phyrx_defer_abort_cnt)); 2718 len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_lstf_event_cnt = %u\n", 2719 le32_to_cpu(htt_stats_buf->rx_gain_adj_lstf_event_cnt)); 2720 len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_non_legacy_cnt = %u\n", 2721 le32_to_cpu(htt_stats_buf->rx_gain_adj_non_legacy_cnt)); 2722 len += print_array_to_buf(buf, len, "rx_pkt_cnt", htt_stats_buf->rx_pkt_cnt, 2723 ATH12K_HTT_MAX_RX_PKT_CNT, "\n"); 2724 len += print_array_to_buf(buf, len, "rx_pkt_crc_pass_cnt", 2725 htt_stats_buf->rx_pkt_crc_pass_cnt, 2726 ATH12K_HTT_MAX_RX_PKT_CRC_PASS_CNT, "\n"); 2727 len += print_array_to_buf(buf, len, "per_blk_err_cnt", 2728 htt_stats_buf->per_blk_err_cnt, 2729 ATH12K_HTT_MAX_PER_BLK_ERR_CNT, "\n"); 2730 len += print_array_to_buf(buf, len, "rx_ota_err_cnt", 2731 htt_stats_buf->rx_ota_err_cnt, 2732 ATH12K_HTT_MAX_RX_OTA_ERR_CNT, "\n\n"); 2733 2734 stats_req->buf_len = len; 2735 } 2736 2737 static void 2738 ath12k_htt_print_phy_reset_stats_tlv(const void *tag_buf, u16 tag_len, 2739 struct debug_htt_stats_req *stats_req) 2740 { 2741 const struct ath12k_htt_phy_reset_stats_tlv *htt_stats_buf = tag_buf; 2742 u32 len = stats_req->buf_len; 2743 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2744 u8 *buf = stats_req->buf; 2745 2746 if (tag_len < sizeof(*htt_stats_buf)) 2747 return; 2748 2749 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_STATS_TLV:\n"); 2750 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 2751 le32_to_cpu(htt_stats_buf->pdev_id)); 2752 len += scnprintf(buf + len, buf_len - len, "chan_mhz = %u\n", 2753 le32_to_cpu(htt_stats_buf->chan_mhz)); 2754 len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq1 = %u\n", 2755 le32_to_cpu(htt_stats_buf->chan_band_center_freq1)); 2756 len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq2 = %u\n", 2757 le32_to_cpu(htt_stats_buf->chan_band_center_freq2)); 2758 len += scnprintf(buf + len, buf_len - len, "chan_phy_mode = %u\n", 2759 le32_to_cpu(htt_stats_buf->chan_phy_mode)); 2760 len += scnprintf(buf + len, buf_len - len, "chan_flags = 0x%0x\n", 2761 le32_to_cpu(htt_stats_buf->chan_flags)); 2762 len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n", 2763 le32_to_cpu(htt_stats_buf->chan_num)); 2764 len += scnprintf(buf + len, buf_len - len, "reset_cause = 0x%0x\n", 2765 le32_to_cpu(htt_stats_buf->reset_cause)); 2766 len += scnprintf(buf + len, buf_len - len, "prev_reset_cause = 0x%0x\n", 2767 le32_to_cpu(htt_stats_buf->prev_reset_cause)); 2768 len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_src = 0x%0x\n", 2769 le32_to_cpu(htt_stats_buf->phy_warm_reset_src)); 2770 len += scnprintf(buf + len, buf_len - len, "rx_gain_tbl_mode = %d\n", 2771 le32_to_cpu(htt_stats_buf->rx_gain_tbl_mode)); 2772 len += scnprintf(buf + len, buf_len - len, "xbar_val = 0x%0x\n", 2773 le32_to_cpu(htt_stats_buf->xbar_val)); 2774 len += scnprintf(buf + len, buf_len - len, "force_calibration = %u\n", 2775 le32_to_cpu(htt_stats_buf->force_calibration)); 2776 len += scnprintf(buf + len, buf_len - len, "phyrf_mode = %u\n", 2777 le32_to_cpu(htt_stats_buf->phyrf_mode)); 2778 len += scnprintf(buf + len, buf_len - len, "phy_homechan = %u\n", 2779 le32_to_cpu(htt_stats_buf->phy_homechan)); 2780 len += scnprintf(buf + len, buf_len - len, "phy_tx_ch_mask = 0x%0x\n", 2781 le32_to_cpu(htt_stats_buf->phy_tx_ch_mask)); 2782 len += scnprintf(buf + len, buf_len - len, "phy_rx_ch_mask = 0x%0x\n", 2783 le32_to_cpu(htt_stats_buf->phy_rx_ch_mask)); 2784 len += scnprintf(buf + len, buf_len - len, "phybb_ini_mask = 0x%0x\n", 2785 le32_to_cpu(htt_stats_buf->phybb_ini_mask)); 2786 len += scnprintf(buf + len, buf_len - len, "phyrf_ini_mask = 0x%0x\n", 2787 le32_to_cpu(htt_stats_buf->phyrf_ini_mask)); 2788 len += scnprintf(buf + len, buf_len - len, "phy_dfs_en_mask = 0x%0x\n", 2789 le32_to_cpu(htt_stats_buf->phy_dfs_en_mask)); 2790 len += scnprintf(buf + len, buf_len - len, "phy_sscan_en_mask = 0x%0x\n", 2791 le32_to_cpu(htt_stats_buf->phy_sscan_en_mask)); 2792 len += scnprintf(buf + len, buf_len - len, "phy_synth_sel_mask = 0x%0x\n", 2793 le32_to_cpu(htt_stats_buf->phy_synth_sel_mask)); 2794 len += scnprintf(buf + len, buf_len - len, "phy_adfs_freq = %u\n", 2795 le32_to_cpu(htt_stats_buf->phy_adfs_freq)); 2796 len += scnprintf(buf + len, buf_len - len, "cck_fir_settings = 0x%0x\n", 2797 le32_to_cpu(htt_stats_buf->cck_fir_settings)); 2798 len += scnprintf(buf + len, buf_len - len, "phy_dyn_pri_chan = %u\n", 2799 le32_to_cpu(htt_stats_buf->phy_dyn_pri_chan)); 2800 len += scnprintf(buf + len, buf_len - len, "cca_thresh = 0x%0x\n", 2801 le32_to_cpu(htt_stats_buf->cca_thresh)); 2802 len += scnprintf(buf + len, buf_len - len, "dyn_cca_status = %u\n", 2803 le32_to_cpu(htt_stats_buf->dyn_cca_status)); 2804 len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_hw = 0x%x\n", 2805 le32_to_cpu(htt_stats_buf->rxdesense_thresh_hw)); 2806 len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_sw = 0x%x\n\n", 2807 le32_to_cpu(htt_stats_buf->rxdesense_thresh_sw)); 2808 2809 stats_req->buf_len = len; 2810 } 2811 2812 static void 2813 ath12k_htt_print_phy_reset_counters_tlv(const void *tag_buf, u16 tag_len, 2814 struct debug_htt_stats_req *stats_req) 2815 { 2816 const struct ath12k_htt_phy_reset_counters_tlv *htt_stats_buf = tag_buf; 2817 u32 len = stats_req->buf_len; 2818 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2819 u8 *buf = stats_req->buf; 2820 2821 if (tag_len < sizeof(*htt_stats_buf)) 2822 return; 2823 2824 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_COUNTERS_TLV:\n"); 2825 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 2826 le32_to_cpu(htt_stats_buf->pdev_id)); 2827 len += scnprintf(buf + len, buf_len - len, "cf_active_low_fail_cnt = %u\n", 2828 le32_to_cpu(htt_stats_buf->cf_active_low_fail_cnt)); 2829 len += scnprintf(buf + len, buf_len - len, "cf_active_low_pass_cnt = %u\n", 2830 le32_to_cpu(htt_stats_buf->cf_active_low_pass_cnt)); 2831 len += scnprintf(buf + len, buf_len - len, "phy_off_through_vreg_cnt = %u\n", 2832 le32_to_cpu(htt_stats_buf->phy_off_through_vreg_cnt)); 2833 len += scnprintf(buf + len, buf_len - len, "force_calibration_cnt = %u\n", 2834 le32_to_cpu(htt_stats_buf->force_calibration_cnt)); 2835 len += scnprintf(buf + len, buf_len - len, "rf_mode_switch_phy_off_cnt = %u\n", 2836 le32_to_cpu(htt_stats_buf->rf_mode_switch_phy_off_cnt)); 2837 len += scnprintf(buf + len, buf_len - len, "temperature_recal_cnt = %u\n\n", 2838 le32_to_cpu(htt_stats_buf->temperature_recal_cnt)); 2839 2840 stats_req->buf_len = len; 2841 } 2842 2843 static void 2844 ath12k_htt_print_phy_tpc_stats_tlv(const void *tag_buf, u16 tag_len, 2845 struct debug_htt_stats_req *stats_req) 2846 { 2847 const struct ath12k_htt_phy_tpc_stats_tlv *htt_stats_buf = tag_buf; 2848 u32 len = stats_req->buf_len; 2849 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2850 u8 *buf = stats_req->buf; 2851 2852 if (tag_len < sizeof(*htt_stats_buf)) 2853 return; 2854 2855 len += scnprintf(buf + len, buf_len - len, "HTT_PHY_TPC_STATS_TLV:\n"); 2856 len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n", 2857 le32_to_cpu(htt_stats_buf->pdev_id)); 2858 len += scnprintf(buf + len, buf_len - len, "tx_power_scale = %u\n", 2859 le32_to_cpu(htt_stats_buf->tx_power_scale)); 2860 len += scnprintf(buf + len, buf_len - len, "tx_power_scale_db = %u\n", 2861 le32_to_cpu(htt_stats_buf->tx_power_scale_db)); 2862 len += scnprintf(buf + len, buf_len - len, "min_negative_tx_power = %d\n", 2863 le32_to_cpu(htt_stats_buf->min_negative_tx_power)); 2864 len += scnprintf(buf + len, buf_len - len, "reg_ctl_domain = %u\n", 2865 le32_to_cpu(htt_stats_buf->reg_ctl_domain)); 2866 len += scnprintf(buf + len, buf_len - len, "twice_max_rd_power = %u\n", 2867 le32_to_cpu(htt_stats_buf->twice_max_rd_power)); 2868 len += scnprintf(buf + len, buf_len - len, "max_tx_power = %u\n", 2869 le32_to_cpu(htt_stats_buf->max_tx_power)); 2870 len += scnprintf(buf + len, buf_len - len, "home_max_tx_power = %u\n", 2871 le32_to_cpu(htt_stats_buf->home_max_tx_power)); 2872 len += scnprintf(buf + len, buf_len - len, "psd_power = %d\n", 2873 le32_to_cpu(htt_stats_buf->psd_power)); 2874 len += scnprintf(buf + len, buf_len - len, "eirp_power = %u\n", 2875 le32_to_cpu(htt_stats_buf->eirp_power)); 2876 len += scnprintf(buf + len, buf_len - len, "power_type_6ghz = %u\n", 2877 le32_to_cpu(htt_stats_buf->power_type_6ghz)); 2878 len += print_array_to_buf(buf, len, "max_reg_allowed_power", 2879 htt_stats_buf->max_reg_allowed_power, 2880 ATH12K_HTT_STATS_MAX_CHAINS, "\n"); 2881 len += print_array_to_buf(buf, len, "max_reg_allowed_power_6ghz", 2882 htt_stats_buf->max_reg_allowed_power_6ghz, 2883 ATH12K_HTT_STATS_MAX_CHAINS, "\n"); 2884 len += print_array_to_buf(buf, len, "sub_band_cfreq", 2885 htt_stats_buf->sub_band_cfreq, 2886 ATH12K_HTT_MAX_CH_PWR_INFO_SIZE, "\n"); 2887 len += print_array_to_buf(buf, len, "sub_band_txpower", 2888 htt_stats_buf->sub_band_txpower, 2889 ATH12K_HTT_MAX_CH_PWR_INFO_SIZE, "\n\n"); 2890 2891 stats_req->buf_len = len; 2892 } 2893 2894 static void 2895 ath12k_htt_print_soc_txrx_stats_common_tlv(const void *tag_buf, u16 tag_len, 2896 struct debug_htt_stats_req *stats_req) 2897 { 2898 const struct ath12k_htt_t2h_soc_txrx_stats_common_tlv *htt_stats_buf = tag_buf; 2899 u64 drop_count; 2900 u32 len = stats_req->buf_len; 2901 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2902 u8 *buf = stats_req->buf; 2903 2904 if (tag_len < sizeof(*htt_stats_buf)) 2905 return; 2906 2907 drop_count = ath12k_le32hilo_to_u64(htt_stats_buf->inv_peers_msdu_drop_count_hi, 2908 htt_stats_buf->inv_peers_msdu_drop_count_lo); 2909 2910 len += scnprintf(buf + len, buf_len - len, "HTT_SOC_COMMON_STATS_TLV:\n"); 2911 len += scnprintf(buf + len, buf_len - len, "soc_drop_count = %llu\n\n", 2912 drop_count); 2913 2914 stats_req->buf_len = len; 2915 } 2916 2917 static void 2918 ath12k_htt_print_tx_per_rate_stats_tlv(const void *tag_buf, u16 tag_len, 2919 struct debug_htt_stats_req *stats_req) 2920 { 2921 const struct ath12k_htt_tx_per_rate_stats_tlv *stats_buf = tag_buf; 2922 u32 len = stats_req->buf_len; 2923 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 2924 u32 ru_size_cnt = 0; 2925 u32 rc_mode, ru_type; 2926 u8 *buf = stats_req->buf, i; 2927 const char *mode_prefix; 2928 2929 if (tag_len < sizeof(*stats_buf)) 2930 return; 2931 2932 rc_mode = le32_to_cpu(stats_buf->rc_mode); 2933 ru_type = le32_to_cpu(stats_buf->ru_type); 2934 2935 switch (rc_mode) { 2936 case ATH12K_HTT_STATS_RC_MODE_DLSU: 2937 len += scnprintf(buf + len, buf_len - len, "HTT_TX_PER_STATS:\n"); 2938 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_SU:\n"); 2939 mode_prefix = "su"; 2940 break; 2941 case ATH12K_HTT_STATS_RC_MODE_DLMUMIMO: 2942 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_DL_MUMIMO:\n"); 2943 mode_prefix = "mu"; 2944 break; 2945 case ATH12K_HTT_STATS_RC_MODE_DLOFDMA: 2946 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_DL_OFDMA:\n"); 2947 mode_prefix = "ofdma"; 2948 if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY) 2949 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_STATS_NUM_AX_RU_SIZE_CNTRS; 2950 else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU) 2951 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; 2952 break; 2953 case ATH12K_HTT_STATS_RC_MODE_ULMUMIMO: 2954 len += scnprintf(buf + len, buf_len - len, "HTT_RX_PER_STATS:\n"); 2955 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_UL_MUMIMO:\n"); 2956 mode_prefix = "ulmu"; 2957 break; 2958 case ATH12K_HTT_STATS_RC_MODE_ULOFDMA: 2959 len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_UL_OFDMA:\n"); 2960 mode_prefix = "ulofdma"; 2961 if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY) 2962 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_STATS_NUM_AX_RU_SIZE_CNTRS; 2963 else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU) 2964 ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; 2965 break; 2966 default: 2967 return; 2968 } 2969 2970 len += scnprintf(buf + len, buf_len - len, "\nPER per BW:\n"); 2971 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 2972 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 2973 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 2974 mode_prefix); 2975 else 2976 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 2977 mode_prefix); 2978 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 2979 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 2980 le32_to_cpu(stats_buf->per_bw[i].ppdus_tried)); 2981 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 2982 le32_to_cpu(stats_buf->per_bw320.ppdus_tried)); 2983 2984 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 2985 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 2986 len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ", 2987 mode_prefix); 2988 else 2989 len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ", 2990 mode_prefix); 2991 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 2992 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 2993 le32_to_cpu(stats_buf->per_bw[i].ppdus_ack_failed)); 2994 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 2995 le32_to_cpu(stats_buf->per_bw320.ppdus_ack_failed)); 2996 2997 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix); 2998 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 2999 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 3000 le32_to_cpu(stats_buf->per_bw[i].mpdus_tried)); 3001 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 3002 le32_to_cpu(stats_buf->per_bw320.mpdus_tried)); 3003 3004 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix); 3005 for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++) 3006 len += scnprintf(buf + len, buf_len - len, " %u:%u", i, 3007 le32_to_cpu(stats_buf->per_bw[i].mpdus_failed)); 3008 len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i, 3009 le32_to_cpu(stats_buf->per_bw320.mpdus_failed)); 3010 3011 len += scnprintf(buf + len, buf_len - len, "\nPER per NSS:\n"); 3012 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 3013 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 3014 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 3015 mode_prefix); 3016 else 3017 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 3018 mode_prefix); 3019 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 3020 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 3021 le32_to_cpu(stats_buf->per_nss[i].ppdus_tried)); 3022 len += scnprintf(buf + len, buf_len - len, "\n"); 3023 3024 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 3025 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 3026 len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ", 3027 mode_prefix); 3028 else 3029 len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ", 3030 mode_prefix); 3031 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 3032 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 3033 le32_to_cpu(stats_buf->per_nss[i].ppdus_ack_failed)); 3034 len += scnprintf(buf + len, buf_len - len, "\n"); 3035 3036 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix); 3037 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 3038 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 3039 le32_to_cpu(stats_buf->per_nss[i].mpdus_tried)); 3040 len += scnprintf(buf + len, buf_len - len, "\n"); 3041 3042 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix); 3043 for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++) 3044 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1, 3045 le32_to_cpu(stats_buf->per_nss[i].mpdus_failed)); 3046 len += scnprintf(buf + len, buf_len - len, "\n"); 3047 3048 len += scnprintf(buf + len, buf_len - len, "\nPER per MCS:\n"); 3049 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 3050 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 3051 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 3052 mode_prefix); 3053 else 3054 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 3055 mode_prefix); 3056 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 3057 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 3058 le32_to_cpu(stats_buf->per_mcs[i].ppdus_tried)); 3059 len += scnprintf(buf + len, buf_len - len, "\n"); 3060 3061 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA || 3062 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO) 3063 len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ", 3064 mode_prefix); 3065 else 3066 len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ", 3067 mode_prefix); 3068 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 3069 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 3070 le32_to_cpu(stats_buf->per_mcs[i].ppdus_ack_failed)); 3071 len += scnprintf(buf + len, buf_len - len, "\n"); 3072 3073 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix); 3074 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 3075 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 3076 le32_to_cpu(stats_buf->per_mcs[i].mpdus_tried)); 3077 len += scnprintf(buf + len, buf_len - len, "\n"); 3078 3079 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix); 3080 for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++) 3081 len += scnprintf(buf + len, buf_len - len, " %u:%u ", i, 3082 le32_to_cpu(stats_buf->per_mcs[i].mpdus_failed)); 3083 len += scnprintf(buf + len, buf_len - len, "\n"); 3084 3085 if ((rc_mode == ATH12K_HTT_STATS_RC_MODE_DLOFDMA || 3086 rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) && 3087 ru_type != ATH12K_HTT_STATS_RU_TYPE_INVALID) { 3088 len += scnprintf(buf + len, buf_len - len, "\nPER per RU:\n"); 3089 3090 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) 3091 len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ", 3092 mode_prefix); 3093 else 3094 len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ", 3095 mode_prefix); 3096 for (i = 0; i < ru_size_cnt; i++) 3097 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3098 ath12k_tx_ru_size_to_str(ru_type, i), 3099 le32_to_cpu(stats_buf->ru[i].ppdus_tried)); 3100 len += scnprintf(buf + len, buf_len - len, "\n"); 3101 3102 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) 3103 len += scnprintf(buf + len, buf_len - len, 3104 "non_data_ppdus_%s = ", mode_prefix); 3105 else 3106 len += scnprintf(buf + len, buf_len - len, 3107 "ppdus_ack_failed_%s = ", mode_prefix); 3108 for (i = 0; i < ru_size_cnt; i++) 3109 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3110 ath12k_tx_ru_size_to_str(ru_type, i), 3111 le32_to_cpu(stats_buf->ru[i].ppdus_ack_failed)); 3112 len += scnprintf(buf + len, buf_len - len, "\n"); 3113 3114 len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", 3115 mode_prefix); 3116 for (i = 0; i < ru_size_cnt; i++) 3117 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3118 ath12k_tx_ru_size_to_str(ru_type, i), 3119 le32_to_cpu(stats_buf->ru[i].mpdus_tried)); 3120 len += scnprintf(buf + len, buf_len - len, "\n"); 3121 3122 len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", 3123 mode_prefix); 3124 for (i = 0; i < ru_size_cnt; i++) 3125 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3126 ath12k_tx_ru_size_to_str(ru_type, i), 3127 le32_to_cpu(stats_buf->ru[i].mpdus_failed)); 3128 len += scnprintf(buf + len, buf_len - len, "\n\n"); 3129 } 3130 3131 if (rc_mode == ATH12K_HTT_STATS_RC_MODE_DLMUMIMO) { 3132 len += scnprintf(buf + len, buf_len - len, "\nlast_probed_bw = %u\n", 3133 le32_to_cpu(stats_buf->last_probed_bw)); 3134 len += scnprintf(buf + len, buf_len - len, "last_probed_nss = %u\n", 3135 le32_to_cpu(stats_buf->last_probed_nss)); 3136 len += scnprintf(buf + len, buf_len - len, "last_probed_mcs = %u\n", 3137 le32_to_cpu(stats_buf->last_probed_mcs)); 3138 len += print_array_to_buf(buf, len, "MU Probe count per RC MODE", 3139 stats_buf->probe_cnt, 3140 ATH12K_HTT_RC_MODE_2D_COUNT, "\n\n"); 3141 } 3142 3143 stats_req->buf_len = len; 3144 } 3145 3146 static void 3147 ath12k_htt_print_dmac_reset_stats_tlv(const void *tag_buf, u16 tag_len, 3148 struct debug_htt_stats_req *stats_req) 3149 { 3150 const struct ath12k_htt_dmac_reset_stats_tlv *htt_stats_buf = tag_buf; 3151 u8 *buf = stats_req->buf; 3152 u32 len = stats_req->buf_len; 3153 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3154 u64 time; 3155 3156 if (tag_len < sizeof(*htt_stats_buf)) 3157 return; 3158 3159 len += scnprintf(buf + len, buf_len - len, "HTT_DMAC_RESET_STATS_TLV:\n"); 3160 len += scnprintf(buf + len, buf_len - len, "reset_count = %u\n", 3161 le32_to_cpu(htt_stats_buf->reset_count)); 3162 time = ath12k_le32hilo_to_u64(htt_stats_buf->reset_time_hi_ms, 3163 htt_stats_buf->reset_time_lo_ms); 3164 len += scnprintf(buf + len, buf_len - len, "reset_time_ms = %llu\n", time); 3165 time = ath12k_le32hilo_to_u64(htt_stats_buf->disengage_time_hi_ms, 3166 htt_stats_buf->disengage_time_lo_ms); 3167 len += scnprintf(buf + len, buf_len - len, "disengage_time_ms = %llu\n", time); 3168 3169 time = ath12k_le32hilo_to_u64(htt_stats_buf->engage_time_hi_ms, 3170 htt_stats_buf->engage_time_lo_ms); 3171 len += scnprintf(buf + len, buf_len - len, "engage_time_ms = %llu\n", time); 3172 3173 len += scnprintf(buf + len, buf_len - len, "disengage_count = %u\n", 3174 le32_to_cpu(htt_stats_buf->disengage_count)); 3175 len += scnprintf(buf + len, buf_len - len, "engage_count = %u\n", 3176 le32_to_cpu(htt_stats_buf->engage_count)); 3177 len += scnprintf(buf + len, buf_len - len, "drain_dest_ring_mask = 0x%x\n\n", 3178 le32_to_cpu(htt_stats_buf->drain_dest_ring_mask)); 3179 3180 stats_req->buf_len = len; 3181 } 3182 3183 static void 3184 ath12k_htt_print_pdev_sched_algo_ofdma_stats_tlv(const void *tag_buf, u16 tag_len, 3185 struct debug_htt_stats_req *stats_req) 3186 { 3187 const struct ath12k_htt_pdev_sched_algo_ofdma_stats_tlv *htt_stats_buf = tag_buf; 3188 u8 *buf = stats_req->buf; 3189 u32 len = stats_req->buf_len; 3190 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3191 u32 mac_id_word; 3192 3193 if (tag_len < sizeof(*htt_stats_buf)) 3194 return; 3195 3196 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 3197 3198 len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_SCHED_ALGO_TLV:\n"); 3199 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 3200 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 3201 len += print_array_to_buf(buf, len, "rate_based_dlofdma_enabled_count", 3202 htt_stats_buf->rate_based_dlofdma_enabled_cnt, 3203 ATH12K_HTT_NUM_AC_WMM, "\n"); 3204 len += print_array_to_buf(buf, len, "rate_based_dlofdma_disabled_count", 3205 htt_stats_buf->rate_based_dlofdma_disabled_cnt, 3206 ATH12K_HTT_NUM_AC_WMM, "\n"); 3207 len += print_array_to_buf(buf, len, "rate_based_dlofdma_probing_count", 3208 htt_stats_buf->rate_based_dlofdma_disabled_cnt, 3209 ATH12K_HTT_NUM_AC_WMM, "\n"); 3210 len += print_array_to_buf(buf, len, "rate_based_dlofdma_monitoring_count", 3211 htt_stats_buf->rate_based_dlofdma_monitor_cnt, 3212 ATH12K_HTT_NUM_AC_WMM, "\n"); 3213 len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_enabled_count", 3214 htt_stats_buf->chan_acc_lat_based_dlofdma_enabled_cnt, 3215 ATH12K_HTT_NUM_AC_WMM, "\n"); 3216 len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_disabled_count", 3217 htt_stats_buf->chan_acc_lat_based_dlofdma_disabled_cnt, 3218 ATH12K_HTT_NUM_AC_WMM, "\n"); 3219 len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_monitoring_count", 3220 htt_stats_buf->chan_acc_lat_based_dlofdma_monitor_cnt, 3221 ATH12K_HTT_NUM_AC_WMM, "\n"); 3222 len += print_array_to_buf(buf, len, "downgrade_to_dl_su_ru_alloc_fail", 3223 htt_stats_buf->downgrade_to_dl_su_ru_alloc_fail, 3224 ATH12K_HTT_NUM_AC_WMM, "\n"); 3225 len += print_array_to_buf(buf, len, "candidate_list_single_user_disable_ofdma", 3226 htt_stats_buf->candidate_list_single_user_disable_ofdma, 3227 ATH12K_HTT_NUM_AC_WMM, "\n"); 3228 len += print_array_to_buf(buf, len, "dl_cand_list_dropped_high_ul_qos_weight", 3229 htt_stats_buf->dl_cand_list_dropped_high_ul_qos_weight, 3230 ATH12K_HTT_NUM_AC_WMM, "\n"); 3231 len += print_array_to_buf(buf, len, "ax_dlofdma_disabled_due_to_pipelining", 3232 htt_stats_buf->ax_dlofdma_disabled_due_to_pipelining, 3233 ATH12K_HTT_NUM_AC_WMM, "\n"); 3234 len += print_array_to_buf(buf, len, "dlofdma_disabled_su_only_eligible", 3235 htt_stats_buf->dlofdma_disabled_su_only_eligible, 3236 ATH12K_HTT_NUM_AC_WMM, "\n"); 3237 len += print_array_to_buf(buf, len, "dlofdma_disabled_consec_no_mpdus_tried", 3238 htt_stats_buf->dlofdma_disabled_consec_no_mpdus_tried, 3239 ATH12K_HTT_NUM_AC_WMM, "\n"); 3240 len += print_array_to_buf(buf, len, "dlofdma_disabled_consec_no_mpdus_success", 3241 htt_stats_buf->dlofdma_disabled_consec_no_mpdus_success, 3242 ATH12K_HTT_NUM_AC_WMM, "\n\n"); 3243 3244 stats_req->buf_len = len; 3245 } 3246 3247 static void 3248 ath12k_htt_print_tx_pdev_rate_stats_be_ofdma_tlv(const void *tag_buf, u16 tag_len, 3249 struct debug_htt_stats_req *stats_req) 3250 { 3251 const struct ath12k_htt_tx_pdev_rate_stats_be_ofdma_tlv *htt_stats_buf = tag_buf; 3252 u8 *buf = stats_req->buf; 3253 u32 len = stats_req->buf_len; 3254 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3255 u32 mac_id_word; 3256 u8 i; 3257 3258 if (tag_len < sizeof(*htt_stats_buf)) 3259 return; 3260 3261 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 3262 3263 len += scnprintf(buf + len, buf_len - len, 3264 "HTT_TX_PDEV_RATE_STATS_BE_OFDMA_TLV:\n"); 3265 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 3266 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 3267 len += scnprintf(buf + len, buf_len - len, "be_ofdma_tx_ldpc = %u\n", 3268 le32_to_cpu(htt_stats_buf->be_ofdma_tx_ldpc)); 3269 len += print_array_to_buf(buf, len, "be_ofdma_tx_mcs", 3270 htt_stats_buf->be_ofdma_tx_mcs, 3271 ATH12K_HTT_TX_PDEV_NUM_BE_MCS_CNTRS, "\n"); 3272 len += print_array_to_buf(buf, len, "be_ofdma_eht_sig_mcs", 3273 htt_stats_buf->be_ofdma_eht_sig_mcs, 3274 ATH12K_HTT_TX_PDEV_NUM_EHT_SIG_MCS_CNTRS, "\n"); 3275 len += scnprintf(buf + len, buf_len - len, "be_ofdma_tx_ru_size = "); 3276 for (i = 0; i < ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; i++) 3277 len += scnprintf(buf + len, buf_len - len, " %s:%u ", 3278 ath12k_htt_be_tx_rx_ru_size_to_str(i), 3279 le32_to_cpu(htt_stats_buf->be_ofdma_tx_ru_size[i])); 3280 len += scnprintf(buf + len, buf_len - len, "\n"); 3281 len += print_array_to_buf_index(buf, len, "be_ofdma_tx_nss = ", 1, 3282 htt_stats_buf->be_ofdma_tx_nss, 3283 ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS, 3284 "\n"); 3285 len += print_array_to_buf(buf, len, "be_ofdma_tx_bw", 3286 htt_stats_buf->be_ofdma_tx_bw, 3287 ATH12K_HTT_TX_PDEV_NUM_BE_BW_CNTRS, "\n"); 3288 for (i = 0; i < ATH12K_HTT_TX_PDEV_NUM_GI_CNTRS; i++) { 3289 len += scnprintf(buf + len, buf_len - len, 3290 "be_ofdma_tx_gi[%u]", i); 3291 len += print_array_to_buf(buf, len, "", htt_stats_buf->gi[i], 3292 ATH12K_HTT_TX_PDEV_NUM_BE_MCS_CNTRS, "\n"); 3293 } 3294 len += scnprintf(buf + len, buf_len - len, "\n"); 3295 3296 stats_req->buf_len = len; 3297 } 3298 3299 static void 3300 ath12k_htt_print_pdev_mbssid_ctrl_frame_stats_tlv(const void *tag_buf, u16 tag_len, 3301 struct debug_htt_stats_req *stats_req) 3302 { 3303 const struct ath12k_htt_pdev_mbssid_ctrl_frame_tlv *htt_stats_buf = tag_buf; 3304 u8 *buf = stats_req->buf; 3305 u32 len = stats_req->buf_len; 3306 u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 3307 u32 mac_id_word; 3308 3309 if (tag_len < sizeof(*htt_stats_buf)) 3310 return; 3311 3312 mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word); 3313 3314 len += scnprintf(buf + len, buf_len - len, "HTT_MBSSID_CTRL_FRAME_STATS_TLV:\n"); 3315 len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 3316 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID)); 3317 len += scnprintf(buf + len, buf_len - len, "basic_trigger_across_bss = %u\n", 3318 le32_to_cpu(htt_stats_buf->basic_trigger_across_bss)); 3319 len += scnprintf(buf + len, buf_len - len, "basic_trigger_within_bss = %u\n", 3320 le32_to_cpu(htt_stats_buf->basic_trigger_within_bss)); 3321 len += scnprintf(buf + len, buf_len - len, "bsr_trigger_across_bss = %u\n", 3322 le32_to_cpu(htt_stats_buf->bsr_trigger_across_bss)); 3323 len += scnprintf(buf + len, buf_len - len, "bsr_trigger_within_bss = %u\n", 3324 le32_to_cpu(htt_stats_buf->bsr_trigger_within_bss)); 3325 len += scnprintf(buf + len, buf_len - len, "mu_rts_across_bss = %u\n", 3326 le32_to_cpu(htt_stats_buf->mu_rts_across_bss)); 3327 len += scnprintf(buf + len, buf_len - len, "mu_rts_within_bss = %u\n", 3328 le32_to_cpu(htt_stats_buf->mu_rts_within_bss)); 3329 len += scnprintf(buf + len, buf_len - len, "ul_mumimo_trigger_across_bss = %u\n", 3330 le32_to_cpu(htt_stats_buf->ul_mumimo_trigger_across_bss)); 3331 len += scnprintf(buf + len, buf_len - len, 3332 "ul_mumimo_trigger_within_bss = %u\n\n", 3333 le32_to_cpu(htt_stats_buf->ul_mumimo_trigger_within_bss)); 3334 3335 stats_req->buf_len = len; 3336 } 3337 3338 static int ath12k_dbg_htt_ext_stats_parse(struct ath12k_base *ab, 3339 u16 tag, u16 len, const void *tag_buf, 3340 void *user_data) 3341 { 3342 struct debug_htt_stats_req *stats_req = user_data; 3343 3344 switch (tag) { 3345 case HTT_STATS_TX_PDEV_CMN_TAG: 3346 htt_print_tx_pdev_stats_cmn_tlv(tag_buf, len, stats_req); 3347 break; 3348 case HTT_STATS_TX_PDEV_UNDERRUN_TAG: 3349 htt_print_tx_pdev_stats_urrn_tlv(tag_buf, len, stats_req); 3350 break; 3351 case HTT_STATS_TX_PDEV_SIFS_TAG: 3352 htt_print_tx_pdev_stats_sifs_tlv(tag_buf, len, stats_req); 3353 break; 3354 case HTT_STATS_TX_PDEV_FLUSH_TAG: 3355 htt_print_tx_pdev_stats_flush_tlv(tag_buf, len, stats_req); 3356 break; 3357 case HTT_STATS_TX_PDEV_SIFS_HIST_TAG: 3358 htt_print_tx_pdev_stats_sifs_hist_tlv(tag_buf, len, stats_req); 3359 break; 3360 case HTT_STATS_PDEV_CTRL_PATH_TX_STATS_TAG: 3361 htt_print_pdev_ctrl_path_tx_stats_tlv(tag_buf, len, stats_req); 3362 break; 3363 case HTT_STATS_MU_PPDU_DIST_TAG: 3364 htt_print_tx_pdev_mu_ppdu_dist_stats_tlv(tag_buf, len, stats_req); 3365 break; 3366 case HTT_STATS_TX_SCHED_CMN_TAG: 3367 ath12k_htt_print_stats_tx_sched_cmn_tlv(tag_buf, len, stats_req); 3368 break; 3369 case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG: 3370 ath12k_htt_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf, len, stats_req); 3371 break; 3372 case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG: 3373 ath12k_htt_print_sched_txq_cmd_posted_tlv(tag_buf, len, stats_req); 3374 break; 3375 case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG: 3376 ath12k_htt_print_sched_txq_cmd_reaped_tlv(tag_buf, len, stats_req); 3377 break; 3378 case HTT_STATS_SCHED_TXQ_SCHED_ORDER_SU_TAG: 3379 ath12k_htt_print_sched_txq_sched_order_su_tlv(tag_buf, len, stats_req); 3380 break; 3381 case HTT_STATS_SCHED_TXQ_SCHED_INELIGIBILITY_TAG: 3382 ath12k_htt_print_sched_txq_sched_ineligibility_tlv(tag_buf, len, 3383 stats_req); 3384 break; 3385 case HTT_STATS_SCHED_TXQ_SUPERCYCLE_TRIGGER_TAG: 3386 ath12k_htt_print_sched_txq_supercycle_trigger_tlv(tag_buf, len, 3387 stats_req); 3388 break; 3389 case HTT_STATS_HW_PDEV_ERRS_TAG: 3390 ath12k_htt_print_hw_stats_pdev_errs_tlv(tag_buf, len, stats_req); 3391 break; 3392 case HTT_STATS_HW_INTR_MISC_TAG: 3393 ath12k_htt_print_hw_stats_intr_misc_tlv(tag_buf, len, stats_req); 3394 break; 3395 case HTT_STATS_WHAL_TX_TAG: 3396 ath12k_htt_print_hw_stats_whal_tx_tlv(tag_buf, len, stats_req); 3397 break; 3398 case HTT_STATS_HW_WAR_TAG: 3399 ath12k_htt_print_hw_war_tlv(tag_buf, len, stats_req); 3400 break; 3401 case HTT_STATS_TX_TQM_CMN_TAG: 3402 ath12k_htt_print_tx_tqm_cmn_stats_tlv(tag_buf, len, stats_req); 3403 break; 3404 case HTT_STATS_TX_TQM_ERROR_STATS_TAG: 3405 ath12k_htt_print_tx_tqm_error_stats_tlv(tag_buf, len, stats_req); 3406 break; 3407 case HTT_STATS_TX_TQM_GEN_MPDU_TAG: 3408 ath12k_htt_print_tx_tqm_gen_mpdu_stats_tlv(tag_buf, len, stats_req); 3409 break; 3410 case HTT_STATS_TX_TQM_LIST_MPDU_TAG: 3411 ath12k_htt_print_tx_tqm_list_mpdu_stats_tlv(tag_buf, len, stats_req); 3412 break; 3413 case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG: 3414 ath12k_htt_print_tx_tqm_list_mpdu_cnt_tlv(tag_buf, len, stats_req); 3415 break; 3416 case HTT_STATS_TX_TQM_PDEV_TAG: 3417 ath12k_htt_print_tx_tqm_pdev_stats_tlv(tag_buf, len, stats_req); 3418 break; 3419 case HTT_STATS_TX_DE_CMN_TAG: 3420 ath12k_htt_print_tx_de_cmn_stats_tlv(tag_buf, len, stats_req); 3421 break; 3422 case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG: 3423 ath12k_htt_print_tx_de_eapol_packets_stats_tlv(tag_buf, len, stats_req); 3424 break; 3425 case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG: 3426 ath12k_htt_print_tx_de_classify_stats_tlv(tag_buf, len, stats_req); 3427 break; 3428 case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG: 3429 ath12k_htt_print_tx_de_classify_failed_stats_tlv(tag_buf, len, stats_req); 3430 break; 3431 case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG: 3432 ath12k_htt_print_tx_de_classify_status_stats_tlv(tag_buf, len, stats_req); 3433 break; 3434 case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG: 3435 ath12k_htt_print_tx_de_enqueue_packets_stats_tlv(tag_buf, len, stats_req); 3436 break; 3437 case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG: 3438 ath12k_htt_print_tx_de_enqueue_discard_stats_tlv(tag_buf, len, stats_req); 3439 break; 3440 case HTT_STATS_TX_DE_COMPL_STATS_TAG: 3441 ath12k_htt_print_tx_de_compl_stats_tlv(tag_buf, len, stats_req); 3442 break; 3443 case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG: 3444 ath12k_htt_print_tx_selfgen_cmn_stats_tlv(tag_buf, len, stats_req); 3445 break; 3446 case HTT_STATS_TX_SELFGEN_AC_STATS_TAG: 3447 ath12k_htt_print_tx_selfgen_ac_stats_tlv(tag_buf, len, stats_req); 3448 break; 3449 case HTT_STATS_TX_SELFGEN_AX_STATS_TAG: 3450 ath12k_htt_print_tx_selfgen_ax_stats_tlv(tag_buf, len, stats_req); 3451 break; 3452 case HTT_STATS_TX_SELFGEN_BE_STATS_TAG: 3453 ath12k_htt_print_tx_selfgen_be_stats_tlv(tag_buf, len, stats_req); 3454 break; 3455 case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG: 3456 ath12k_htt_print_tx_selfgen_ac_err_stats_tlv(tag_buf, len, stats_req); 3457 break; 3458 case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG: 3459 ath12k_htt_print_tx_selfgen_ax_err_stats_tlv(tag_buf, len, stats_req); 3460 break; 3461 case HTT_STATS_TX_SELFGEN_BE_ERR_STATS_TAG: 3462 ath12k_htt_print_tx_selfgen_be_err_stats_tlv(tag_buf, len, stats_req); 3463 break; 3464 case HTT_STATS_TX_SELFGEN_AC_SCHED_STATUS_STATS_TAG: 3465 ath12k_htt_print_tx_selfgen_ac_sched_status_stats_tlv(tag_buf, len, 3466 stats_req); 3467 break; 3468 case HTT_STATS_TX_SELFGEN_AX_SCHED_STATUS_STATS_TAG: 3469 ath12k_htt_print_tx_selfgen_ax_sched_status_stats_tlv(tag_buf, len, 3470 stats_req); 3471 break; 3472 case HTT_STATS_TX_SELFGEN_BE_SCHED_STATUS_STATS_TAG: 3473 ath12k_htt_print_tx_selfgen_be_sched_status_stats_tlv(tag_buf, len, 3474 stats_req); 3475 break; 3476 case HTT_STATS_STRING_TAG: 3477 ath12k_htt_print_stats_string_tlv(tag_buf, len, stats_req); 3478 break; 3479 case HTT_STATS_SRING_STATS_TAG: 3480 ath12k_htt_print_sring_stats_tlv(tag_buf, len, stats_req); 3481 break; 3482 case HTT_STATS_SFM_CMN_TAG: 3483 ath12k_htt_print_sfm_cmn_tlv(tag_buf, len, stats_req); 3484 break; 3485 case HTT_STATS_SFM_CLIENT_TAG: 3486 ath12k_htt_print_sfm_client_tlv(tag_buf, len, stats_req); 3487 break; 3488 case HTT_STATS_SFM_CLIENT_USER_TAG: 3489 ath12k_htt_print_sfm_client_user_tlv(tag_buf, len, stats_req); 3490 break; 3491 case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG: 3492 ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, len, stats_req); 3493 break; 3494 case HTT_STATS_TX_PDEV_MUMIMO_GRP_STATS_TAG: 3495 ath12k_htt_print_tx_pdev_mumimo_grp_stats_tlv(tag_buf, len, stats_req); 3496 break; 3497 case HTT_STATS_TX_PDEV_MPDU_STATS_TAG: 3498 ath12k_htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf, len, stats_req); 3499 break; 3500 case HTT_STATS_PDEV_CCA_1SEC_HIST_TAG: 3501 case HTT_STATS_PDEV_CCA_100MSEC_HIST_TAG: 3502 case HTT_STATS_PDEV_CCA_STAT_CUMULATIVE_TAG: 3503 ath12k_htt_print_pdev_cca_stats_hist_tlv(tag_buf, len, stats_req); 3504 break; 3505 case HTT_STATS_PDEV_CCA_COUNTERS_TAG: 3506 ath12k_htt_print_pdev_stats_cca_counters_tlv(tag_buf, len, stats_req); 3507 break; 3508 case HTT_STATS_PDEV_OBSS_PD_TAG: 3509 ath12k_htt_print_pdev_obss_pd_stats_tlv(tag_buf, len, stats_req); 3510 break; 3511 case HTT_STATS_DLPAGER_STATS_TAG: 3512 ath12k_htt_print_dlpager_stats_tlv(tag_buf, len, stats_req); 3513 break; 3514 case HTT_STATS_PHY_STATS_TAG: 3515 ath12k_htt_print_phy_stats_tlv(tag_buf, len, stats_req); 3516 break; 3517 case HTT_STATS_PHY_COUNTERS_TAG: 3518 ath12k_htt_print_phy_counters_tlv(tag_buf, len, stats_req); 3519 break; 3520 case HTT_STATS_PHY_RESET_STATS_TAG: 3521 ath12k_htt_print_phy_reset_stats_tlv(tag_buf, len, stats_req); 3522 break; 3523 case HTT_STATS_PHY_RESET_COUNTERS_TAG: 3524 ath12k_htt_print_phy_reset_counters_tlv(tag_buf, len, stats_req); 3525 break; 3526 case HTT_STATS_PHY_TPC_STATS_TAG: 3527 ath12k_htt_print_phy_tpc_stats_tlv(tag_buf, len, stats_req); 3528 break; 3529 case HTT_STATS_SOC_TXRX_STATS_COMMON_TAG: 3530 ath12k_htt_print_soc_txrx_stats_common_tlv(tag_buf, len, stats_req); 3531 break; 3532 case HTT_STATS_PER_RATE_STATS_TAG: 3533 ath12k_htt_print_tx_per_rate_stats_tlv(tag_buf, len, stats_req); 3534 break; 3535 case HTT_STATS_DMAC_RESET_STATS_TAG: 3536 ath12k_htt_print_dmac_reset_stats_tlv(tag_buf, len, stats_req); 3537 break; 3538 case HTT_STATS_PDEV_SCHED_ALGO_OFDMA_STATS_TAG: 3539 ath12k_htt_print_pdev_sched_algo_ofdma_stats_tlv(tag_buf, len, stats_req); 3540 break; 3541 case HTT_STATS_TX_PDEV_RATE_STATS_BE_OFDMA_TAG: 3542 ath12k_htt_print_tx_pdev_rate_stats_be_ofdma_tlv(tag_buf, len, stats_req); 3543 break; 3544 case HTT_STATS_PDEV_MBSSID_CTRL_FRAME_STATS_TAG: 3545 ath12k_htt_print_pdev_mbssid_ctrl_frame_stats_tlv(tag_buf, len, 3546 stats_req); 3547 break; 3548 default: 3549 break; 3550 } 3551 3552 return 0; 3553 } 3554 3555 void ath12k_debugfs_htt_ext_stats_handler(struct ath12k_base *ab, 3556 struct sk_buff *skb) 3557 { 3558 struct ath12k_htt_extd_stats_msg *msg; 3559 struct debug_htt_stats_req *stats_req; 3560 struct ath12k *ar; 3561 u32 len, pdev_id, stats_info; 3562 u64 cookie; 3563 int ret; 3564 bool send_completion = false; 3565 3566 msg = (struct ath12k_htt_extd_stats_msg *)skb->data; 3567 cookie = le64_to_cpu(msg->cookie); 3568 3569 if (u64_get_bits(cookie, ATH12K_HTT_STATS_COOKIE_MSB) != 3570 ATH12K_HTT_STATS_MAGIC_VALUE) { 3571 ath12k_warn(ab, "received invalid htt ext stats event\n"); 3572 return; 3573 } 3574 3575 pdev_id = u64_get_bits(cookie, ATH12K_HTT_STATS_COOKIE_LSB); 3576 rcu_read_lock(); 3577 ar = ath12k_mac_get_ar_by_pdev_id(ab, pdev_id); 3578 if (!ar) { 3579 ath12k_warn(ab, "failed to get ar for pdev_id %d\n", pdev_id); 3580 goto exit; 3581 } 3582 3583 stats_req = ar->debug.htt_stats.stats_req; 3584 if (!stats_req) 3585 goto exit; 3586 3587 spin_lock_bh(&ar->data_lock); 3588 3589 stats_info = le32_to_cpu(msg->info1); 3590 stats_req->done = u32_get_bits(stats_info, ATH12K_HTT_T2H_EXT_STATS_INFO1_DONE); 3591 if (stats_req->done) 3592 send_completion = true; 3593 3594 spin_unlock_bh(&ar->data_lock); 3595 3596 len = u32_get_bits(stats_info, ATH12K_HTT_T2H_EXT_STATS_INFO1_LENGTH); 3597 if (len > skb->len) { 3598 ath12k_warn(ab, "invalid length %d for HTT stats", len); 3599 goto exit; 3600 } 3601 3602 ret = ath12k_dp_htt_tlv_iter(ab, msg->data, len, 3603 ath12k_dbg_htt_ext_stats_parse, 3604 stats_req); 3605 if (ret) 3606 ath12k_warn(ab, "Failed to parse tlv %d\n", ret); 3607 3608 if (send_completion) 3609 complete(&stats_req->htt_stats_rcvd); 3610 exit: 3611 rcu_read_unlock(); 3612 } 3613 3614 static ssize_t ath12k_read_htt_stats_type(struct file *file, 3615 char __user *user_buf, 3616 size_t count, loff_t *ppos) 3617 { 3618 struct ath12k *ar = file->private_data; 3619 enum ath12k_dbg_htt_ext_stats_type type; 3620 char buf[32]; 3621 size_t len; 3622 3623 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 3624 type = ar->debug.htt_stats.type; 3625 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3626 3627 len = scnprintf(buf, sizeof(buf), "%u\n", type); 3628 3629 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 3630 } 3631 3632 static ssize_t ath12k_write_htt_stats_type(struct file *file, 3633 const char __user *user_buf, 3634 size_t count, loff_t *ppos) 3635 { 3636 struct ath12k *ar = file->private_data; 3637 enum ath12k_dbg_htt_ext_stats_type type; 3638 unsigned int cfg_param[4] = {0}; 3639 const int size = 32; 3640 int num_args; 3641 3642 char *buf __free(kfree) = kzalloc(size, GFP_KERNEL); 3643 if (!buf) 3644 return -ENOMEM; 3645 3646 if (copy_from_user(buf, user_buf, count)) 3647 return -EFAULT; 3648 3649 num_args = sscanf(buf, "%u %u %u %u %u\n", &type, &cfg_param[0], 3650 &cfg_param[1], &cfg_param[2], &cfg_param[3]); 3651 if (!num_args || num_args > 5) 3652 return -EINVAL; 3653 3654 if (type == ATH12K_DBG_HTT_EXT_STATS_RESET || 3655 type >= ATH12K_DBG_HTT_NUM_EXT_STATS) 3656 return -EINVAL; 3657 3658 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 3659 3660 ar->debug.htt_stats.type = type; 3661 ar->debug.htt_stats.cfg_param[0] = cfg_param[0]; 3662 ar->debug.htt_stats.cfg_param[1] = cfg_param[1]; 3663 ar->debug.htt_stats.cfg_param[2] = cfg_param[2]; 3664 ar->debug.htt_stats.cfg_param[3] = cfg_param[3]; 3665 3666 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3667 3668 return count; 3669 } 3670 3671 static const struct file_operations fops_htt_stats_type = { 3672 .read = ath12k_read_htt_stats_type, 3673 .write = ath12k_write_htt_stats_type, 3674 .open = simple_open, 3675 .owner = THIS_MODULE, 3676 .llseek = default_llseek, 3677 }; 3678 3679 static int ath12k_debugfs_htt_stats_req(struct ath12k *ar) 3680 { 3681 struct debug_htt_stats_req *stats_req = ar->debug.htt_stats.stats_req; 3682 enum ath12k_dbg_htt_ext_stats_type type = stats_req->type; 3683 u64 cookie; 3684 int ret, pdev_id; 3685 struct htt_ext_stats_cfg_params cfg_params = { 0 }; 3686 3687 lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); 3688 3689 init_completion(&stats_req->htt_stats_rcvd); 3690 3691 pdev_id = ath12k_mac_get_target_pdev_id(ar); 3692 stats_req->done = false; 3693 stats_req->pdev_id = pdev_id; 3694 3695 cookie = u64_encode_bits(ATH12K_HTT_STATS_MAGIC_VALUE, 3696 ATH12K_HTT_STATS_COOKIE_MSB); 3697 cookie |= u64_encode_bits(pdev_id, ATH12K_HTT_STATS_COOKIE_LSB); 3698 3699 if (stats_req->override_cfg_param) { 3700 cfg_params.cfg0 = stats_req->cfg_param[0]; 3701 cfg_params.cfg1 = stats_req->cfg_param[1]; 3702 cfg_params.cfg2 = stats_req->cfg_param[2]; 3703 cfg_params.cfg3 = stats_req->cfg_param[3]; 3704 } 3705 3706 ret = ath12k_dp_tx_htt_h2t_ext_stats_req(ar, type, &cfg_params, cookie); 3707 if (ret) { 3708 ath12k_warn(ar->ab, "failed to send htt stats request: %d\n", ret); 3709 return ret; 3710 } 3711 if (!wait_for_completion_timeout(&stats_req->htt_stats_rcvd, 3 * HZ)) { 3712 spin_lock_bh(&ar->data_lock); 3713 if (!stats_req->done) { 3714 stats_req->done = true; 3715 spin_unlock_bh(&ar->data_lock); 3716 ath12k_warn(ar->ab, "stats request timed out\n"); 3717 return -ETIMEDOUT; 3718 } 3719 spin_unlock_bh(&ar->data_lock); 3720 } 3721 3722 return 0; 3723 } 3724 3725 static int ath12k_open_htt_stats(struct inode *inode, 3726 struct file *file) 3727 { 3728 struct ath12k *ar = inode->i_private; 3729 struct debug_htt_stats_req *stats_req; 3730 enum ath12k_dbg_htt_ext_stats_type type = ar->debug.htt_stats.type; 3731 struct ath12k_hw *ah = ath12k_ar_to_ah(ar); 3732 int ret; 3733 3734 if (type == ATH12K_DBG_HTT_EXT_STATS_RESET) 3735 return -EPERM; 3736 3737 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 3738 3739 if (ah->state != ATH12K_HW_STATE_ON) { 3740 ret = -ENETDOWN; 3741 goto err_unlock; 3742 } 3743 3744 if (ar->debug.htt_stats.stats_req) { 3745 ret = -EAGAIN; 3746 goto err_unlock; 3747 } 3748 3749 stats_req = kzalloc(sizeof(*stats_req) + ATH12K_HTT_STATS_BUF_SIZE, GFP_KERNEL); 3750 if (!stats_req) { 3751 ret = -ENOMEM; 3752 goto err_unlock; 3753 } 3754 3755 ar->debug.htt_stats.stats_req = stats_req; 3756 stats_req->type = type; 3757 stats_req->cfg_param[0] = ar->debug.htt_stats.cfg_param[0]; 3758 stats_req->cfg_param[1] = ar->debug.htt_stats.cfg_param[1]; 3759 stats_req->cfg_param[2] = ar->debug.htt_stats.cfg_param[2]; 3760 stats_req->cfg_param[3] = ar->debug.htt_stats.cfg_param[3]; 3761 stats_req->override_cfg_param = !!stats_req->cfg_param[0] || 3762 !!stats_req->cfg_param[1] || 3763 !!stats_req->cfg_param[2] || 3764 !!stats_req->cfg_param[3]; 3765 3766 ret = ath12k_debugfs_htt_stats_req(ar); 3767 if (ret < 0) 3768 goto out; 3769 3770 file->private_data = stats_req; 3771 3772 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3773 3774 return 0; 3775 out: 3776 kfree(stats_req); 3777 ar->debug.htt_stats.stats_req = NULL; 3778 err_unlock: 3779 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3780 3781 return ret; 3782 } 3783 3784 static int ath12k_release_htt_stats(struct inode *inode, 3785 struct file *file) 3786 { 3787 struct ath12k *ar = inode->i_private; 3788 3789 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 3790 kfree(file->private_data); 3791 ar->debug.htt_stats.stats_req = NULL; 3792 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3793 3794 return 0; 3795 } 3796 3797 static ssize_t ath12k_read_htt_stats(struct file *file, 3798 char __user *user_buf, 3799 size_t count, loff_t *ppos) 3800 { 3801 struct debug_htt_stats_req *stats_req = file->private_data; 3802 char *buf; 3803 u32 length; 3804 3805 buf = stats_req->buf; 3806 length = min_t(u32, stats_req->buf_len, ATH12K_HTT_STATS_BUF_SIZE); 3807 return simple_read_from_buffer(user_buf, count, ppos, buf, length); 3808 } 3809 3810 static const struct file_operations fops_dump_htt_stats = { 3811 .open = ath12k_open_htt_stats, 3812 .release = ath12k_release_htt_stats, 3813 .read = ath12k_read_htt_stats, 3814 .owner = THIS_MODULE, 3815 .llseek = default_llseek, 3816 }; 3817 3818 static ssize_t ath12k_write_htt_stats_reset(struct file *file, 3819 const char __user *user_buf, 3820 size_t count, loff_t *ppos) 3821 { 3822 struct ath12k *ar = file->private_data; 3823 enum ath12k_dbg_htt_ext_stats_type type; 3824 struct htt_ext_stats_cfg_params cfg_params = { 0 }; 3825 u8 param_pos; 3826 int ret; 3827 3828 ret = kstrtou32_from_user(user_buf, count, 0, &type); 3829 if (ret) 3830 return ret; 3831 3832 if (type >= ATH12K_DBG_HTT_NUM_EXT_STATS || 3833 type == ATH12K_DBG_HTT_EXT_STATS_RESET) 3834 return -E2BIG; 3835 3836 wiphy_lock(ath12k_ar_to_hw(ar)->wiphy); 3837 cfg_params.cfg0 = HTT_STAT_DEFAULT_RESET_START_OFFSET; 3838 param_pos = (type >> 5) + 1; 3839 3840 switch (param_pos) { 3841 case ATH12K_HTT_STATS_RESET_PARAM_CFG_32_BYTES: 3842 cfg_params.cfg1 = 1 << (cfg_params.cfg0 + type); 3843 break; 3844 case ATH12K_HTT_STATS_RESET_PARAM_CFG_64_BYTES: 3845 cfg_params.cfg2 = ATH12K_HTT_STATS_RESET_BITMAP32_BIT(cfg_params.cfg0 + 3846 type); 3847 break; 3848 case ATH12K_HTT_STATS_RESET_PARAM_CFG_128_BYTES: 3849 cfg_params.cfg3 = ATH12K_HTT_STATS_RESET_BITMAP64_BIT(cfg_params.cfg0 + 3850 type); 3851 break; 3852 default: 3853 break; 3854 } 3855 3856 ret = ath12k_dp_tx_htt_h2t_ext_stats_req(ar, 3857 ATH12K_DBG_HTT_EXT_STATS_RESET, 3858 &cfg_params, 3859 0ULL); 3860 if (ret) { 3861 ath12k_warn(ar->ab, "failed to send htt stats request: %d\n", ret); 3862 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3863 return ret; 3864 } 3865 3866 ar->debug.htt_stats.reset = type; 3867 wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy); 3868 3869 return count; 3870 } 3871 3872 static const struct file_operations fops_htt_stats_reset = { 3873 .write = ath12k_write_htt_stats_reset, 3874 .open = simple_open, 3875 .owner = THIS_MODULE, 3876 .llseek = default_llseek, 3877 }; 3878 3879 void ath12k_debugfs_htt_stats_register(struct ath12k *ar) 3880 { 3881 debugfs_create_file("htt_stats_type", 0600, ar->debug.debugfs_pdev, 3882 ar, &fops_htt_stats_type); 3883 debugfs_create_file("htt_stats", 0400, ar->debug.debugfs_pdev, 3884 ar, &fops_dump_htt_stats); 3885 debugfs_create_file("htt_stats_reset", 0200, ar->debug.debugfs_pdev, 3886 ar, &fops_htt_stats_reset); 3887 } 3888