CoCalc -- debugfs_htt

GitHub Repository: freebsd/freebsd-src
Path: blob/main/sys/contrib/dev/athk/ath12k/debugfs_htt_stats.c
¹⁷⁸⁶⁹⁹ views
1
// SPDX-License-Identifier: BSD-3-Clause-Clear
2
/*
3
 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
4
 * Copyright (c) 2021-2025 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 u32
52
print_array_to_buf_s8(u8 *buf, u32 offset, const char *header, u32 stats_index,
53
		      const s8 *array, u32 array_len, const char *footer)
54
{
55
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
56
	int index = 0;
57
	u8 i;
58

59
	if (header)
60
		index += scnprintf(buf + offset, buf_len - offset, "%s = ", header);
61

62
	for (i = 0; i < array_len; i++) {
63
		index += scnprintf(buf + offset + index, (buf_len - offset) - index,
64
				   " %u:%d,", stats_index++, array[i]);
65
	}
66

67
	index--;
68
	if ((offset + index) < buf_len)
69
		buf[offset + index] = '\0';
70

71
	if (footer) {
72
		index += scnprintf(buf + offset + index, (buf_len - offset) - index,
73
				   "%s", footer);
74
	}
75

76
	return index;
77
}
78

79
static const char *ath12k_htt_ax_tx_rx_ru_size_to_str(u8 ru_size)
80
{
81
	switch (ru_size) {
82
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_26:
83
		return "26";
84
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_52:
85
		return "52";
86
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_106:
87
		return "106";
88
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_242:
89
		return "242";
90
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_484:
91
		return "484";
92
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_996:
93
		return "996";
94
	case ATH12K_HTT_TX_RX_PDEV_STATS_AX_RU_SIZE_996x2:
95
		return "996x2";
96
	default:
97
		return "unknown";
98
	}
99
}
100

101
static const char *ath12k_htt_be_tx_rx_ru_size_to_str(u8 ru_size)
102
{
103
	switch (ru_size) {
104
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_26:
105
		return "26";
106
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_52:
107
		return "52";
108
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_52_26:
109
		return "52+26";
110
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_106:
111
		return "106";
112
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_106_26:
113
		return "106+26";
114
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_242:
115
		return "242";
116
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_484:
117
		return "484";
118
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_484_242:
119
		return "484+242";
120
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996:
121
		return "996";
122
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996_484:
123
		return "996+484";
124
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996_484_242:
125
		return "996+484+242";
126
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x2:
127
		return "996x2";
128
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x2_484:
129
		return "996x2+484";
130
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x3:
131
		return "996x3";
132
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x3_484:
133
		return "996x3+484";
134
	case ATH12K_HTT_TX_RX_PDEV_STATS_BE_RU_SIZE_996x4:
135
		return "996x4";
136
	default:
137
		return "unknown";
138
	}
139
}
140

141
static const char*
142
ath12k_tx_ru_size_to_str(enum ath12k_htt_stats_ru_type ru_type, u8 ru_size)
143
{
144
	if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY)
145
		return ath12k_htt_ax_tx_rx_ru_size_to_str(ru_size);
146
	else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU)
147
		return ath12k_htt_be_tx_rx_ru_size_to_str(ru_size);
148
	else
149
		return "unknown";
150
}
151

152
static void
153
htt_print_tx_pdev_stats_cmn_tlv(const void *tag_buf, u16 tag_len,
154
				struct debug_htt_stats_req *stats_req)
155
{
156
	const struct ath12k_htt_tx_pdev_stats_cmn_tlv *htt_stats_buf = tag_buf;
157
	u8 *buf = stats_req->buf;
158
	u32 len = stats_req->buf_len;
159
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
160
	u32 mac_id_word;
161

162
	if (tag_len < sizeof(*htt_stats_buf))
163
		return;
164

165
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word);
166

167
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n");
168
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
169
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
170
	len += scnprintf(buf + len, buf_len - len, "comp_delivered = %u\n",
171
			 le32_to_cpu(htt_stats_buf->comp_delivered));
172
	len += scnprintf(buf + len, buf_len - len, "self_triggers = %u\n",
173
			 le32_to_cpu(htt_stats_buf->self_triggers));
174
	len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n",
175
			 le32_to_cpu(htt_stats_buf->hw_queued));
176
	len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n",
177
			 le32_to_cpu(htt_stats_buf->hw_reaped));
178
	len += scnprintf(buf + len, buf_len - len, "underrun = %u\n",
179
			 le32_to_cpu(htt_stats_buf->underrun));
180
	len += scnprintf(buf + len, buf_len - len, "hw_paused = %u\n",
181
			 le32_to_cpu(htt_stats_buf->hw_paused));
182
	len += scnprintf(buf + len, buf_len - len, "hw_flush = %u\n",
183
			 le32_to_cpu(htt_stats_buf->hw_flush));
184
	len += scnprintf(buf + len, buf_len - len, "hw_filt = %u\n",
185
			 le32_to_cpu(htt_stats_buf->hw_filt));
186
	len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n",
187
			 le32_to_cpu(htt_stats_buf->tx_abort));
188
	len += scnprintf(buf + len, buf_len - len, "ppdu_ok = %u\n",
189
			 le32_to_cpu(htt_stats_buf->ppdu_ok));
190
	len += scnprintf(buf + len, buf_len - len, "mpdu_requeued = %u\n",
191
			 le32_to_cpu(htt_stats_buf->mpdu_requed));
192
	len += scnprintf(buf + len, buf_len - len, "tx_xretry = %u\n",
193
			 le32_to_cpu(htt_stats_buf->tx_xretry));
194
	len += scnprintf(buf + len, buf_len - len, "data_rc = %u\n",
195
			 le32_to_cpu(htt_stats_buf->data_rc));
196
	len += scnprintf(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n",
197
			 le32_to_cpu(htt_stats_buf->mpdu_dropped_xretry));
198
	len += scnprintf(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n",
199
			 le32_to_cpu(htt_stats_buf->illgl_rate_phy_err));
200
	len += scnprintf(buf + len, buf_len - len, "cont_xretry = %u\n",
201
			 le32_to_cpu(htt_stats_buf->cont_xretry));
202
	len += scnprintf(buf + len, buf_len - len, "tx_timeout = %u\n",
203
			 le32_to_cpu(htt_stats_buf->tx_timeout));
204
	len += scnprintf(buf + len, buf_len - len, "tx_time_dur_data = %u\n",
205
			 le32_to_cpu(htt_stats_buf->tx_time_dur_data));
206
	len += scnprintf(buf + len, buf_len - len, "pdev_resets = %u\n",
207
			 le32_to_cpu(htt_stats_buf->pdev_resets));
208
	len += scnprintf(buf + len, buf_len - len, "phy_underrun = %u\n",
209
			 le32_to_cpu(htt_stats_buf->phy_underrun));
210
	len += scnprintf(buf + len, buf_len - len, "txop_ovf = %u\n",
211
			 le32_to_cpu(htt_stats_buf->txop_ovf));
212
	len += scnprintf(buf + len, buf_len - len, "seq_posted = %u\n",
213
			 le32_to_cpu(htt_stats_buf->seq_posted));
214
	len += scnprintf(buf + len, buf_len - len, "seq_failed_queueing = %u\n",
215
			 le32_to_cpu(htt_stats_buf->seq_failed_queueing));
216
	len += scnprintf(buf + len, buf_len - len, "seq_completed = %u\n",
217
			 le32_to_cpu(htt_stats_buf->seq_completed));
218
	len += scnprintf(buf + len, buf_len - len, "seq_restarted = %u\n",
219
			 le32_to_cpu(htt_stats_buf->seq_restarted));
220
	len += scnprintf(buf + len, buf_len - len, "seq_txop_repost_stop = %u\n",
221
			 le32_to_cpu(htt_stats_buf->seq_txop_repost_stop));
222
	len += scnprintf(buf + len, buf_len - len, "next_seq_cancel = %u\n",
223
			 le32_to_cpu(htt_stats_buf->next_seq_cancel));
224
	len += scnprintf(buf + len, buf_len - len, "dl_mu_mimo_seq_posted = %u\n",
225
			 le32_to_cpu(htt_stats_buf->mu_seq_posted));
226
	len += scnprintf(buf + len, buf_len - len, "dl_mu_ofdma_seq_posted = %u\n",
227
			 le32_to_cpu(htt_stats_buf->mu_ofdma_seq_posted));
228
	len += scnprintf(buf + len, buf_len - len, "ul_mu_mimo_seq_posted = %u\n",
229
			 le32_to_cpu(htt_stats_buf->ul_mumimo_seq_posted));
230
	len += scnprintf(buf + len, buf_len - len, "ul_mu_ofdma_seq_posted = %u\n",
231
			 le32_to_cpu(htt_stats_buf->ul_ofdma_seq_posted));
232
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_peer_blacklisted = %u\n",
233
			 le32_to_cpu(htt_stats_buf->num_mu_peer_blacklisted));
234
	len += scnprintf(buf + len, buf_len - len, "seq_qdepth_repost_stop = %u\n",
235
			 le32_to_cpu(htt_stats_buf->seq_qdepth_repost_stop));
236
	len += scnprintf(buf + len, buf_len - len, "seq_min_msdu_repost_stop = %u\n",
237
			 le32_to_cpu(htt_stats_buf->seq_min_msdu_repost_stop));
238
	len += scnprintf(buf + len, buf_len - len, "mu_seq_min_msdu_repost_stop = %u\n",
239
			 le32_to_cpu(htt_stats_buf->mu_seq_min_msdu_repost_stop));
240
	len += scnprintf(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n",
241
			 le32_to_cpu(htt_stats_buf->seq_switch_hw_paused));
242
	len += scnprintf(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n",
243
			 le32_to_cpu(htt_stats_buf->next_seq_posted_dsr));
244
	len += scnprintf(buf + len, buf_len - len, "seq_posted_isr = %u\n",
245
			 le32_to_cpu(htt_stats_buf->seq_posted_isr));
246
	len += scnprintf(buf + len, buf_len - len, "seq_ctrl_cached = %u\n",
247
			 le32_to_cpu(htt_stats_buf->seq_ctrl_cached));
248
	len += scnprintf(buf + len, buf_len - len, "mpdu_count_tqm = %u\n",
249
			 le32_to_cpu(htt_stats_buf->mpdu_count_tqm));
250
	len += scnprintf(buf + len, buf_len - len, "msdu_count_tqm = %u\n",
251
			 le32_to_cpu(htt_stats_buf->msdu_count_tqm));
252
	len += scnprintf(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n",
253
			 le32_to_cpu(htt_stats_buf->mpdu_removed_tqm));
254
	len += scnprintf(buf + len, buf_len - len, "msdu_removed_tqm = %u\n",
255
			 le32_to_cpu(htt_stats_buf->msdu_removed_tqm));
256
	len += scnprintf(buf + len, buf_len - len, "remove_mpdus_max_retries = %u\n",
257
			 le32_to_cpu(htt_stats_buf->remove_mpdus_max_retries));
258
	len += scnprintf(buf + len, buf_len - len, "mpdus_sw_flush = %u\n",
259
			 le32_to_cpu(htt_stats_buf->mpdus_sw_flush));
260
	len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
261
			 le32_to_cpu(htt_stats_buf->mpdus_hw_filter));
262
	len += scnprintf(buf + len, buf_len - len, "mpdus_truncated = %u\n",
263
			 le32_to_cpu(htt_stats_buf->mpdus_truncated));
264
	len += scnprintf(buf + len, buf_len - len, "mpdus_ack_failed = %u\n",
265
			 le32_to_cpu(htt_stats_buf->mpdus_ack_failed));
266
	len += scnprintf(buf + len, buf_len - len, "mpdus_expired = %u\n",
267
			 le32_to_cpu(htt_stats_buf->mpdus_expired));
268
	len += scnprintf(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n",
269
			 le32_to_cpu(htt_stats_buf->mpdus_seq_hw_retry));
270
	len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
271
			 le32_to_cpu(htt_stats_buf->ack_tlv_proc));
272
	len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n",
273
			 le32_to_cpu(htt_stats_buf->coex_abort_mpdu_cnt_valid));
274
	len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n",
275
			 le32_to_cpu(htt_stats_buf->coex_abort_mpdu_cnt));
276
	len += scnprintf(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n",
277
			 le32_to_cpu(htt_stats_buf->num_total_ppdus_tried_ota));
278
	len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n",
279
			 le32_to_cpu(htt_stats_buf->num_data_ppdus_tried_ota));
280
	len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n",
281
			 le32_to_cpu(htt_stats_buf->local_ctrl_mgmt_enqued));
282
	len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n",
283
			 le32_to_cpu(htt_stats_buf->local_ctrl_mgmt_freed));
284
	len += scnprintf(buf + len, buf_len - len, "local_data_enqued = %u\n",
285
			 le32_to_cpu(htt_stats_buf->local_data_enqued));
286
	len += scnprintf(buf + len, buf_len - len, "local_data_freed = %u\n",
287
			 le32_to_cpu(htt_stats_buf->local_data_freed));
288
	len += scnprintf(buf + len, buf_len - len, "mpdu_tried = %u\n",
289
			 le32_to_cpu(htt_stats_buf->mpdu_tried));
290
	len += scnprintf(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n",
291
			 le32_to_cpu(htt_stats_buf->isr_wait_seq_posted));
292
	len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n",
293
			 le32_to_cpu(htt_stats_buf->tx_active_dur_us_low));
294
	len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n",
295
			 le32_to_cpu(htt_stats_buf->tx_active_dur_us_high));
296
	len += scnprintf(buf + len, buf_len - len, "fes_offsets_err_cnt = %u\n\n",
297
			 le32_to_cpu(htt_stats_buf->fes_offsets_err_cnt));
298

299
	stats_req->buf_len = len;
300
}
301

302
static void
303
htt_print_tx_pdev_stats_urrn_tlv(const void *tag_buf,
304
				 u16 tag_len,
305
				 struct debug_htt_stats_req *stats_req)
306
{
307
	const struct ath12k_htt_tx_pdev_stats_urrn_tlv *htt_stats_buf = tag_buf;
308
	u8 *buf = stats_req->buf;
309
	u32 len = stats_req->buf_len;
310
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
311
	u16 num_elems = min_t(u16, (tag_len >> 2),
312
			      HTT_TX_PDEV_MAX_URRN_STATS);
313

314
	len += scnprintf(buf + len, buf_len - len,
315
			"HTT_TX_PDEV_STATS_URRN_TLV:\n");
316

317
	len += print_array_to_buf(buf, len, "urrn_stats", htt_stats_buf->urrn_stats,
318
				  num_elems, "\n\n");
319

320
	stats_req->buf_len = len;
321
}
322

323
static void
324
htt_print_tx_pdev_stats_flush_tlv(const void *tag_buf,
325
				  u16 tag_len,
326
				  struct debug_htt_stats_req *stats_req)
327
{
328
	const struct ath12k_htt_tx_pdev_stats_flush_tlv *htt_stats_buf = tag_buf;
329
	u8 *buf = stats_req->buf;
330
	u32 len = stats_req->buf_len;
331
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
332
	u16 num_elems = min_t(u16, (tag_len >> 2),
333
			      ATH12K_HTT_TX_PDEV_MAX_FLUSH_REASON_STATS);
334

335
	len += scnprintf(buf + len, buf_len - len,
336
			 "HTT_TX_PDEV_STATS_FLUSH_TLV:\n");
337

338
	len += print_array_to_buf(buf, len, "flush_errs", htt_stats_buf->flush_errs,
339
				  num_elems, "\n\n");
340

341
	stats_req->buf_len = len;
342
}
343

344
static void
345
htt_print_tx_pdev_stats_sifs_tlv(const void *tag_buf,
346
				 u16 tag_len,
347
				 struct debug_htt_stats_req *stats_req)
348
{
349
	const struct ath12k_htt_tx_pdev_stats_sifs_tlv *htt_stats_buf = tag_buf;
350
	u8 *buf = stats_req->buf;
351
	u32 len = stats_req->buf_len;
352
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
353
	u16 num_elems = min_t(u16, (tag_len >> 2),
354
			      ATH12K_HTT_TX_PDEV_MAX_SIFS_BURST_STATS);
355

356
	len += scnprintf(buf + len, buf_len - len,
357
			 "HTT_TX_PDEV_STATS_SIFS_TLV:\n");
358

359
	len += print_array_to_buf(buf, len, "sifs_status", htt_stats_buf->sifs_status,
360
				  num_elems, "\n\n");
361

362
	stats_req->buf_len = len;
363
}
364

365
static void
366
htt_print_tx_pdev_mu_ppdu_dist_stats_tlv(const void *tag_buf, u16 tag_len,
367
					 struct debug_htt_stats_req *stats_req)
368
{
369
	const struct ath12k_htt_tx_pdev_mu_ppdu_dist_stats_tlv *htt_stats_buf = tag_buf;
370
	char *mode;
371
	u8 j, hw_mode, i, str_buf_len;
372
	u8 *buf = stats_req->buf;
373
	u32 len = stats_req->buf_len;
374
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
375
	u32 stats_value;
376
	u8 max_ppdu = ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST;
377
	u8 max_sched = ATH12K_HTT_STATS_MAX_NUM_SCHED_STATUS;
378
	char str_buf[ATH12K_HTT_MAX_STRING_LEN];
379

380
	if (tag_len < sizeof(*htt_stats_buf))
381
		return;
382

383
	hw_mode = le32_to_cpu(htt_stats_buf->hw_mode);
384

385
	switch (hw_mode) {
386
	case ATH12K_HTT_STATS_HWMODE_AC:
387
		len += scnprintf(buf + len, buf_len - len,
388
				 "HTT_TX_PDEV_AC_MU_PPDU_DISTRIBUTION_STATS:\n");
389
		mode = "ac";
390
		break;
391
	case ATH12K_HTT_STATS_HWMODE_AX:
392
		len += scnprintf(buf + len, buf_len - len,
393
				 "HTT_TX_PDEV_AX_MU_PPDU_DISTRIBUTION_STATS:\n");
394
		mode = "ax";
395
		break;
396
	case ATH12K_HTT_STATS_HWMODE_BE:
397
		len += scnprintf(buf + len, buf_len - len,
398
				 "HTT_TX_PDEV_BE_MU_PPDU_DISTRIBUTION_STATS:\n");
399
		mode = "be";
400
		break;
401
	default:
402
		return;
403
	}
404

405
	for (i = 0; i < ATH12K_HTT_STATS_NUM_NR_BINS ; i++) {
406
		len += scnprintf(buf + len, buf_len - len,
407
				 "%s_mu_mimo_num_seq_posted_nr%u = %u\n", mode,
408
				 ((i + 1) * 4), htt_stats_buf->num_seq_posted[i]);
409
		str_buf_len = 0;
410
		memset(str_buf, 0x0, sizeof(str_buf));
411
		for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST ; j++) {
412
			stats_value = le32_to_cpu(htt_stats_buf->num_ppdu_posted_per_burst
413
						  [i * max_ppdu + 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_ppdu_posted_per_burst_nr%u = %s\n",
422
				 mode, ((i + 1) * 4), str_buf);
423
		str_buf_len = 0;
424
		memset(str_buf, 0x0, sizeof(str_buf));
425
		for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_MU_PPDU_PER_BURST ; j++) {
426
			stats_value = le32_to_cpu(htt_stats_buf->num_ppdu_cmpl_per_burst
427
						  [i * max_ppdu + j]);
428
			str_buf_len += scnprintf(&str_buf[str_buf_len],
429
						ATH12K_HTT_MAX_STRING_LEN - str_buf_len,
430
						" %u:%u,", j, stats_value);
431
		}
432
		/* To overwrite the last trailing comma */
433
		str_buf[str_buf_len - 1] = '\0';
434
		len += scnprintf(buf + len, buf_len - len,
435
				 "%s_mu_mimo_num_ppdu_completed_per_burst_nr%u = %s\n",
436
				 mode, ((i + 1) * 4), str_buf);
437
		str_buf_len = 0;
438
		memset(str_buf, 0x0, sizeof(str_buf));
439
		for (j = 0; j < ATH12K_HTT_STATS_MAX_NUM_SCHED_STATUS ; j++) {
440
			stats_value = le32_to_cpu(htt_stats_buf->num_seq_term_status
441
						  [i * max_sched + j]);
442
			str_buf_len += scnprintf(&str_buf[str_buf_len],
443
						ATH12K_HTT_MAX_STRING_LEN - str_buf_len,
444
						" %u:%u,", j, stats_value);
445
		}
446
		/* To overwrite the last trailing comma */
447
		str_buf[str_buf_len - 1] = '\0';
448
		len += scnprintf(buf + len, buf_len - len,
449
				 "%s_mu_mimo_num_seq_term_status_nr%u = %s\n\n",
450
				 mode, ((i + 1) * 4), str_buf);
451
	}
452

453
	stats_req->buf_len = len;
454
}
455

456
static void
457
htt_print_tx_pdev_stats_sifs_hist_tlv(const void *tag_buf,
458
				      u16 tag_len,
459
				      struct debug_htt_stats_req *stats_req)
460
{
461
	const struct ath12k_htt_tx_pdev_stats_sifs_hist_tlv *htt_stats_buf = tag_buf;
462
	u8 *buf = stats_req->buf;
463
	u32 len = stats_req->buf_len;
464
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
465
	u16 num_elems = min_t(u16, (tag_len >> 2),
466
			      ATH12K_HTT_TX_PDEV_MAX_SIFS_BURST_HIST_STATS);
467

468
	len += scnprintf(buf + len, buf_len - len,
469
			 "HTT_TX_PDEV_STATS_SIFS_HIST_TLV:\n");
470

471
	len += print_array_to_buf(buf, len, "sifs_hist_status",
472
				  htt_stats_buf->sifs_hist_status, num_elems, "\n\n");
473

474
	stats_req->buf_len = len;
475
}
476

477
static void
478
htt_print_pdev_ctrl_path_tx_stats_tlv(const void *tag_buf, u16 tag_len,
479
				      struct debug_htt_stats_req *stats_req)
480
{
481
	const struct ath12k_htt_pdev_ctrl_path_tx_stats_tlv *htt_stats_buf = tag_buf;
482
	u8 *buf = stats_req->buf;
483
	u32 len = stats_req->buf_len;
484
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
485

486
	if (len < sizeof(*htt_stats_buf))
487
		return;
488

489
	len += scnprintf(buf + len, buf_len - len,
490
			 "HTT_TX_PDEV_STATS_CTRL_PATH_TX_STATS:\n");
491
	len += print_array_to_buf(buf, len, "fw_tx_mgmt_subtype",
492
				 htt_stats_buf->fw_tx_mgmt_subtype,
493
				 ATH12K_HTT_STATS_SUBTYPE_MAX, "\n\n");
494

495
	stats_req->buf_len = len;
496
}
497

498
static void
499
ath12k_htt_print_stats_tx_sched_cmn_tlv(const void *tag_buf,
500
					u16 tag_len,
501
					struct debug_htt_stats_req *stats_req)
502
{
503
	const struct ath12k_htt_stats_tx_sched_cmn_tlv *htt_stats_buf = tag_buf;
504
	u8 *buf = stats_req->buf;
505
	u32 len = stats_req->buf_len;
506
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
507
	u32 mac_id_word;
508

509
	if (tag_len < sizeof(*htt_stats_buf))
510
		return;
511

512
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
513

514
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_TX_SCHED_CMN_TLV:\n");
515
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
516
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
517
	len += scnprintf(buf + len, buf_len - len, "current_timestamp = %u\n\n",
518
			 le32_to_cpu(htt_stats_buf->current_timestamp));
519

520
	stats_req->buf_len = len;
521
}
522

523
static void
524
ath12k_htt_print_tx_pdev_stats_sched_per_txq_tlv(const void *tag_buf,
525
						 u16 tag_len,
526
						 struct debug_htt_stats_req *stats_req)
527
{
528
	const struct ath12k_htt_tx_pdev_stats_sched_per_txq_tlv *htt_stats_buf = tag_buf;
529
	u8 *buf = stats_req->buf;
530
	u32 len = stats_req->buf_len;
531
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
532
	u32 mac_id_word;
533

534
	if (tag_len < sizeof(*htt_stats_buf))
535
		return;
536

537
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
538

539
	len += scnprintf(buf + len, buf_len - len,
540
			 "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:\n");
541
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
542
			u32_get_bits(mac_id_word,
543
				     ATH12K_HTT_TX_PDEV_STATS_SCHED_PER_TXQ_MAC_ID));
544
	len += scnprintf(buf + len, buf_len - len, "txq_id = %u\n",
545
			 u32_get_bits(mac_id_word,
546
				      ATH12K_HTT_TX_PDEV_STATS_SCHED_PER_TXQ_ID));
547
	len += scnprintf(buf + len, buf_len - len, "sched_policy = %u\n",
548
			 le32_to_cpu(htt_stats_buf->sched_policy));
549
	len += scnprintf(buf + len, buf_len - len,
550
			 "last_sched_cmd_posted_timestamp = %u\n",
551
			 le32_to_cpu(htt_stats_buf->last_sched_cmd_posted_timestamp));
552
	len += scnprintf(buf + len, buf_len - len,
553
			 "last_sched_cmd_compl_timestamp = %u\n",
554
			 le32_to_cpu(htt_stats_buf->last_sched_cmd_compl_timestamp));
555
	len += scnprintf(buf + len, buf_len - len, "sched_2_tac_lwm_count = %u\n",
556
			 le32_to_cpu(htt_stats_buf->sched_2_tac_lwm_count));
557
	len += scnprintf(buf + len, buf_len - len, "sched_2_tac_ring_full = %u\n",
558
			 le32_to_cpu(htt_stats_buf->sched_2_tac_ring_full));
559
	len += scnprintf(buf + len, buf_len - len, "sched_cmd_post_failure = %u\n",
560
			 le32_to_cpu(htt_stats_buf->sched_cmd_post_failure));
561
	len += scnprintf(buf + len, buf_len - len, "num_active_tids = %u\n",
562
			 le32_to_cpu(htt_stats_buf->num_active_tids));
563
	len += scnprintf(buf + len, buf_len - len, "num_ps_schedules = %u\n",
564
			 le32_to_cpu(htt_stats_buf->num_ps_schedules));
565
	len += scnprintf(buf + len, buf_len - len, "sched_cmds_pending = %u\n",
566
			 le32_to_cpu(htt_stats_buf->sched_cmds_pending));
567
	len += scnprintf(buf + len, buf_len - len, "num_tid_register = %u\n",
568
			 le32_to_cpu(htt_stats_buf->num_tid_register));
569
	len += scnprintf(buf + len, buf_len - len, "num_tid_unregister = %u\n",
570
			 le32_to_cpu(htt_stats_buf->num_tid_unregister));
571
	len += scnprintf(buf + len, buf_len - len, "num_qstats_queried = %u\n",
572
			 le32_to_cpu(htt_stats_buf->num_qstats_queried));
573
	len += scnprintf(buf + len, buf_len - len, "qstats_update_pending = %u\n",
574
			 le32_to_cpu(htt_stats_buf->qstats_update_pending));
575
	len += scnprintf(buf + len, buf_len - len, "last_qstats_query_timestamp = %u\n",
576
			 le32_to_cpu(htt_stats_buf->last_qstats_query_timestamp));
577
	len += scnprintf(buf + len, buf_len - len, "num_tqm_cmdq_full = %u\n",
578
			 le32_to_cpu(htt_stats_buf->num_tqm_cmdq_full));
579
	len += scnprintf(buf + len, buf_len - len, "num_de_sched_algo_trigger = %u\n",
580
			 le32_to_cpu(htt_stats_buf->num_de_sched_algo_trigger));
581
	len += scnprintf(buf + len, buf_len - len, "num_rt_sched_algo_trigger = %u\n",
582
			 le32_to_cpu(htt_stats_buf->num_rt_sched_algo_trigger));
583
	len += scnprintf(buf + len, buf_len - len, "num_tqm_sched_algo_trigger = %u\n",
584
			 le32_to_cpu(htt_stats_buf->num_tqm_sched_algo_trigger));
585
	len += scnprintf(buf + len, buf_len - len, "notify_sched = %u\n",
586
			 le32_to_cpu(htt_stats_buf->notify_sched));
587
	len += scnprintf(buf + len, buf_len - len, "dur_based_sendn_term = %u\n",
588
			 le32_to_cpu(htt_stats_buf->dur_based_sendn_term));
589
	len += scnprintf(buf + len, buf_len - len, "su_notify2_sched = %u\n",
590
			 le32_to_cpu(htt_stats_buf->su_notify2_sched));
591
	len += scnprintf(buf + len, buf_len - len, "su_optimal_queued_msdus_sched = %u\n",
592
			 le32_to_cpu(htt_stats_buf->su_optimal_queued_msdus_sched));
593
	len += scnprintf(buf + len, buf_len - len, "su_delay_timeout_sched = %u\n",
594
			 le32_to_cpu(htt_stats_buf->su_delay_timeout_sched));
595
	len += scnprintf(buf + len, buf_len - len, "su_min_txtime_sched_delay = %u\n",
596
			 le32_to_cpu(htt_stats_buf->su_min_txtime_sched_delay));
597
	len += scnprintf(buf + len, buf_len - len, "su_no_delay = %u\n",
598
			 le32_to_cpu(htt_stats_buf->su_no_delay));
599
	len += scnprintf(buf + len, buf_len - len, "num_supercycles = %u\n",
600
			 le32_to_cpu(htt_stats_buf->num_supercycles));
601
	len += scnprintf(buf + len, buf_len - len, "num_subcycles_with_sort = %u\n",
602
			 le32_to_cpu(htt_stats_buf->num_subcycles_with_sort));
603
	len += scnprintf(buf + len, buf_len - len, "num_subcycles_no_sort = %u\n\n",
604
			 le32_to_cpu(htt_stats_buf->num_subcycles_no_sort));
605

606
	stats_req->buf_len = len;
607
}
608

609
static void
610
ath12k_htt_print_sched_txq_cmd_posted_tlv(const void *tag_buf,
611
					  u16 tag_len,
612
					  struct debug_htt_stats_req *stats_req)
613
{
614
	const struct ath12k_htt_sched_txq_cmd_posted_tlv *htt_stats_buf = tag_buf;
615
	u8 *buf = stats_req->buf;
616
	u32 len = stats_req->buf_len;
617
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
618
	u16 num_elements = tag_len >> 2;
619

620
	len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV:\n");
621
	len += print_array_to_buf(buf, len, "sched_cmd_posted",
622
				  htt_stats_buf->sched_cmd_posted, num_elements, "\n\n");
623

624
	stats_req->buf_len = len;
625
}
626

627
static void
628
ath12k_htt_print_sched_txq_cmd_reaped_tlv(const void *tag_buf,
629
					  u16 tag_len,
630
					  struct debug_htt_stats_req *stats_req)
631
{
632
	const struct ath12k_htt_sched_txq_cmd_reaped_tlv *htt_stats_buf = tag_buf;
633
	u8 *buf = stats_req->buf;
634
	u32 len = stats_req->buf_len;
635
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
636
	u16 num_elements = tag_len >> 2;
637

638
	len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_REAPED_TLV:\n");
639
	len += print_array_to_buf(buf, len, "sched_cmd_reaped",
640
				  htt_stats_buf->sched_cmd_reaped, num_elements, "\n\n");
641

642
	stats_req->buf_len = len;
643
}
644

645
static void
646
ath12k_htt_print_sched_txq_sched_order_su_tlv(const void *tag_buf,
647
					      u16 tag_len,
648
					      struct debug_htt_stats_req *stats_req)
649
{
650
	const struct ath12k_htt_sched_txq_sched_order_su_tlv *htt_stats_buf = tag_buf;
651
	u8 *buf = stats_req->buf;
652
	u32 len = stats_req->buf_len;
653
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
654
	u32 sched_order_su_num_entries = min_t(u32, (tag_len >> 2),
655
					       ATH12K_HTT_TX_PDEV_NUM_SCHED_ORDER_LOG);
656

657
	len += scnprintf(buf + len, buf_len - len,
658
			 "HTT_SCHED_TXQ_SCHED_ORDER_SU_TLV:\n");
659
	len += print_array_to_buf(buf, len, "sched_order_su",
660
				  htt_stats_buf->sched_order_su,
661
				  sched_order_su_num_entries, "\n\n");
662

663
	stats_req->buf_len = len;
664
}
665

666
static void
667
ath12k_htt_print_sched_txq_sched_ineligibility_tlv(const void *tag_buf,
668
						   u16 tag_len,
669
						   struct debug_htt_stats_req *stats_req)
670
{
671
	const struct ath12k_htt_sched_txq_sched_ineligibility_tlv *htt_stats_buf =
672
		     tag_buf;
673
	u8 *buf = stats_req->buf;
674
	u32 len = stats_req->buf_len;
675
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
676
	u32 sched_ineligibility_num_entries = tag_len >> 2;
677

678
	len += scnprintf(buf + len, buf_len - len,
679
			 "HTT_SCHED_TXQ_SCHED_INELIGIBILITY:\n");
680
	len += print_array_to_buf(buf, len, "sched_ineligibility",
681
				  htt_stats_buf->sched_ineligibility,
682
				  sched_ineligibility_num_entries, "\n\n");
683

684
	stats_req->buf_len = len;
685
}
686

687
static void
688
ath12k_htt_print_sched_txq_supercycle_trigger_tlv(const void *tag_buf,
689
						  u16 tag_len,
690
						  struct debug_htt_stats_req *stats_req)
691
{
692
	const struct ath12k_htt_sched_txq_supercycle_triggers_tlv *htt_stats_buf =
693
		     tag_buf;
694
	u8 *buf = stats_req->buf;
695
	u32 len = stats_req->buf_len;
696
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
697
	u16 num_elems = min_t(u16, (tag_len >> 2),
698
			      ATH12K_HTT_SCHED_SUPERCYCLE_TRIGGER_MAX);
699

700
	len += scnprintf(buf + len, buf_len - len,
701
			 "HTT_SCHED_TXQ_SUPERCYCLE_TRIGGER:\n");
702
	len += print_array_to_buf(buf, len, "supercycle_triggers",
703
				  htt_stats_buf->supercycle_triggers, num_elems, "\n\n");
704

705
	stats_req->buf_len = len;
706
}
707

708
static void
709
ath12k_htt_print_hw_stats_pdev_errs_tlv(const void *tag_buf, u16 tag_len,
710
					struct debug_htt_stats_req *stats_req)
711
{
712
	const struct ath12k_htt_hw_stats_pdev_errs_tlv *htt_buf = tag_buf;
713
	u8 *buf = stats_req->buf;
714
	u32 len = stats_req->buf_len;
715
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
716
	u32 mac_id_word;
717

718
	if (tag_len < sizeof(*htt_buf))
719
		return;
720

721
	mac_id_word = le32_to_cpu(htt_buf->mac_id__word);
722

723
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n");
724
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
725
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
726
	len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n",
727
			 le32_to_cpu(htt_buf->tx_abort));
728
	len += scnprintf(buf + len, buf_len - len, "tx_abort_fail_count = %u\n",
729
			 le32_to_cpu(htt_buf->tx_abort_fail_count));
730
	len += scnprintf(buf + len, buf_len - len, "rx_abort = %u\n",
731
			 le32_to_cpu(htt_buf->rx_abort));
732
	len += scnprintf(buf + len, buf_len - len, "rx_abort_fail_count = %u\n",
733
			 le32_to_cpu(htt_buf->rx_abort_fail_count));
734
	len += scnprintf(buf + len, buf_len - len, "rx_flush_cnt = %u\n",
735
			 le32_to_cpu(htt_buf->rx_flush_cnt));
736
	len += scnprintf(buf + len, buf_len - len, "warm_reset = %u\n",
737
			 le32_to_cpu(htt_buf->warm_reset));
738
	len += scnprintf(buf + len, buf_len - len, "cold_reset = %u\n",
739
			 le32_to_cpu(htt_buf->cold_reset));
740
	len += scnprintf(buf + len, buf_len - len, "mac_cold_reset_restore_cal = %u\n",
741
			 le32_to_cpu(htt_buf->mac_cold_reset_restore_cal));
742
	len += scnprintf(buf + len, buf_len - len, "mac_cold_reset = %u\n",
743
			 le32_to_cpu(htt_buf->mac_cold_reset));
744
	len += scnprintf(buf + len, buf_len - len, "mac_warm_reset = %u\n",
745
			 le32_to_cpu(htt_buf->mac_warm_reset));
746
	len += scnprintf(buf + len, buf_len - len, "mac_only_reset = %u\n",
747
			 le32_to_cpu(htt_buf->mac_only_reset));
748
	len += scnprintf(buf + len, buf_len - len, "phy_warm_reset = %u\n",
749
			 le32_to_cpu(htt_buf->phy_warm_reset));
750
	len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_ucode_trig = %u\n",
751
			 le32_to_cpu(htt_buf->phy_warm_reset_ucode_trig));
752
	len += scnprintf(buf + len, buf_len - len, "mac_warm_reset_restore_cal = %u\n",
753
			 le32_to_cpu(htt_buf->mac_warm_reset_restore_cal));
754
	len += scnprintf(buf + len, buf_len - len, "mac_sfm_reset = %u\n",
755
			 le32_to_cpu(htt_buf->mac_sfm_reset));
756
	len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_m3_ssr = %u\n",
757
			 le32_to_cpu(htt_buf->phy_warm_reset_m3_ssr));
758
	len += scnprintf(buf + len, buf_len - len, "fw_rx_rings_reset = %u\n",
759
			 le32_to_cpu(htt_buf->fw_rx_rings_reset));
760
	len += scnprintf(buf + len, buf_len - len, "tx_flush = %u\n",
761
			 le32_to_cpu(htt_buf->tx_flush));
762
	len += scnprintf(buf + len, buf_len - len, "tx_glb_reset = %u\n",
763
			 le32_to_cpu(htt_buf->tx_glb_reset));
764
	len += scnprintf(buf + len, buf_len - len, "tx_txq_reset = %u\n",
765
			 le32_to_cpu(htt_buf->tx_txq_reset));
766
	len += scnprintf(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n",
767
			 le32_to_cpu(htt_buf->rx_timeout_reset));
768

769
	len += scnprintf(buf + len, buf_len - len, "PDEV_PHY_WARM_RESET_REASONS:\n");
770
	len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_reason_phy_m3 = %u\n",
771
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_phy_m3));
772
	len += scnprintf(buf + len, buf_len - len,
773
			 "phy_warm_reset_reason_tx_hw_stuck = %u\n",
774
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_hw_stuck));
775
	len += scnprintf(buf + len, buf_len - len,
776
			 "phy_warm_reset_reason_num_cca_rx_frame_stuck = %u\n",
777
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_num_rx_frame_stuck));
778
	len += scnprintf(buf + len, buf_len - len,
779
			 "phy_warm_reset_reason_wal_rx_recovery_rst_rx_busy = %u\n",
780
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_wal_rx_rec_rx_busy));
781
	len += scnprintf(buf + len, buf_len - len,
782
			 "phy_warm_reset_reason_wal_rx_recovery_rst_mac_hang = %u\n",
783
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_wal_rx_rec_mac_hng));
784
	len += scnprintf(buf + len, buf_len - len,
785
			 "phy_warm_reset_reason_mac_reset_converted_phy_reset = %u\n",
786
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_mac_conv_phy_reset));
787
	len += scnprintf(buf + len, buf_len - len,
788
			 "phy_warm_reset_reason_tx_lifetime_expiry_cca_stuck = %u\n",
789
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_exp_cca_stuck));
790
	len += scnprintf(buf + len, buf_len - len,
791
			 "phy_warm_reset_reason_tx_consecutive_flush9_war = %u\n",
792
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_consec_flsh_war));
793
	len += scnprintf(buf + len, buf_len - len,
794
			 "phy_warm_reset_reason_tx_hwsch_reset_war = %u\n",
795
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_tx_hwsch_reset_war));
796
	len += scnprintf(buf + len, buf_len - len,
797
			 "phy_warm_reset_reason_hwsch_wdog_or_cca_wdog_war = %u\n\n",
798
			 le32_to_cpu(htt_buf->phy_warm_reset_reason_hwsch_cca_wdog_war));
799

800
	len += scnprintf(buf + len, buf_len - len, "WAL_RX_RECOVERY_STATS:\n");
801
	len += scnprintf(buf + len, buf_len - len,
802
			 "wal_rx_recovery_rst_mac_hang_count = %u\n",
803
			 le32_to_cpu(htt_buf->wal_rx_recovery_rst_mac_hang_cnt));
804
	len += scnprintf(buf + len, buf_len - len,
805
			 "wal_rx_recovery_rst_known_sig_count = %u\n",
806
			 le32_to_cpu(htt_buf->wal_rx_recovery_rst_known_sig_cnt));
807
	len += scnprintf(buf + len, buf_len - len,
808
			 "wal_rx_recovery_rst_no_rx_count = %u\n",
809
			 le32_to_cpu(htt_buf->wal_rx_recovery_rst_no_rx_cnt));
810
	len += scnprintf(buf + len, buf_len - len,
811
			 "wal_rx_recovery_rst_no_rx_consecutive_count = %u\n",
812
			 le32_to_cpu(htt_buf->wal_rx_recovery_rst_no_rx_consec_cnt));
813
	len += scnprintf(buf + len, buf_len - len,
814
			 "wal_rx_recovery_rst_rx_busy_count = %u\n",
815
			 le32_to_cpu(htt_buf->wal_rx_recovery_rst_rx_busy_cnt));
816
	len += scnprintf(buf + len, buf_len - len,
817
			 "wal_rx_recovery_rst_phy_mac_hang_count = %u\n\n",
818
			 le32_to_cpu(htt_buf->wal_rx_recovery_rst_phy_mac_hang_cnt));
819

820
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_DEST_DRAIN_STATS:\n");
821
	len += scnprintf(buf + len, buf_len - len,
822
			 "rx_dest_drain_rx_descs_leak_prevention_done = %u\n",
823
			 le32_to_cpu(htt_buf->rx_dest_drain_rx_descs_leak_prevented));
824
	len += scnprintf(buf + len, buf_len - len,
825
			 "rx_dest_drain_rx_descs_saved_cnt = %u\n",
826
			 le32_to_cpu(htt_buf->rx_dest_drain_rx_descs_saved_cnt));
827
	len += scnprintf(buf + len, buf_len - len,
828
			 "rx_dest_drain_rxdma2reo_leak_detected = %u\n",
829
			 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2reo_leak_detected));
830
	len += scnprintf(buf + len, buf_len - len,
831
			 "rx_dest_drain_rxdma2fw_leak_detected = %u\n",
832
			 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2fw_leak_detected));
833
	len += scnprintf(buf + len, buf_len - len,
834
			 "rx_dest_drain_rxdma2wbm_leak_detected = %u\n",
835
			 le32_to_cpu(htt_buf->rx_dest_drain_rxdma2wbm_leak_detected));
836
	len += scnprintf(buf + len, buf_len - len,
837
			 "rx_dest_drain_rxdma1_2sw_leak_detected = %u\n",
838
			 le32_to_cpu(htt_buf->rx_dest_drain_rxdma1_2sw_leak_detected));
839
	len += scnprintf(buf + len, buf_len - len,
840
			 "rx_dest_drain_rx_drain_ok_mac_idle = %u\n",
841
			 le32_to_cpu(htt_buf->rx_dest_drain_rx_drain_ok_mac_idle));
842
	len += scnprintf(buf + len, buf_len - len,
843
			 "rx_dest_drain_ok_mac_not_idle = %u\n",
844
			 le32_to_cpu(htt_buf->rx_dest_drain_ok_mac_not_idle));
845
	len += scnprintf(buf + len, buf_len - len,
846
			 "rx_dest_drain_prerequisite_invld = %u\n",
847
			 le32_to_cpu(htt_buf->rx_dest_drain_prerequisite_invld));
848
	len += scnprintf(buf + len, buf_len - len,
849
			 "rx_dest_drain_skip_for_non_lmac_reset = %u\n",
850
			 le32_to_cpu(htt_buf->rx_dest_drain_skip_non_lmac_reset));
851
	len += scnprintf(buf + len, buf_len - len,
852
			 "rx_dest_drain_hw_fifo_not_empty_post_drain_wait = %u\n\n",
853
			 le32_to_cpu(htt_buf->rx_dest_drain_hw_fifo_notempty_post_wait));
854

855
	stats_req->buf_len = len;
856
}
857

858
static void
859
ath12k_htt_print_hw_stats_intr_misc_tlv(const void *tag_buf, u16 tag_len,
860
					struct debug_htt_stats_req *stats_req)
861
{
862
	const struct ath12k_htt_hw_stats_intr_misc_tlv *htt_stats_buf = tag_buf;
863
	u8 *buf = stats_req->buf;
864
	u32 len = stats_req->buf_len;
865
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
866

867
	if (tag_len < sizeof(*htt_stats_buf))
868
		return;
869

870
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_INTR_MISC_TLV:\n");
871
	len += scnprintf(buf + len, buf_len - len, "hw_intr_name = %s\n",
872
			 htt_stats_buf->hw_intr_name);
873
	len += scnprintf(buf + len, buf_len - len, "mask = %u\n",
874
			 le32_to_cpu(htt_stats_buf->mask));
875
	len += scnprintf(buf + len, buf_len - len, "count = %u\n\n",
876
			 le32_to_cpu(htt_stats_buf->count));
877

878
	stats_req->buf_len = len;
879
}
880

881
static void
882
ath12k_htt_print_hw_stats_whal_tx_tlv(const void *tag_buf, u16 tag_len,
883
				      struct debug_htt_stats_req *stats_req)
884
{
885
	const struct ath12k_htt_hw_stats_whal_tx_tlv *htt_stats_buf = tag_buf;
886
	u8 *buf = stats_req->buf;
887
	u32 len = stats_req->buf_len;
888
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
889
	u32 mac_id_word;
890

891
	if (tag_len < sizeof(*htt_stats_buf))
892
		return;
893

894
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
895

896
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WHAL_TX_TLV:\n");
897
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
898
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
899
	len += scnprintf(buf + len, buf_len - len, "last_unpause_ppdu_id = %u\n",
900
			 le32_to_cpu(htt_stats_buf->last_unpause_ppdu_id));
901
	len += scnprintf(buf + len, buf_len - len, "hwsch_unpause_wait_tqm_write = %u\n",
902
			 le32_to_cpu(htt_stats_buf->hwsch_unpause_wait_tqm_write));
903
	len += scnprintf(buf + len, buf_len - len, "hwsch_dummy_tlv_skipped = %u\n",
904
			 le32_to_cpu(htt_stats_buf->hwsch_dummy_tlv_skipped));
905
	len += scnprintf(buf + len, buf_len - len,
906
			 "hwsch_misaligned_offset_received = %u\n",
907
			 le32_to_cpu(htt_stats_buf->hwsch_misaligned_offset_received));
908
	len += scnprintf(buf + len, buf_len - len, "hwsch_reset_count = %u\n",
909
			 le32_to_cpu(htt_stats_buf->hwsch_reset_count));
910
	len += scnprintf(buf + len, buf_len - len, "hwsch_dev_reset_war = %u\n",
911
			 le32_to_cpu(htt_stats_buf->hwsch_dev_reset_war));
912
	len += scnprintf(buf + len, buf_len - len, "hwsch_delayed_pause = %u\n",
913
			 le32_to_cpu(htt_stats_buf->hwsch_delayed_pause));
914
	len += scnprintf(buf + len, buf_len - len, "hwsch_long_delayed_pause = %u\n",
915
			 le32_to_cpu(htt_stats_buf->hwsch_long_delayed_pause));
916
	len += scnprintf(buf + len, buf_len - len, "sch_rx_ppdu_no_response = %u\n",
917
			 le32_to_cpu(htt_stats_buf->sch_rx_ppdu_no_response));
918
	len += scnprintf(buf + len, buf_len - len, "sch_selfgen_response = %u\n",
919
			 le32_to_cpu(htt_stats_buf->sch_selfgen_response));
920
	len += scnprintf(buf + len, buf_len - len, "sch_rx_sifs_resp_trigger= %u\n\n",
921
			 le32_to_cpu(htt_stats_buf->sch_rx_sifs_resp_trigger));
922

923
	stats_req->buf_len = len;
924
}
925

926
static void
927
ath12k_htt_print_hw_war_tlv(const void *tag_buf, u16 tag_len,
928
			    struct debug_htt_stats_req *stats_req)
929
{
930
	const struct ath12k_htt_hw_war_stats_tlv *htt_stats_buf = tag_buf;
931
	u8 *buf = stats_req->buf;
932
	u32 len = stats_req->buf_len;
933
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
934
	u16 fixed_len, array_len;
935
	u8 i, array_words;
936
	u32 mac_id;
937

938
	if (tag_len < sizeof(*htt_stats_buf))
939
		return;
940

941
	mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word);
942
	fixed_len = sizeof(*htt_stats_buf);
943
	array_len = tag_len - fixed_len;
944
	array_words = array_len >> 2;
945

946
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_WAR_STATS_TLV:\n");
947
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
948
			 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID));
949

950
	for (i = 0; i < array_words; i++) {
951
		len += scnprintf(buf + len, buf_len - len, "hw_war %u = %u\n\n",
952
				 i, le32_to_cpu(htt_stats_buf->hw_wars[i]));
953
	}
954

955
	stats_req->buf_len = len;
956
}
957

958
static void
959
ath12k_htt_print_tx_tqm_cmn_stats_tlv(const void *tag_buf, u16 tag_len,
960
				      struct debug_htt_stats_req *stats_req)
961
{
962
	const struct ath12k_htt_tx_tqm_cmn_stats_tlv *htt_stats_buf = tag_buf;
963
	u8 *buf = stats_req->buf;
964
	u32 len = stats_req->buf_len;
965
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
966
	u32 mac_id_word;
967

968
	if (tag_len < sizeof(*htt_stats_buf))
969
		return;
970

971
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
972

973
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMN_STATS_TLV:\n");
974
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
975
			u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
976
	len += scnprintf(buf + len, buf_len - len, "max_cmdq_id = %u\n",
977
			 le32_to_cpu(htt_stats_buf->max_cmdq_id));
978
	len += scnprintf(buf + len, buf_len - len, "list_mpdu_cnt_hist_intvl = %u\n",
979
			 le32_to_cpu(htt_stats_buf->list_mpdu_cnt_hist_intvl));
980
	len += scnprintf(buf + len, buf_len - len, "add_msdu = %u\n",
981
			 le32_to_cpu(htt_stats_buf->add_msdu));
982
	len += scnprintf(buf + len, buf_len - len, "q_empty = %u\n",
983
			 le32_to_cpu(htt_stats_buf->q_empty));
984
	len += scnprintf(buf + len, buf_len - len, "q_not_empty = %u\n",
985
			 le32_to_cpu(htt_stats_buf->q_not_empty));
986
	len += scnprintf(buf + len, buf_len - len, "drop_notification = %u\n",
987
			 le32_to_cpu(htt_stats_buf->drop_notification));
988
	len += scnprintf(buf + len, buf_len - len, "desc_threshold = %u\n",
989
			 le32_to_cpu(htt_stats_buf->desc_threshold));
990
	len += scnprintf(buf + len, buf_len - len, "hwsch_tqm_invalid_status = %u\n",
991
			 le32_to_cpu(htt_stats_buf->hwsch_tqm_invalid_status));
992
	len += scnprintf(buf + len, buf_len - len, "missed_tqm_gen_mpdus = %u\n",
993
			 le32_to_cpu(htt_stats_buf->missed_tqm_gen_mpdus));
994
	len += scnprintf(buf + len, buf_len - len,
995
			 "total_msduq_timestamp_updates = %u\n",
996
			 le32_to_cpu(htt_stats_buf->msduq_timestamp_updates));
997
	len += scnprintf(buf + len, buf_len - len,
998
			 "total_msduq_timestamp_updates_by_get_mpdu_head_info_cmd = %u\n",
999
			 le32_to_cpu(htt_stats_buf->msduq_updates_mpdu_head_info_cmd));
1000
	len += scnprintf(buf + len, buf_len - len,
1001
			 "total_msduq_timestamp_updates_by_emp_to_nonemp_status = %u\n",
1002
			 le32_to_cpu(htt_stats_buf->msduq_updates_emp_to_nonemp_status));
1003
	len += scnprintf(buf + len, buf_len - len,
1004
			 "total_get_mpdu_head_info_cmds_by_sched_algo_la_query = %u\n",
1005
			 le32_to_cpu(htt_stats_buf->get_mpdu_head_info_cmds_by_query));
1006
	len += scnprintf(buf + len, buf_len - len,
1007
			 "total_get_mpdu_head_info_cmds_by_tac = %u\n",
1008
			 le32_to_cpu(htt_stats_buf->get_mpdu_head_info_cmds_by_tac));
1009
	len += scnprintf(buf + len, buf_len - len,
1010
			 "total_gen_mpdu_cmds_by_sched_algo_la_query = %u\n",
1011
			 le32_to_cpu(htt_stats_buf->gen_mpdu_cmds_by_query));
1012
	len += scnprintf(buf + len, buf_len - len, "active_tqm_tids = %u\n",
1013
			 le32_to_cpu(htt_stats_buf->tqm_active_tids));
1014
	len += scnprintf(buf + len, buf_len - len, "inactive_tqm_tids = %u\n",
1015
			 le32_to_cpu(htt_stats_buf->tqm_inactive_tids));
1016
	len += scnprintf(buf + len, buf_len - len, "tqm_active_msduq_flows = %u\n",
1017
			 le32_to_cpu(htt_stats_buf->tqm_active_msduq_flows));
1018
	len += scnprintf(buf + len, buf_len - len, "hi_prio_q_not_empty = %u\n\n",
1019
			 le32_to_cpu(htt_stats_buf->high_prio_q_not_empty));
1020

1021
	stats_req->buf_len = len;
1022
}
1023

1024
static void
1025
ath12k_htt_print_tx_tqm_error_stats_tlv(const void *tag_buf, u16 tag_len,
1026
					struct debug_htt_stats_req *stats_req)
1027
{
1028
	const struct ath12k_htt_tx_tqm_error_stats_tlv *htt_stats_buf = tag_buf;
1029
	u8 *buf = stats_req->buf;
1030
	u32 len = stats_req->buf_len;
1031
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1032

1033
	if (tag_len < sizeof(*htt_stats_buf))
1034
		return;
1035

1036
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_ERROR_STATS_TLV:\n");
1037
	len += scnprintf(buf + len, buf_len - len, "q_empty_failure = %u\n",
1038
			 le32_to_cpu(htt_stats_buf->q_empty_failure));
1039
	len += scnprintf(buf + len, buf_len - len, "q_not_empty_failure = %u\n",
1040
			 le32_to_cpu(htt_stats_buf->q_not_empty_failure));
1041
	len += scnprintf(buf + len, buf_len - len, "add_msdu_failure = %u\n\n",
1042
			 le32_to_cpu(htt_stats_buf->add_msdu_failure));
1043

1044
	len += scnprintf(buf + len, buf_len - len, "TQM_ERROR_RESET_STATS:\n");
1045
	len += scnprintf(buf + len, buf_len - len, "tqm_cache_ctl_err = %u\n",
1046
			 le32_to_cpu(htt_stats_buf->tqm_cache_ctl_err));
1047
	len += scnprintf(buf + len, buf_len - len, "tqm_soft_reset = %u\n",
1048
			 le32_to_cpu(htt_stats_buf->tqm_soft_reset));
1049
	len += scnprintf(buf + len, buf_len - len,
1050
			 "tqm_reset_total_num_in_use_link_descs = %u\n",
1051
			 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_link_descs));
1052
	len += scnprintf(buf + len, buf_len - len,
1053
			 "tqm_reset_worst_case_num_lost_link_descs = %u\n",
1054
			 le32_to_cpu(htt_stats_buf->tqm_reset_num_lost_link_descs));
1055
	len += scnprintf(buf + len, buf_len - len,
1056
			 "tqm_reset_worst_case_num_lost_host_tx_bufs_count = %u\n",
1057
			 le32_to_cpu(htt_stats_buf->tqm_reset_num_lost_host_tx_buf_cnt));
1058
	len += scnprintf(buf + len, buf_len - len,
1059
			 "tqm_reset_num_in_use_link_descs_internal_tqm = %u\n",
1060
			 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_internal_tqm));
1061
	len += scnprintf(buf + len, buf_len - len,
1062
			 "tqm_reset_num_in_use_link_descs_wbm_idle_link_ring = %u\n",
1063
			 le32_to_cpu(htt_stats_buf->tqm_reset_num_in_use_idle_link_rng));
1064
	len += scnprintf(buf + len, buf_len - len,
1065
			 "tqm_reset_time_to_tqm_hang_delta_ms = %u\n",
1066
			 le32_to_cpu(htt_stats_buf->tqm_reset_time_to_tqm_hang_delta_ms));
1067
	len += scnprintf(buf + len, buf_len - len, "tqm_reset_recovery_time_ms = %u\n",
1068
			 le32_to_cpu(htt_stats_buf->tqm_reset_recovery_time_ms));
1069
	len += scnprintf(buf + len, buf_len - len, "tqm_reset_num_peers_hdl = %u\n",
1070
			 le32_to_cpu(htt_stats_buf->tqm_reset_num_peers_hdl));
1071
	len += scnprintf(buf + len, buf_len - len,
1072
			 "tqm_reset_cumm_dirty_hw_mpduq_proc_cnt = %u\n",
1073
			 le32_to_cpu(htt_stats_buf->tqm_reset_cumm_dirty_hw_mpduq_cnt));
1074
	len += scnprintf(buf + len, buf_len - len,
1075
			 "tqm_reset_cumm_dirty_hw_msduq_proc = %u\n",
1076
			 le32_to_cpu(htt_stats_buf->tqm_reset_cumm_dirty_hw_msduq_proc));
1077
	len += scnprintf(buf + len, buf_len - len,
1078
			 "tqm_reset_flush_cache_cmd_su_cnt = %u\n",
1079
			 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_su_cnt));
1080
	len += scnprintf(buf + len, buf_len - len,
1081
			 "tqm_reset_flush_cache_cmd_other_cnt = %u\n",
1082
			 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_other_cnt));
1083
	len += scnprintf(buf + len, buf_len - len,
1084
			 "tqm_reset_flush_cache_cmd_trig_type = %u\n",
1085
			 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_trig_type));
1086
	len += scnprintf(buf + len, buf_len - len,
1087
			 "tqm_reset_flush_cache_cmd_trig_cfg = %u\n",
1088
			 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cache_cmd_trig_cfg));
1089
	len += scnprintf(buf + len, buf_len - len,
1090
			 "tqm_reset_flush_cache_cmd_skip_cmd_status_null = %u\n\n",
1091
			 le32_to_cpu(htt_stats_buf->tqm_reset_flush_cmd_skp_status_null));
1092

1093
	stats_req->buf_len = len;
1094
}
1095

1096
static void
1097
ath12k_htt_print_tx_tqm_gen_mpdu_stats_tlv(const void *tag_buf, u16 tag_len,
1098
					   struct debug_htt_stats_req *stats_req)
1099
{
1100
	const struct ath12k_htt_tx_tqm_gen_mpdu_stats_tlv *htt_stats_buf = tag_buf;
1101
	u8 *buf = stats_req->buf;
1102
	u32 len = stats_req->buf_len;
1103
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1104
	u16 num_elements = tag_len >> 2;
1105

1106
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_GEN_MPDU_STATS_TLV:\n");
1107
	len += print_array_to_buf(buf, len, "gen_mpdu_end_reason",
1108
				  htt_stats_buf->gen_mpdu_end_reason, num_elements,
1109
				  "\n\n");
1110

1111
	stats_req->buf_len = len;
1112
}
1113

1114
static void
1115
ath12k_htt_print_tx_tqm_list_mpdu_stats_tlv(const void *tag_buf, u16 tag_len,
1116
					    struct debug_htt_stats_req *stats_req)
1117
{
1118
	const struct ath12k_htt_tx_tqm_list_mpdu_stats_tlv *htt_stats_buf = tag_buf;
1119
	u8 *buf = stats_req->buf;
1120
	u32 len = stats_req->buf_len;
1121
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1122
	u16 num_elems = min_t(u16, (tag_len >> 2),
1123
			      ATH12K_HTT_TX_TQM_MAX_LIST_MPDU_END_REASON);
1124

1125
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_STATS_TLV:\n");
1126
	len += print_array_to_buf(buf, len, "list_mpdu_end_reason",
1127
				  htt_stats_buf->list_mpdu_end_reason, num_elems, "\n\n");
1128

1129
	stats_req->buf_len = len;
1130
}
1131

1132
static void
1133
ath12k_htt_print_tx_tqm_list_mpdu_cnt_tlv(const void *tag_buf, u16 tag_len,
1134
					  struct debug_htt_stats_req *stats_req)
1135
{
1136
	const struct ath12k_htt_tx_tqm_list_mpdu_cnt_tlv *htt_stats_buf = tag_buf;
1137
	u8 *buf = stats_req->buf;
1138
	u32 len = stats_req->buf_len;
1139
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1140
	u16 num_elems = min_t(u16, (tag_len >> 2),
1141
			      ATH12K_HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS);
1142

1143
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:\n");
1144
	len += print_array_to_buf(buf, len, "list_mpdu_cnt_hist",
1145
				  htt_stats_buf->list_mpdu_cnt_hist, num_elems, "\n\n");
1146

1147
	stats_req->buf_len = len;
1148
}
1149

1150
static void
1151
ath12k_htt_print_tx_tqm_pdev_stats_tlv(const void *tag_buf, u16 tag_len,
1152
				       struct debug_htt_stats_req *stats_req)
1153
{
1154
	const struct ath12k_htt_tx_tqm_pdev_stats_tlv *htt_stats_buf = tag_buf;
1155
	u8 *buf = stats_req->buf;
1156
	u32 len = stats_req->buf_len;
1157
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1158

1159
	if (tag_len < sizeof(*htt_stats_buf))
1160
		return;
1161

1162
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_PDEV_STATS_TLV_V:\n");
1163
	len += scnprintf(buf + len, buf_len - len, "msdu_count = %u\n",
1164
			 le32_to_cpu(htt_stats_buf->msdu_count));
1165
	len += scnprintf(buf + len, buf_len - len, "mpdu_count = %u\n",
1166
			 le32_to_cpu(htt_stats_buf->mpdu_count));
1167
	len += scnprintf(buf + len, buf_len - len, "remove_msdu = %u\n",
1168
			 le32_to_cpu(htt_stats_buf->remove_msdu));
1169
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu = %u\n",
1170
			 le32_to_cpu(htt_stats_buf->remove_mpdu));
1171
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl = %u\n",
1172
			 le32_to_cpu(htt_stats_buf->remove_msdu_ttl));
1173
	len += scnprintf(buf + len, buf_len - len, "send_bar = %u\n",
1174
			 le32_to_cpu(htt_stats_buf->send_bar));
1175
	len += scnprintf(buf + len, buf_len - len, "bar_sync = %u\n",
1176
			 le32_to_cpu(htt_stats_buf->bar_sync));
1177
	len += scnprintf(buf + len, buf_len - len, "notify_mpdu = %u\n",
1178
			 le32_to_cpu(htt_stats_buf->notify_mpdu));
1179
	len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n",
1180
			 le32_to_cpu(htt_stats_buf->sync_cmd));
1181
	len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n",
1182
			 le32_to_cpu(htt_stats_buf->write_cmd));
1183
	len += scnprintf(buf + len, buf_len - len, "hwsch_trigger = %u\n",
1184
			 le32_to_cpu(htt_stats_buf->hwsch_trigger));
1185
	len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
1186
			 le32_to_cpu(htt_stats_buf->ack_tlv_proc));
1187
	len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n",
1188
			 le32_to_cpu(htt_stats_buf->gen_mpdu_cmd));
1189
	len += scnprintf(buf + len, buf_len - len, "gen_list_cmd = %u\n",
1190
			 le32_to_cpu(htt_stats_buf->gen_list_cmd));
1191
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n",
1192
			 le32_to_cpu(htt_stats_buf->remove_mpdu_cmd));
1193
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu_tried_cmd = %u\n",
1194
			 le32_to_cpu(htt_stats_buf->remove_mpdu_tried_cmd));
1195
	len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n",
1196
			 le32_to_cpu(htt_stats_buf->mpdu_queue_stats_cmd));
1197
	len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n",
1198
			 le32_to_cpu(htt_stats_buf->mpdu_head_info_cmd));
1199
	len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n",
1200
			 le32_to_cpu(htt_stats_buf->msdu_flow_stats_cmd));
1201
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n",
1202
			 le32_to_cpu(htt_stats_buf->remove_msdu_cmd));
1203
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl_cmd = %u\n",
1204
			 le32_to_cpu(htt_stats_buf->remove_msdu_ttl_cmd));
1205
	len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n",
1206
			 le32_to_cpu(htt_stats_buf->flush_cache_cmd));
1207
	len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n",
1208
			 le32_to_cpu(htt_stats_buf->update_mpduq_cmd));
1209
	len += scnprintf(buf + len, buf_len - len, "enqueue = %u\n",
1210
			 le32_to_cpu(htt_stats_buf->enqueue));
1211
	len += scnprintf(buf + len, buf_len - len, "enqueue_notify = %u\n",
1212
			 le32_to_cpu(htt_stats_buf->enqueue_notify));
1213
	len += scnprintf(buf + len, buf_len - len, "notify_mpdu_at_head = %u\n",
1214
			 le32_to_cpu(htt_stats_buf->notify_mpdu_at_head));
1215
	len += scnprintf(buf + len, buf_len - len, "notify_mpdu_state_valid = %u\n",
1216
			 le32_to_cpu(htt_stats_buf->notify_mpdu_state_valid));
1217
	len += scnprintf(buf + len, buf_len - len, "sched_udp_notify1 = %u\n",
1218
			 le32_to_cpu(htt_stats_buf->sched_udp_notify1));
1219
	len += scnprintf(buf + len, buf_len - len, "sched_udp_notify2 = %u\n",
1220
			 le32_to_cpu(htt_stats_buf->sched_udp_notify2));
1221
	len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify1 = %u\n",
1222
			 le32_to_cpu(htt_stats_buf->sched_nonudp_notify1));
1223
	len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify2 = %u\n\n",
1224
			 le32_to_cpu(htt_stats_buf->sched_nonudp_notify2));
1225

1226
	stats_req->buf_len = len;
1227
}
1228

1229
static void
1230
ath12k_htt_print_tx_de_cmn_stats_tlv(const void *tag_buf, u16 tag_len,
1231
				     struct debug_htt_stats_req *stats_req)
1232
{
1233
	const struct ath12k_htt_tx_de_cmn_stats_tlv *htt_stats_buf = tag_buf;
1234
	u8 *buf = stats_req->buf;
1235
	u32 len = stats_req->buf_len;
1236
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1237
	u32 mac_id_word;
1238

1239
	if (tag_len < sizeof(*htt_stats_buf))
1240
		return;
1241

1242
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
1243

1244
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CMN_STATS_TLV:\n");
1245
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
1246
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
1247
	len += scnprintf(buf + len, buf_len - len, "tcl2fw_entry_count = %u\n",
1248
			 le32_to_cpu(htt_stats_buf->tcl2fw_entry_count));
1249
	len += scnprintf(buf + len, buf_len - len, "not_to_fw = %u\n",
1250
			 le32_to_cpu(htt_stats_buf->not_to_fw));
1251
	len += scnprintf(buf + len, buf_len - len, "invalid_pdev_vdev_peer = %u\n",
1252
			 le32_to_cpu(htt_stats_buf->invalid_pdev_vdev_peer));
1253
	len += scnprintf(buf + len, buf_len - len, "tcl_res_invalid_addrx = %u\n",
1254
			 le32_to_cpu(htt_stats_buf->tcl_res_invalid_addrx));
1255
	len += scnprintf(buf + len, buf_len - len, "wbm2fw_entry_count = %u\n",
1256
			 le32_to_cpu(htt_stats_buf->wbm2fw_entry_count));
1257
	len += scnprintf(buf + len, buf_len - len, "invalid_pdev = %u\n",
1258
			 le32_to_cpu(htt_stats_buf->invalid_pdev));
1259
	len += scnprintf(buf + len, buf_len - len, "tcl_res_addrx_timeout = %u\n",
1260
			 le32_to_cpu(htt_stats_buf->tcl_res_addrx_timeout));
1261
	len += scnprintf(buf + len, buf_len - len, "invalid_vdev = %u\n",
1262
			 le32_to_cpu(htt_stats_buf->invalid_vdev));
1263
	len += scnprintf(buf + len, buf_len - len, "invalid_tcl_exp_frame_desc = %u\n",
1264
			 le32_to_cpu(htt_stats_buf->invalid_tcl_exp_frame_desc));
1265
	len += scnprintf(buf + len, buf_len - len, "vdev_id_mismatch_count = %u\n\n",
1266
			 le32_to_cpu(htt_stats_buf->vdev_id_mismatch_cnt));
1267

1268
	stats_req->buf_len = len;
1269
}
1270

1271
static void
1272
ath12k_htt_print_tx_de_eapol_packets_stats_tlv(const void *tag_buf, u16 tag_len,
1273
					       struct debug_htt_stats_req *stats_req)
1274
{
1275
	const struct ath12k_htt_tx_de_eapol_packets_stats_tlv *htt_stats_buf = tag_buf;
1276
	u8 *buf = stats_req->buf;
1277
	u32 len = stats_req->buf_len;
1278
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1279

1280
	if (tag_len < sizeof(*htt_stats_buf))
1281
		return;
1282

1283
	len += scnprintf(buf + len, buf_len - len,
1284
			 "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:\n");
1285
	len += scnprintf(buf + len, buf_len - len, "m1_packets = %u\n",
1286
			 le32_to_cpu(htt_stats_buf->m1_packets));
1287
	len += scnprintf(buf + len, buf_len - len, "m2_packets = %u\n",
1288
			 le32_to_cpu(htt_stats_buf->m2_packets));
1289
	len += scnprintf(buf + len, buf_len - len, "m3_packets = %u\n",
1290
			 le32_to_cpu(htt_stats_buf->m3_packets));
1291
	len += scnprintf(buf + len, buf_len - len, "m4_packets = %u\n",
1292
			 le32_to_cpu(htt_stats_buf->m4_packets));
1293
	len += scnprintf(buf + len, buf_len - len, "g1_packets = %u\n",
1294
			 le32_to_cpu(htt_stats_buf->g1_packets));
1295
	len += scnprintf(buf + len, buf_len - len, "g2_packets = %u\n",
1296
			 le32_to_cpu(htt_stats_buf->g2_packets));
1297
	len += scnprintf(buf + len, buf_len - len, "rc4_packets = %u\n",
1298
			 le32_to_cpu(htt_stats_buf->rc4_packets));
1299
	len += scnprintf(buf + len, buf_len - len, "eap_packets = %u\n",
1300
			 le32_to_cpu(htt_stats_buf->eap_packets));
1301
	len += scnprintf(buf + len, buf_len - len, "eapol_start_packets = %u\n",
1302
			 le32_to_cpu(htt_stats_buf->eapol_start_packets));
1303
	len += scnprintf(buf + len, buf_len - len, "eapol_logoff_packets = %u\n",
1304
			 le32_to_cpu(htt_stats_buf->eapol_logoff_packets));
1305
	len += scnprintf(buf + len, buf_len - len, "eapol_encap_asf_packets = %u\n\n",
1306
			 le32_to_cpu(htt_stats_buf->eapol_encap_asf_packets));
1307

1308
	stats_req->buf_len = len;
1309
}
1310

1311
static void
1312
ath12k_htt_print_tx_de_classify_stats_tlv(const void *tag_buf, u16 tag_len,
1313
					  struct debug_htt_stats_req *stats_req)
1314
{
1315
	const struct ath12k_htt_tx_de_classify_stats_tlv *htt_stats_buf = tag_buf;
1316
	u8 *buf = stats_req->buf;
1317
	u32 len = stats_req->buf_len;
1318
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1319

1320
	if (tag_len < sizeof(*htt_stats_buf))
1321
		return;
1322

1323
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CLASSIFY_STATS_TLV:\n");
1324
	len += scnprintf(buf + len, buf_len - len, "arp_packets = %u\n",
1325
			 le32_to_cpu(htt_stats_buf->arp_packets));
1326
	len += scnprintf(buf + len, buf_len - len, "igmp_packets = %u\n",
1327
			 le32_to_cpu(htt_stats_buf->igmp_packets));
1328
	len += scnprintf(buf + len, buf_len - len, "dhcp_packets = %u\n",
1329
			 le32_to_cpu(htt_stats_buf->dhcp_packets));
1330
	len += scnprintf(buf + len, buf_len - len, "host_inspected = %u\n",
1331
			 le32_to_cpu(htt_stats_buf->host_inspected));
1332
	len += scnprintf(buf + len, buf_len - len, "htt_included = %u\n",
1333
			 le32_to_cpu(htt_stats_buf->htt_included));
1334
	len += scnprintf(buf + len, buf_len - len, "htt_valid_mcs = %u\n",
1335
			 le32_to_cpu(htt_stats_buf->htt_valid_mcs));
1336
	len += scnprintf(buf + len, buf_len - len, "htt_valid_nss = %u\n",
1337
			 le32_to_cpu(htt_stats_buf->htt_valid_nss));
1338
	len += scnprintf(buf + len, buf_len - len, "htt_valid_preamble_type = %u\n",
1339
			 le32_to_cpu(htt_stats_buf->htt_valid_preamble_type));
1340
	len += scnprintf(buf + len, buf_len - len, "htt_valid_chainmask = %u\n",
1341
			 le32_to_cpu(htt_stats_buf->htt_valid_chainmask));
1342
	len += scnprintf(buf + len, buf_len - len, "htt_valid_guard_interval = %u\n",
1343
			 le32_to_cpu(htt_stats_buf->htt_valid_guard_interval));
1344
	len += scnprintf(buf + len, buf_len - len, "htt_valid_retries = %u\n",
1345
			 le32_to_cpu(htt_stats_buf->htt_valid_retries));
1346
	len += scnprintf(buf + len, buf_len - len, "htt_valid_bw_info = %u\n",
1347
			 le32_to_cpu(htt_stats_buf->htt_valid_bw_info));
1348
	len += scnprintf(buf + len, buf_len - len, "htt_valid_power = %u\n",
1349
			 le32_to_cpu(htt_stats_buf->htt_valid_power));
1350
	len += scnprintf(buf + len, buf_len - len, "htt_valid_key_flags = 0x%x\n",
1351
			 le32_to_cpu(htt_stats_buf->htt_valid_key_flags));
1352
	len += scnprintf(buf + len, buf_len - len, "htt_valid_no_encryption = %u\n",
1353
			 le32_to_cpu(htt_stats_buf->htt_valid_no_encryption));
1354
	len += scnprintf(buf + len, buf_len - len, "fse_entry_count = %u\n",
1355
			 le32_to_cpu(htt_stats_buf->fse_entry_count));
1356
	len += scnprintf(buf + len, buf_len - len, "fse_priority_be = %u\n",
1357
			 le32_to_cpu(htt_stats_buf->fse_priority_be));
1358
	len += scnprintf(buf + len, buf_len - len, "fse_priority_high = %u\n",
1359
			 le32_to_cpu(htt_stats_buf->fse_priority_high));
1360
	len += scnprintf(buf + len, buf_len - len, "fse_priority_low = %u\n",
1361
			 le32_to_cpu(htt_stats_buf->fse_priority_low));
1362
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_be = %u\n",
1363
			 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_be));
1364
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_over_sub = %u\n",
1365
			 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_over_sub));
1366
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_bursty = %u\n",
1367
			 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_bursty));
1368
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_interactive = %u\n",
1369
			 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_interactive));
1370
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_periodic = %u\n",
1371
			 le32_to_cpu(htt_stats_buf->fse_traffic_ptrn_periodic));
1372
	len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_alloc = %u\n",
1373
			 le32_to_cpu(htt_stats_buf->fse_hwqueue_alloc));
1374
	len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_created = %u\n",
1375
			 le32_to_cpu(htt_stats_buf->fse_hwqueue_created));
1376
	len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_send_to_host = %u\n",
1377
			 le32_to_cpu(htt_stats_buf->fse_hwqueue_send_to_host));
1378
	len += scnprintf(buf + len, buf_len - len, "mcast_entry = %u\n",
1379
			 le32_to_cpu(htt_stats_buf->mcast_entry));
1380
	len += scnprintf(buf + len, buf_len - len, "bcast_entry = %u\n",
1381
			 le32_to_cpu(htt_stats_buf->bcast_entry));
1382
	len += scnprintf(buf + len, buf_len - len, "htt_update_peer_cache = %u\n",
1383
			 le32_to_cpu(htt_stats_buf->htt_update_peer_cache));
1384
	len += scnprintf(buf + len, buf_len - len, "htt_learning_frame = %u\n",
1385
			 le32_to_cpu(htt_stats_buf->htt_learning_frame));
1386
	len += scnprintf(buf + len, buf_len - len, "fse_invalid_peer = %u\n",
1387
			 le32_to_cpu(htt_stats_buf->fse_invalid_peer));
1388
	len += scnprintf(buf + len, buf_len - len, "mec_notify = %u\n\n",
1389
			 le32_to_cpu(htt_stats_buf->mec_notify));
1390

1391
	stats_req->buf_len = len;
1392
}
1393

1394
static void
1395
ath12k_htt_print_tx_de_classify_failed_stats_tlv(const void *tag_buf, u16 tag_len,
1396
						 struct debug_htt_stats_req *stats_req)
1397
{
1398
	const struct ath12k_htt_tx_de_classify_failed_stats_tlv *htt_stats_buf = tag_buf;
1399
	u8 *buf = stats_req->buf;
1400
	u32 len = stats_req->buf_len;
1401
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1402

1403
	if (tag_len < sizeof(*htt_stats_buf))
1404
		return;
1405

1406
	len += scnprintf(buf + len, buf_len - len,
1407
			 "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:\n");
1408
	len += scnprintf(buf + len, buf_len - len, "ap_bss_peer_not_found = %u\n",
1409
			 le32_to_cpu(htt_stats_buf->ap_bss_peer_not_found));
1410
	len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_no_peer = %u\n",
1411
			 le32_to_cpu(htt_stats_buf->ap_bcast_mcast_no_peer));
1412
	len += scnprintf(buf + len, buf_len - len, "sta_delete_in_progress = %u\n",
1413
			 le32_to_cpu(htt_stats_buf->sta_delete_in_progress));
1414
	len += scnprintf(buf + len, buf_len - len, "ibss_no_bss_peer = %u\n",
1415
			 le32_to_cpu(htt_stats_buf->ibss_no_bss_peer));
1416
	len += scnprintf(buf + len, buf_len - len, "invalid_vdev_type = %u\n",
1417
			 le32_to_cpu(htt_stats_buf->invalid_vdev_type));
1418
	len += scnprintf(buf + len, buf_len - len, "invalid_ast_peer_entry = %u\n",
1419
			 le32_to_cpu(htt_stats_buf->invalid_ast_peer_entry));
1420
	len += scnprintf(buf + len, buf_len - len, "peer_entry_invalid = %u\n",
1421
			 le32_to_cpu(htt_stats_buf->peer_entry_invalid));
1422
	len += scnprintf(buf + len, buf_len - len, "ethertype_not_ip = %u\n",
1423
			 le32_to_cpu(htt_stats_buf->ethertype_not_ip));
1424
	len += scnprintf(buf + len, buf_len - len, "eapol_lookup_failed = %u\n",
1425
			 le32_to_cpu(htt_stats_buf->eapol_lookup_failed));
1426
	len += scnprintf(buf + len, buf_len - len, "qpeer_not_allow_data = %u\n",
1427
			 le32_to_cpu(htt_stats_buf->qpeer_not_allow_data));
1428
	len += scnprintf(buf + len, buf_len - len, "fse_tid_override = %u\n",
1429
			 le32_to_cpu(htt_stats_buf->fse_tid_override));
1430
	len += scnprintf(buf + len, buf_len - len, "ipv6_jumbogram_zero_length = %u\n",
1431
			 le32_to_cpu(htt_stats_buf->ipv6_jumbogram_zero_length));
1432
	len += scnprintf(buf + len, buf_len - len, "qos_to_non_qos_in_prog = %u\n",
1433
			 le32_to_cpu(htt_stats_buf->qos_to_non_qos_in_prog));
1434
	len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_eapol = %u\n",
1435
			 le32_to_cpu(htt_stats_buf->ap_bcast_mcast_eapol));
1436
	len += scnprintf(buf + len, buf_len - len, "unicast_on_ap_bss_peer = %u\n",
1437
			 le32_to_cpu(htt_stats_buf->unicast_on_ap_bss_peer));
1438
	len += scnprintf(buf + len, buf_len - len, "ap_vdev_invalid = %u\n",
1439
			 le32_to_cpu(htt_stats_buf->ap_vdev_invalid));
1440
	len += scnprintf(buf + len, buf_len - len, "incomplete_llc = %u\n",
1441
			 le32_to_cpu(htt_stats_buf->incomplete_llc));
1442
	len += scnprintf(buf + len, buf_len - len, "eapol_duplicate_m3 = %u\n",
1443
			 le32_to_cpu(htt_stats_buf->eapol_duplicate_m3));
1444
	len += scnprintf(buf + len, buf_len - len, "eapol_duplicate_m4 = %u\n\n",
1445
			 le32_to_cpu(htt_stats_buf->eapol_duplicate_m4));
1446

1447
	stats_req->buf_len = len;
1448
}
1449

1450
static void
1451
ath12k_htt_print_tx_de_classify_status_stats_tlv(const void *tag_buf, u16 tag_len,
1452
						 struct debug_htt_stats_req *stats_req)
1453
{
1454
	const struct ath12k_htt_tx_de_classify_status_stats_tlv *htt_stats_buf = tag_buf;
1455
	u8 *buf = stats_req->buf;
1456
	u32 len = stats_req->buf_len;
1457
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1458

1459
	if (tag_len < sizeof(*htt_stats_buf))
1460
		return;
1461

1462
	len += scnprintf(buf + len, buf_len - len,
1463
			 "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:\n");
1464
	len += scnprintf(buf + len, buf_len - len, "eok = %u\n",
1465
			 le32_to_cpu(htt_stats_buf->eok));
1466
	len += scnprintf(buf + len, buf_len - len, "classify_done = %u\n",
1467
			 le32_to_cpu(htt_stats_buf->classify_done));
1468
	len += scnprintf(buf + len, buf_len - len, "lookup_failed = %u\n",
1469
			 le32_to_cpu(htt_stats_buf->lookup_failed));
1470
	len += scnprintf(buf + len, buf_len - len, "send_host_dhcp = %u\n",
1471
			 le32_to_cpu(htt_stats_buf->send_host_dhcp));
1472
	len += scnprintf(buf + len, buf_len - len, "send_host_mcast = %u\n",
1473
			 le32_to_cpu(htt_stats_buf->send_host_mcast));
1474
	len += scnprintf(buf + len, buf_len - len, "send_host_unknown_dest = %u\n",
1475
			 le32_to_cpu(htt_stats_buf->send_host_unknown_dest));
1476
	len += scnprintf(buf + len, buf_len - len, "send_host = %u\n",
1477
			 le32_to_cpu(htt_stats_buf->send_host));
1478
	len += scnprintf(buf + len, buf_len - len, "status_invalid = %u\n\n",
1479
			 le32_to_cpu(htt_stats_buf->status_invalid));
1480

1481
	stats_req->buf_len = len;
1482
}
1483

1484
static void
1485
ath12k_htt_print_tx_de_enqueue_packets_stats_tlv(const void *tag_buf, u16 tag_len,
1486
						 struct debug_htt_stats_req *stats_req)
1487
{
1488
	const struct ath12k_htt_tx_de_enqueue_packets_stats_tlv *htt_stats_buf = tag_buf;
1489
	u8 *buf = stats_req->buf;
1490
	u32 len = stats_req->buf_len;
1491
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1492

1493
	if (tag_len < sizeof(*htt_stats_buf))
1494
		return;
1495

1496
	len += scnprintf(buf + len, buf_len - len,
1497
			 "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:\n");
1498
	len += scnprintf(buf + len, buf_len - len, "enqueued_pkts = %u\n",
1499
			 le32_to_cpu(htt_stats_buf->enqueued_pkts));
1500
	len += scnprintf(buf + len, buf_len - len, "to_tqm = %u\n",
1501
			 le32_to_cpu(htt_stats_buf->to_tqm));
1502
	len += scnprintf(buf + len, buf_len - len, "to_tqm_bypass = %u\n\n",
1503
			 le32_to_cpu(htt_stats_buf->to_tqm_bypass));
1504

1505
	stats_req->buf_len = len;
1506
}
1507

1508
static void
1509
ath12k_htt_print_tx_de_enqueue_discard_stats_tlv(const void *tag_buf, u16 tag_len,
1510
						 struct debug_htt_stats_req *stats_req)
1511
{
1512
	const struct ath12k_htt_tx_de_enqueue_discard_stats_tlv *htt_stats_buf = tag_buf;
1513
	u8 *buf = stats_req->buf;
1514
	u32 len = stats_req->buf_len;
1515
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1516

1517
	if (tag_len < sizeof(*htt_stats_buf))
1518
		return;
1519

1520
	len += scnprintf(buf + len, buf_len - len,
1521
			 "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:\n");
1522
	len += scnprintf(buf + len, buf_len - len, "discarded_pkts = %u\n",
1523
			 le32_to_cpu(htt_stats_buf->discarded_pkts));
1524
	len += scnprintf(buf + len, buf_len - len, "local_frames = %u\n",
1525
			 le32_to_cpu(htt_stats_buf->local_frames));
1526
	len += scnprintf(buf + len, buf_len - len, "is_ext_msdu = %u\n\n",
1527
			 le32_to_cpu(htt_stats_buf->is_ext_msdu));
1528

1529
	stats_req->buf_len = len;
1530
}
1531

1532
static void
1533
ath12k_htt_print_tx_de_compl_stats_tlv(const void *tag_buf, u16 tag_len,
1534
				       struct debug_htt_stats_req *stats_req)
1535
{
1536
	const struct ath12k_htt_tx_de_compl_stats_tlv *htt_stats_buf = tag_buf;
1537
	u8 *buf = stats_req->buf;
1538
	u32 len = stats_req->buf_len;
1539
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1540

1541
	if (tag_len < sizeof(*htt_stats_buf))
1542
		return;
1543

1544
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_COMPL_STATS_TLV:\n");
1545
	len += scnprintf(buf + len, buf_len - len, "tcl_dummy_frame = %u\n",
1546
			 le32_to_cpu(htt_stats_buf->tcl_dummy_frame));
1547
	len += scnprintf(buf + len, buf_len - len, "tqm_dummy_frame = %u\n",
1548
			 le32_to_cpu(htt_stats_buf->tqm_dummy_frame));
1549
	len += scnprintf(buf + len, buf_len - len, "tqm_notify_frame = %u\n",
1550
			 le32_to_cpu(htt_stats_buf->tqm_notify_frame));
1551
	len += scnprintf(buf + len, buf_len - len, "fw2wbm_enq = %u\n",
1552
			 le32_to_cpu(htt_stats_buf->fw2wbm_enq));
1553
	len += scnprintf(buf + len, buf_len - len, "tqm_bypass_frame = %u\n\n",
1554
			 le32_to_cpu(htt_stats_buf->tqm_bypass_frame));
1555

1556
	stats_req->buf_len = len;
1557
}
1558

1559
static void
1560
ath12k_htt_print_tx_selfgen_cmn_stats_tlv(const void *tag_buf, u16 tag_len,
1561
					  struct debug_htt_stats_req *stats_req)
1562
{
1563
	const struct ath12k_htt_tx_selfgen_cmn_stats_tlv *htt_stats_buf = tag_buf;
1564
	u8 *buf = stats_req->buf;
1565
	u32 len = stats_req->buf_len;
1566
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1567
	u32 mac_id_word;
1568

1569
	if (tag_len < sizeof(*htt_stats_buf))
1570
		return;
1571

1572
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
1573

1574
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n");
1575
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
1576
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
1577
	len += scnprintf(buf + len, buf_len - len, "su_bar = %u\n",
1578
			 le32_to_cpu(htt_stats_buf->su_bar));
1579
	len += scnprintf(buf + len, buf_len - len, "rts = %u\n",
1580
			 le32_to_cpu(htt_stats_buf->rts));
1581
	len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n",
1582
			 le32_to_cpu(htt_stats_buf->cts2self));
1583
	len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n",
1584
			 le32_to_cpu(htt_stats_buf->qos_null));
1585
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_1 = %u\n",
1586
			 le32_to_cpu(htt_stats_buf->delayed_bar_1));
1587
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_2 = %u\n",
1588
			 le32_to_cpu(htt_stats_buf->delayed_bar_2));
1589
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_3 = %u\n",
1590
			 le32_to_cpu(htt_stats_buf->delayed_bar_3));
1591
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_4 = %u\n",
1592
			 le32_to_cpu(htt_stats_buf->delayed_bar_4));
1593
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_5 = %u\n",
1594
			 le32_to_cpu(htt_stats_buf->delayed_bar_5));
1595
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_6 = %u\n",
1596
			 le32_to_cpu(htt_stats_buf->delayed_bar_6));
1597
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_7 = %u\n\n",
1598
			 le32_to_cpu(htt_stats_buf->delayed_bar_7));
1599

1600
	stats_req->buf_len = len;
1601
}
1602

1603
static void
1604
ath12k_htt_print_tx_selfgen_ac_stats_tlv(const void *tag_buf, u16 tag_len,
1605
					 struct debug_htt_stats_req *stats_req)
1606
{
1607
	const struct ath12k_htt_tx_selfgen_ac_stats_tlv *htt_stats_buf = tag_buf;
1608
	u8 *buf = stats_req->buf;
1609
	u32 len = stats_req->buf_len;
1610
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1611

1612
	if (tag_len < sizeof(*htt_stats_buf))
1613
		return;
1614

1615
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n");
1616
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_tried = %u\n",
1617
			 le32_to_cpu(htt_stats_buf->ac_su_ndpa));
1618
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_tried = %u\n",
1619
			 le32_to_cpu(htt_stats_buf->ac_su_ndp));
1620
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_tried = %u\n",
1621
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndpa));
1622
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_tried = %u\n",
1623
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndp));
1624
	len += print_array_to_buf_index(buf, len, "ac_mu_mimo_brpollX_tried = ", 1,
1625
					htt_stats_buf->ac_mu_mimo_brpoll,
1626
					ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS - 1,
1627
					"\n\n");
1628

1629
	stats_req->buf_len = len;
1630
}
1631

1632
static void
1633
ath12k_htt_print_tx_selfgen_ax_stats_tlv(const void *tag_buf, u16 tag_len,
1634
					 struct debug_htt_stats_req *stats_req)
1635
{
1636
	const struct ath12k_htt_tx_selfgen_ax_stats_tlv *htt_stats_buf = tag_buf;
1637
	u8 *buf = stats_req->buf;
1638
	u32 len = stats_req->buf_len;
1639
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1640

1641
	if (tag_len < sizeof(*htt_stats_buf))
1642
		return;
1643

1644
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n");
1645
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_tried = %u\n",
1646
			 le32_to_cpu(htt_stats_buf->ax_su_ndpa));
1647
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_tried = %u\n",
1648
			 le32_to_cpu(htt_stats_buf->ax_su_ndp));
1649
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_tried = %u\n",
1650
			 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndpa));
1651
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_tried = %u\n",
1652
			 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndp));
1653
	len += print_array_to_buf_index(buf, len, "ax_mu_mimo_brpollX_tried = ", 1,
1654
					htt_stats_buf->ax_mu_mimo_brpoll,
1655
					ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS - 1, "\n");
1656
	len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger = %u\n",
1657
			 le32_to_cpu(htt_stats_buf->ax_basic_trigger));
1658
	len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_total_trigger = %u\n",
1659
			 le32_to_cpu(htt_stats_buf->ax_ulmumimo_trigger));
1660
	len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger = %u\n",
1661
			 le32_to_cpu(htt_stats_buf->ax_bsr_trigger));
1662
	len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n",
1663
			 le32_to_cpu(htt_stats_buf->ax_mu_bar_trigger));
1664
	len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n\n",
1665
			 le32_to_cpu(htt_stats_buf->ax_mu_rts_trigger));
1666

1667
	stats_req->buf_len = len;
1668
}
1669

1670
static void
1671
ath12k_htt_print_tx_selfgen_be_stats_tlv(const void *tag_buf, u16 tag_len,
1672
					 struct debug_htt_stats_req *stats_req)
1673
{
1674
	const struct ath12k_htt_tx_selfgen_be_stats_tlv *htt_stats_buf = tag_buf;
1675
	u8 *buf = stats_req->buf;
1676
	u32 len = stats_req->buf_len;
1677
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1678

1679
	if (tag_len < sizeof(*htt_stats_buf))
1680
		return;
1681

1682
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_BE_STATS_TLV:\n");
1683
	len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_queued = %u\n",
1684
			 le32_to_cpu(htt_stats_buf->be_su_ndpa_queued));
1685
	len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_tried = %u\n",
1686
			 le32_to_cpu(htt_stats_buf->be_su_ndpa));
1687
	len += scnprintf(buf + len, buf_len - len, "be_su_ndp_queued = %u\n",
1688
			 le32_to_cpu(htt_stats_buf->be_su_ndp_queued));
1689
	len += scnprintf(buf + len, buf_len - len, "be_su_ndp_tried = %u\n",
1690
			 le32_to_cpu(htt_stats_buf->be_su_ndp));
1691
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_queued = %u\n",
1692
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_queued));
1693
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_tried = %u\n",
1694
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa));
1695
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_queued = %u\n",
1696
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_queued));
1697
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_tried = %u\n",
1698
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp));
1699
	len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_queued = ", 1,
1700
					htt_stats_buf->be_mu_mimo_brpoll_queued,
1701
					ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1,
1702
					"\n");
1703
	len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_tried = ", 1,
1704
					htt_stats_buf->be_mu_mimo_brpoll,
1705
					ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1,
1706
					"\n");
1707
	len += print_array_to_buf(buf, len, "be_ul_mumimo_trigger = ",
1708
				  htt_stats_buf->be_ul_mumimo_trigger,
1709
				  ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n");
1710
	len += scnprintf(buf + len, buf_len - len, "be_basic_trigger = %u\n",
1711
			 le32_to_cpu(htt_stats_buf->be_basic_trigger));
1712
	len += scnprintf(buf + len, buf_len - len, "be_ulmumimo_total_trigger = %u\n",
1713
			 le32_to_cpu(htt_stats_buf->be_ulmumimo_trigger));
1714
	len += scnprintf(buf + len, buf_len - len, "be_bsr_trigger = %u\n",
1715
			 le32_to_cpu(htt_stats_buf->be_bsr_trigger));
1716
	len += scnprintf(buf + len, buf_len - len, "be_mu_bar_trigger = %u\n",
1717
			 le32_to_cpu(htt_stats_buf->be_mu_bar_trigger));
1718
	len += scnprintf(buf + len, buf_len - len, "be_mu_rts_trigger = %u\n\n",
1719
			 le32_to_cpu(htt_stats_buf->be_mu_rts_trigger));
1720

1721
	stats_req->buf_len = len;
1722
}
1723

1724
static void
1725
ath12k_htt_print_tx_selfgen_ac_err_stats_tlv(const void *tag_buf, u16 tag_len,
1726
					     struct debug_htt_stats_req *stats_req)
1727
{
1728
	const struct ath12k_htt_tx_selfgen_ac_err_stats_tlv *htt_stats_buf = tag_buf;
1729
	u8 *buf = stats_req->buf;
1730
	u32 len = stats_req->buf_len;
1731
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1732

1733
	if (tag_len < sizeof(*htt_stats_buf))
1734
		return;
1735

1736
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n");
1737
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_err = %u\n",
1738
			 le32_to_cpu(htt_stats_buf->ac_su_ndp_err));
1739
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n",
1740
			 le32_to_cpu(htt_stats_buf->ac_su_ndpa_err));
1741
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n",
1742
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndpa_err));
1743
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n",
1744
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_ndp_err));
1745
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n",
1746
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp1_err));
1747
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n",
1748
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp2_err));
1749
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n",
1750
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_brp3_err));
1751

1752
	stats_req->buf_len = len;
1753
}
1754

1755
static void
1756
ath12k_htt_print_tx_selfgen_ax_err_stats_tlv(const void *tag_buf, u16 tag_len,
1757
					     struct debug_htt_stats_req *stats_req)
1758
{
1759
	const struct ath12k_htt_tx_selfgen_ax_err_stats_tlv *htt_stats_buf = tag_buf;
1760
	u8 *buf = stats_req->buf;
1761
	u32 len = stats_req->buf_len;
1762
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1763

1764
	if (tag_len < sizeof(*htt_stats_buf))
1765
		return;
1766

1767
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n");
1768
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_err = %u\n",
1769
			 le32_to_cpu(htt_stats_buf->ax_su_ndp_err));
1770
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n",
1771
			 le32_to_cpu(htt_stats_buf->ax_su_ndpa_err));
1772
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n",
1773
			 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndpa_err));
1774
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n",
1775
			 le32_to_cpu(htt_stats_buf->ax_mu_mimo_ndp_err));
1776
	len += print_array_to_buf_index(buf, len, "ax_mu_mimo_brpX_err", 1,
1777
					htt_stats_buf->ax_mu_mimo_brp_err,
1778
					ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS - 1,
1779
					"\n");
1780
	len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger_err = %u\n",
1781
			 le32_to_cpu(htt_stats_buf->ax_basic_trigger_err));
1782
	len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_total_trigger_err = %u\n",
1783
			 le32_to_cpu(htt_stats_buf->ax_ulmumimo_trigger_err));
1784
	len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n",
1785
			 le32_to_cpu(htt_stats_buf->ax_bsr_trigger_err));
1786
	len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n",
1787
			 le32_to_cpu(htt_stats_buf->ax_mu_bar_trigger_err));
1788
	len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n\n",
1789
			 le32_to_cpu(htt_stats_buf->ax_mu_rts_trigger_err));
1790

1791
	stats_req->buf_len = len;
1792
}
1793

1794
static void
1795
ath12k_htt_print_tx_selfgen_be_err_stats_tlv(const void *tag_buf, u16 tag_len,
1796
					     struct debug_htt_stats_req *stats_req)
1797
{
1798
	const struct ath12k_htt_tx_selfgen_be_err_stats_tlv *htt_stats_buf = tag_buf;
1799
	u8 *buf = stats_req->buf;
1800
	u32 len = stats_req->buf_len;
1801
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1802

1803
	if (tag_len < sizeof(*htt_stats_buf))
1804
		return;
1805

1806
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_BE_ERR_STATS_TLV:\n");
1807
	len += scnprintf(buf + len, buf_len - len, "be_su_ndp_err = %u\n",
1808
			 le32_to_cpu(htt_stats_buf->be_su_ndp_err));
1809
	len += scnprintf(buf + len, buf_len - len, "be_su_ndp_flushed = %u\n",
1810
			 le32_to_cpu(htt_stats_buf->be_su_ndp_flushed));
1811
	len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_err = %u\n",
1812
			 le32_to_cpu(htt_stats_buf->be_su_ndpa_err));
1813
	len += scnprintf(buf + len, buf_len - len, "be_su_ndpa_flushed = %u\n",
1814
			 le32_to_cpu(htt_stats_buf->be_su_ndpa_flushed));
1815
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_err = %u\n",
1816
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_err));
1817
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndpa_flushed = %u\n",
1818
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndpa_flushed));
1819
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_err = %u\n",
1820
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_err));
1821
	len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_ndp_flushed = %u\n",
1822
			 le32_to_cpu(htt_stats_buf->be_mu_mimo_ndp_flushed));
1823
	len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpX_err", 1,
1824
					htt_stats_buf->be_mu_mimo_brp_err,
1825
					ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1,
1826
					"\n");
1827
	len += print_array_to_buf_index(buf, len, "be_mu_mimo_brpollX_flushed", 1,
1828
					htt_stats_buf->be_mu_mimo_brpoll_flushed,
1829
					ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS - 1,
1830
					"\n");
1831
	len += print_array_to_buf(buf, len, "be_mu_mimo_num_cbf_rcvd_on_brp_err",
1832
				  htt_stats_buf->be_mu_mimo_brp_err_num_cbf_rxd,
1833
				  ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n");
1834
	len += print_array_to_buf(buf, len, "be_ul_mumimo_trigger_err",
1835
				  htt_stats_buf->be_ul_mumimo_trigger_err,
1836
				  ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS, "\n");
1837
	len += scnprintf(buf + len, buf_len - len, "be_basic_trigger_err = %u\n",
1838
			 le32_to_cpu(htt_stats_buf->be_basic_trigger_err));
1839
	len += scnprintf(buf + len, buf_len - len, "be_ulmumimo_total_trig_err = %u\n",
1840
			 le32_to_cpu(htt_stats_buf->be_ulmumimo_trigger_err));
1841
	len += scnprintf(buf + len, buf_len - len, "be_bsr_trigger_err = %u\n",
1842
			 le32_to_cpu(htt_stats_buf->be_bsr_trigger_err));
1843
	len += scnprintf(buf + len, buf_len - len, "be_mu_bar_trigger_err = %u\n",
1844
			 le32_to_cpu(htt_stats_buf->be_mu_bar_trigger_err));
1845
	len += scnprintf(buf + len, buf_len - len, "be_mu_rts_trigger_err = %u\n\n",
1846
			 le32_to_cpu(htt_stats_buf->be_mu_rts_trigger_err));
1847

1848
	stats_req->buf_len = len;
1849
}
1850

1851
static void
1852
ath12k_htt_print_tx_selfgen_ac_sched_status_stats_tlv(const void *tag_buf, u16 tag_len,
1853
						      struct debug_htt_stats_req *stats)
1854
{
1855
	const struct ath12k_htt_tx_selfgen_ac_sched_status_stats_tlv *htt_stats_buf =
1856
		     tag_buf;
1857
	u8 *buf = stats->buf;
1858
	u32 len = stats->buf_len;
1859
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1860

1861
	if (tag_len < sizeof(*htt_stats_buf))
1862
		return;
1863

1864
	len += scnprintf(buf + len, buf_len - len,
1865
			 "HTT_TX_SELFGEN_AC_SCHED_STATUS_STATS_TLV:\n");
1866
	len += print_array_to_buf(buf, len, "ac_su_ndpa_sch_status",
1867
				  htt_stats_buf->ac_su_ndpa_sch_status,
1868
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1869
	len += print_array_to_buf(buf, len, "ac_su_ndp_sch_status",
1870
				  htt_stats_buf->ac_su_ndp_sch_status,
1871
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1872
	len += print_array_to_buf(buf, len, "ac_mu_mimo_ndpa_sch_status",
1873
				  htt_stats_buf->ac_mu_mimo_ndpa_sch_status,
1874
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1875
	len += print_array_to_buf(buf, len, "ac_mu_mimo_ndp_sch_status",
1876
				  htt_stats_buf->ac_mu_mimo_ndp_sch_status,
1877
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1878
	len += print_array_to_buf(buf, len, "ac_mu_mimo_brp_sch_status",
1879
				  htt_stats_buf->ac_mu_mimo_brp_sch_status,
1880
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1881
	len += print_array_to_buf(buf, len, "ac_su_ndp_sch_flag_err",
1882
				  htt_stats_buf->ac_su_ndp_sch_flag_err,
1883
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1884
	len += print_array_to_buf(buf, len, "ac_mu_mimo_ndp_sch_flag_err",
1885
				  htt_stats_buf->ac_mu_mimo_ndp_sch_flag_err,
1886
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1887
	len += print_array_to_buf(buf, len, "ac_mu_mimo_brp_sch_flag_err",
1888
				  htt_stats_buf->ac_mu_mimo_brp_sch_flag_err,
1889
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n");
1890

1891
	stats->buf_len = len;
1892
}
1893

1894
static void
1895
ath12k_htt_print_tx_selfgen_ax_sched_status_stats_tlv(const void *tag_buf, u16 tag_len,
1896
						      struct debug_htt_stats_req *stats)
1897
{
1898
	const struct ath12k_htt_tx_selfgen_ax_sched_status_stats_tlv *htt_stats_buf =
1899
		     tag_buf;
1900
	u8 *buf = stats->buf;
1901
	u32 len = stats->buf_len;
1902
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1903

1904
	if (tag_len < sizeof(*htt_stats_buf))
1905
		return;
1906

1907
	len += scnprintf(buf + len, buf_len - len,
1908
			 "HTT_TX_SELFGEN_AX_SCHED_STATUS_STATS_TLV:\n");
1909
	len += print_array_to_buf(buf, len, "ax_su_ndpa_sch_status",
1910
				  htt_stats_buf->ax_su_ndpa_sch_status,
1911
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1912
	len += print_array_to_buf(buf, len, "ax_su_ndp_sch_status",
1913
				  htt_stats_buf->ax_su_ndp_sch_status,
1914
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1915
	len += print_array_to_buf(buf, len, "ax_mu_mimo_ndpa_sch_status",
1916
				  htt_stats_buf->ax_mu_mimo_ndpa_sch_status,
1917
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1918
	len += print_array_to_buf(buf, len, "ax_mu_mimo_ndp_sch_status",
1919
				  htt_stats_buf->ax_mu_mimo_ndp_sch_status,
1920
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1921
	len += print_array_to_buf(buf, len, "ax_mu_brp_sch_status",
1922
				  htt_stats_buf->ax_mu_brp_sch_status,
1923
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1924
	len += print_array_to_buf(buf, len, "ax_mu_bar_sch_status",
1925
				  htt_stats_buf->ax_mu_bar_sch_status,
1926
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1927
	len += print_array_to_buf(buf, len, "ax_basic_trig_sch_status",
1928
				  htt_stats_buf->ax_basic_trig_sch_status,
1929
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1930
	len += print_array_to_buf(buf, len, "ax_su_ndp_sch_flag_err",
1931
				  htt_stats_buf->ax_su_ndp_sch_flag_err,
1932
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1933
	len += print_array_to_buf(buf, len, "ax_mu_mimo_ndp_sch_flag_err",
1934
				  htt_stats_buf->ax_mu_mimo_ndp_sch_flag_err,
1935
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1936
	len += print_array_to_buf(buf, len, "ax_mu_brp_sch_flag_err",
1937
				  htt_stats_buf->ax_mu_brp_sch_flag_err,
1938
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1939
	len += print_array_to_buf(buf, len, "ax_mu_bar_sch_flag_err",
1940
				  htt_stats_buf->ax_mu_bar_sch_flag_err,
1941
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1942
	len += print_array_to_buf(buf, len, "ax_basic_trig_sch_flag_err",
1943
				  htt_stats_buf->ax_basic_trig_sch_flag_err,
1944
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1945
	len += print_array_to_buf(buf, len, "ax_ulmumimo_trig_sch_status",
1946
				  htt_stats_buf->ax_ulmumimo_trig_sch_status,
1947
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1948
	len += print_array_to_buf(buf, len, "ax_ulmumimo_trig_sch_flag_err",
1949
				  htt_stats_buf->ax_ulmumimo_trig_sch_flag_err,
1950
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n");
1951

1952
	stats->buf_len = len;
1953
}
1954

1955
static void
1956
ath12k_htt_print_tx_selfgen_be_sched_status_stats_tlv(const void *tag_buf, u16 tag_len,
1957
						      struct debug_htt_stats_req *stats)
1958
{
1959
	const struct ath12k_htt_tx_selfgen_be_sched_status_stats_tlv *htt_stats_buf =
1960
		     tag_buf;
1961
	u8 *buf = stats->buf;
1962
	u32 len = stats->buf_len;
1963
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
1964

1965
	if (tag_len < sizeof(*htt_stats_buf))
1966
		return;
1967

1968
	len += scnprintf(buf + len, buf_len - len,
1969
			 "HTT_TX_SELFGEN_BE_SCHED_STATUS_STATS_TLV:\n");
1970
	len += print_array_to_buf(buf, len, "be_su_ndpa_sch_status",
1971
				  htt_stats_buf->be_su_ndpa_sch_status,
1972
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1973
	len += print_array_to_buf(buf, len, "be_su_ndp_sch_status",
1974
				  htt_stats_buf->be_su_ndp_sch_status,
1975
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1976
	len += print_array_to_buf(buf, len, "be_mu_mimo_ndpa_sch_status",
1977
				  htt_stats_buf->be_mu_mimo_ndpa_sch_status,
1978
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1979
	len += print_array_to_buf(buf, len, "be_mu_mimo_ndp_sch_status",
1980
				  htt_stats_buf->be_mu_mimo_ndp_sch_status,
1981
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1982
	len += print_array_to_buf(buf, len, "be_mu_brp_sch_status",
1983
				  htt_stats_buf->be_mu_brp_sch_status,
1984
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1985
	len += print_array_to_buf(buf, len, "be_mu_bar_sch_status",
1986
				  htt_stats_buf->be_mu_bar_sch_status,
1987
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1988
	len += print_array_to_buf(buf, len, "be_basic_trig_sch_status",
1989
				  htt_stats_buf->be_basic_trig_sch_status,
1990
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
1991
	len += print_array_to_buf(buf, len, "be_su_ndp_sch_flag_err",
1992
				  htt_stats_buf->be_su_ndp_sch_flag_err,
1993
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1994
	len += print_array_to_buf(buf, len, "be_mu_mimo_ndp_sch_flag_err",
1995
				  htt_stats_buf->be_mu_mimo_ndp_sch_flag_err,
1996
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
1997
	len += print_array_to_buf(buf, len, "be_mu_brp_sch_flag_err",
1998
				  htt_stats_buf->be_mu_brp_sch_flag_err,
1999
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
2000
	len += print_array_to_buf(buf, len, "be_mu_bar_sch_flag_err",
2001
				  htt_stats_buf->be_mu_bar_sch_flag_err,
2002
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
2003
	len += print_array_to_buf(buf, len, "be_basic_trig_sch_flag_err",
2004
				  htt_stats_buf->be_basic_trig_sch_flag_err,
2005
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n");
2006
	len += print_array_to_buf(buf, len, "be_basic_trig_sch_flag_err",
2007
				  htt_stats_buf->be_basic_trig_sch_flag_err,
2008
				  ATH12K_HTT_TX_PDEV_STATS_NUM_TX_ERR_STATUS, "\n");
2009
	len += print_array_to_buf(buf, len, "be_ulmumimo_trig_sch_flag_err",
2010
				  htt_stats_buf->be_ulmumimo_trig_sch_flag_err,
2011
				  ATH12K_HTT_TX_SELFGEN_SCH_TSFLAG_ERR_STATS, "\n\n");
2012

2013
	stats->buf_len = len;
2014
}
2015

2016
static void
2017
ath12k_htt_print_stats_string_tlv(const void *tag_buf, u16 tag_len,
2018
				  struct debug_htt_stats_req *stats_req)
2019
{
2020
	const struct ath12k_htt_stats_string_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
	u8 i;
2025
	u16 index = 0;
2026
	u32 datum;
2027
	char data[ATH12K_HTT_MAX_STRING_LEN] = {};
2028

2029
	tag_len = tag_len >> 2;
2030

2031
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n");
2032
	for (i = 0; i < tag_len; i++) {
2033
		datum = __le32_to_cpu(htt_stats_buf->data[i]);
2034
		index += scnprintf(&data[index], ATH12K_HTT_MAX_STRING_LEN - index,
2035
				   "%.*s", 4, (char *)&datum);
2036
		if (index >= ATH12K_HTT_MAX_STRING_LEN)
2037
			break;
2038
	}
2039
	len += scnprintf(buf + len, buf_len - len, "data = %s\n\n", data);
2040

2041
	stats_req->buf_len = len;
2042
}
2043

2044
static void
2045
ath12k_htt_print_sring_stats_tlv(const void *tag_buf, u16 tag_len,
2046
				 struct debug_htt_stats_req *stats_req)
2047
{
2048
	const struct ath12k_htt_sring_stats_tlv *htt_stats_buf = tag_buf;
2049
	u8 *buf = stats_req->buf;
2050
	u32 len = stats_req->buf_len;
2051
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2052
	u32 mac_id_word;
2053
	u32 avail_words;
2054
	u32 head_tail_ptr;
2055
	u32 sring_stat;
2056
	u32 tail_ptr;
2057

2058
	if (tag_len < sizeof(*htt_stats_buf))
2059
		return;
2060

2061
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__ring_id__arena__ep);
2062
	avail_words = __le32_to_cpu(htt_stats_buf->num_avail_words__num_valid_words);
2063
	head_tail_ptr = __le32_to_cpu(htt_stats_buf->head_ptr__tail_ptr);
2064
	sring_stat = __le32_to_cpu(htt_stats_buf->consumer_empty__producer_full);
2065
	tail_ptr = __le32_to_cpu(htt_stats_buf->prefetch_count__internal_tail_ptr);
2066

2067
	len += scnprintf(buf + len, buf_len - len, "HTT_SRING_STATS_TLV:\n");
2068
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
2069
			 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_MAC_ID));
2070
	len += scnprintf(buf + len, buf_len - len, "ring_id = %u\n",
2071
			 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_RING_ID));
2072
	len += scnprintf(buf + len, buf_len - len, "arena = %u\n",
2073
			 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_ARENA));
2074
	len += scnprintf(buf + len, buf_len - len, "ep = %u\n",
2075
			 u32_get_bits(mac_id_word, ATH12K_HTT_SRING_STATS_EP));
2076
	len += scnprintf(buf + len, buf_len - len, "base_addr_lsb = 0x%x\n",
2077
			 le32_to_cpu(htt_stats_buf->base_addr_lsb));
2078
	len += scnprintf(buf + len, buf_len - len, "base_addr_msb = 0x%x\n",
2079
			 le32_to_cpu(htt_stats_buf->base_addr_msb));
2080
	len += scnprintf(buf + len, buf_len - len, "ring_size = %u\n",
2081
			 le32_to_cpu(htt_stats_buf->ring_size));
2082
	len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n",
2083
			 le32_to_cpu(htt_stats_buf->elem_size));
2084
	len += scnprintf(buf + len, buf_len - len, "num_avail_words = %u\n",
2085
			 u32_get_bits(avail_words,
2086
				      ATH12K_HTT_SRING_STATS_NUM_AVAIL_WORDS));
2087
	len += scnprintf(buf + len, buf_len - len, "num_valid_words = %u\n",
2088
			 u32_get_bits(avail_words,
2089
				      ATH12K_HTT_SRING_STATS_NUM_VALID_WORDS));
2090
	len += scnprintf(buf + len, buf_len - len, "head_ptr = %u\n",
2091
			 u32_get_bits(head_tail_ptr, ATH12K_HTT_SRING_STATS_HEAD_PTR));
2092
	len += scnprintf(buf + len, buf_len - len, "tail_ptr = %u\n",
2093
			 u32_get_bits(head_tail_ptr, ATH12K_HTT_SRING_STATS_TAIL_PTR));
2094
	len += scnprintf(buf + len, buf_len - len, "consumer_empty = %u\n",
2095
			 u32_get_bits(sring_stat,
2096
				      ATH12K_HTT_SRING_STATS_CONSUMER_EMPTY));
2097
	len += scnprintf(buf + len, buf_len - len, "producer_full = %u\n",
2098
			 u32_get_bits(head_tail_ptr,
2099
				      ATH12K_HTT_SRING_STATS_PRODUCER_FULL));
2100
	len += scnprintf(buf + len, buf_len - len, "prefetch_count = %u\n",
2101
			 u32_get_bits(tail_ptr, ATH12K_HTT_SRING_STATS_PREFETCH_COUNT));
2102
	len += scnprintf(buf + len, buf_len - len, "internal_tail_ptr = %u\n\n",
2103
			 u32_get_bits(tail_ptr,
2104
				      ATH12K_HTT_SRING_STATS_INTERNAL_TAIL_PTR));
2105

2106
	stats_req->buf_len = len;
2107
}
2108

2109
static void
2110
ath12k_htt_print_sfm_cmn_tlv(const void *tag_buf, u16 tag_len,
2111
			     struct debug_htt_stats_req *stats_req)
2112
{
2113
	const struct ath12k_htt_sfm_cmn_tlv *htt_stats_buf = tag_buf;
2114
	u8 *buf = stats_req->buf;
2115
	u32 len = stats_req->buf_len;
2116
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2117
	u32 mac_id_word;
2118

2119
	if (tag_len < sizeof(*htt_stats_buf))
2120
		return;
2121

2122
	mac_id_word = __le32_to_cpu(htt_stats_buf->mac_id__word);
2123

2124
	len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CMN_TLV:\n");
2125
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
2126
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
2127
	len += scnprintf(buf + len, buf_len - len, "buf_total = %u\n",
2128
			 le32_to_cpu(htt_stats_buf->buf_total));
2129
	len += scnprintf(buf + len, buf_len - len, "mem_empty = %u\n",
2130
			 le32_to_cpu(htt_stats_buf->mem_empty));
2131
	len += scnprintf(buf + len, buf_len - len, "deallocate_bufs = %u\n",
2132
			 le32_to_cpu(htt_stats_buf->deallocate_bufs));
2133
	len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n",
2134
			 le32_to_cpu(htt_stats_buf->num_records));
2135

2136
	stats_req->buf_len = len;
2137
}
2138

2139
static void
2140
ath12k_htt_print_sfm_client_tlv(const void *tag_buf, u16 tag_len,
2141
				struct debug_htt_stats_req *stats_req)
2142
{
2143
	const struct ath12k_htt_sfm_client_tlv *htt_stats_buf = tag_buf;
2144
	u8 *buf = stats_req->buf;
2145
	u32 len = stats_req->buf_len;
2146
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2147

2148
	if (tag_len < sizeof(*htt_stats_buf))
2149
		return;
2150

2151
	len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_TLV:\n");
2152
	len += scnprintf(buf + len, buf_len - len, "client_id = %u\n",
2153
			 le32_to_cpu(htt_stats_buf->client_id));
2154
	len += scnprintf(buf + len, buf_len - len, "buf_min = %u\n",
2155
			 le32_to_cpu(htt_stats_buf->buf_min));
2156
	len += scnprintf(buf + len, buf_len - len, "buf_max = %u\n",
2157
			 le32_to_cpu(htt_stats_buf->buf_max));
2158
	len += scnprintf(buf + len, buf_len - len, "buf_busy = %u\n",
2159
			 le32_to_cpu(htt_stats_buf->buf_busy));
2160
	len += scnprintf(buf + len, buf_len - len, "buf_alloc = %u\n",
2161
			 le32_to_cpu(htt_stats_buf->buf_alloc));
2162
	len += scnprintf(buf + len, buf_len - len, "buf_avail = %u\n",
2163
			 le32_to_cpu(htt_stats_buf->buf_avail));
2164
	len += scnprintf(buf + len, buf_len - len, "num_users = %u\n\n",
2165
			 le32_to_cpu(htt_stats_buf->num_users));
2166

2167
	stats_req->buf_len = len;
2168
}
2169

2170
static void
2171
ath12k_htt_print_sfm_client_user_tlv(const void *tag_buf, u16 tag_len,
2172
				     struct debug_htt_stats_req *stats_req)
2173
{
2174
	const struct ath12k_htt_sfm_client_user_tlv *htt_stats_buf = tag_buf;
2175
	u8 *buf = stats_req->buf;
2176
	u32 len = stats_req->buf_len;
2177
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2178
	u16 num_elems = tag_len >> 2;
2179

2180
	len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_USER_TLV:\n");
2181
	len += print_array_to_buf(buf, len, "dwords_used_by_user_n",
2182
				  htt_stats_buf->dwords_used_by_user_n,
2183
				  num_elems, "\n\n");
2184

2185
	stats_req->buf_len = len;
2186
}
2187

2188
static void
2189
ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(const void *tag_buf, u16 tag_len,
2190
					       struct debug_htt_stats_req *stats_req)
2191
{
2192
	const struct ath12k_htt_tx_pdev_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf;
2193
	u8 *buf = stats_req->buf;
2194
	u32 len = stats_req->buf_len;
2195
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2196
	u8 i;
2197

2198
	if (tag_len < sizeof(*htt_stats_buf))
2199
		return;
2200

2201
	len += scnprintf(buf + len, buf_len - len,
2202
			 "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n");
2203
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
2204
			 le32_to_cpu(htt_stats_buf->mu_mimo_sch_posted));
2205
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
2206
			 le32_to_cpu(htt_stats_buf->mu_mimo_sch_failed));
2207
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n",
2208
			 le32_to_cpu(htt_stats_buf->mu_mimo_ppdu_posted));
2209
	len += scnprintf(buf + len, buf_len - len,
2210
			 "\nac_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0,
2211
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_per_grp_sz[0]));
2212
	for (i = 1; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) {
2213
		len += scnprintf(buf + len, buf_len - len,
2214
				 "ac_mu_mimo_sch_posted_per_group_index %u ", i);
2215
		len += scnprintf(buf + len, buf_len - len,
2216
				 "(TOTAL STREAMS = %u) = %u\n", i + 1,
2217
				 le32_to_cpu(htt_stats_buf->ac_mu_mimo_per_grp_sz[i]));
2218
	}
2219

2220
	for (i = 0; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) {
2221
		len += scnprintf(buf + len, buf_len - len,
2222
				 "ac_mu_mimo_sch_posted_per_group_index %u ",
2223
				 i + ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS);
2224
		len += scnprintf(buf + len, buf_len - len,
2225
				 "(TOTAL STREAMS = %u) = %u\n",
2226
				 i + ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS + 1,
2227
				 le32_to_cpu(htt_stats_buf->ac_mu_mimo_grp_sz_ext[i]));
2228
	}
2229

2230
	len += scnprintf(buf + len, buf_len - len,
2231
			 "\nax_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0,
2232
			 le32_to_cpu(htt_stats_buf->ax_mu_mimo_per_grp_sz[0]));
2233
	for (i = 1; i < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; i++) {
2234
		len += scnprintf(buf + len, buf_len - len,
2235
				 "ax_mu_mimo_sch_posted_per_group_index %u ", i);
2236
		len += scnprintf(buf + len, buf_len - len,
2237
				 "(TOTAL STREAMS = %u) = %u\n", i + 1,
2238
				 le32_to_cpu(htt_stats_buf->ax_mu_mimo_per_grp_sz[i]));
2239
	}
2240

2241
	len += scnprintf(buf + len, buf_len - len,
2242
			"\nbe_mu_mimo_sch_posted_per_group_index %u (SU) = %u\n", 0,
2243
			le32_to_cpu(htt_stats_buf->be_mu_mimo_per_grp_sz[0]));
2244
	for (i = 1; i < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; i++) {
2245
		len += scnprintf(buf + len, buf_len - len,
2246
				 "be_mu_mimo_sch_posted_per_group_index %u ", i);
2247
		len += scnprintf(buf + len, buf_len - len,
2248
				 "(TOTAL STREAMS = %u) = %u\n", i + 1,
2249
				 le32_to_cpu(htt_stats_buf->be_mu_mimo_per_grp_sz[i]));
2250
	}
2251

2252
	len += scnprintf(buf + len, buf_len - len, "\n11ac MU_MIMO SCH STATS:\n");
2253
	for (i = 0; i < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; i++) {
2254
		len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_sch_nusers_");
2255
		len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i,
2256
				 le32_to_cpu(htt_stats_buf->ac_mu_mimo_sch_nusers[i]));
2257
	}
2258

2259
	len += scnprintf(buf + len, buf_len - len, "\n11ax MU_MIMO SCH STATS:\n");
2260
	for (i = 0; i < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; i++) {
2261
		len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_sch_nusers_");
2262
		len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i,
2263
				 le32_to_cpu(htt_stats_buf->ax_mu_mimo_sch_nusers[i]));
2264
	}
2265

2266
	len += scnprintf(buf + len, buf_len - len, "\n11be MU_MIMO SCH STATS:\n");
2267
	for (i = 0; i < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; i++) {
2268
		len += scnprintf(buf + len, buf_len - len, "be_mu_mimo_sch_nusers_");
2269
		len += scnprintf(buf + len, buf_len - len, "%u = %u\n", i,
2270
				 le32_to_cpu(htt_stats_buf->be_mu_mimo_sch_nusers[i]));
2271
	}
2272

2273
	len += scnprintf(buf + len, buf_len - len, "\n11ax OFDMA SCH STATS:\n");
2274
	for (i = 0; i < ATH12K_HTT_TX_NUM_OFDMA_USER_STATS; i++) {
2275
		len += scnprintf(buf + len, buf_len - len,
2276
				 "ax_ofdma_sch_nusers_%u = %u\n", i,
2277
				 le32_to_cpu(htt_stats_buf->ax_ofdma_sch_nusers[i]));
2278
		len += scnprintf(buf + len, buf_len - len,
2279
				 "ax_ul_ofdma_basic_sch_nusers_%u = %u\n", i,
2280
				 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_nusers[i]));
2281
		len += scnprintf(buf + len, buf_len - len,
2282
				 "ax_ul_ofdma_bsr_sch_nusers_%u = %u\n", i,
2283
				 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_bsr_nusers[i]));
2284
		len += scnprintf(buf + len, buf_len - len,
2285
				 "ax_ul_ofdma_bar_sch_nusers_%u = %u\n", i,
2286
				 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_bar_nusers[i]));
2287
		len += scnprintf(buf + len, buf_len - len,
2288
				 "ax_ul_ofdma_brp_sch_nusers_%u = %u\n\n", i,
2289
				 le32_to_cpu(htt_stats_buf->ax_ul_ofdma_brp_nusers[i]));
2290
	}
2291

2292
	len += scnprintf(buf + len, buf_len - len, "11ax UL MUMIMO SCH STATS:\n");
2293
	for (i = 0; i < ATH12K_HTT_TX_NUM_UL_MUMIMO_USER_STATS; i++) {
2294
		len += scnprintf(buf + len, buf_len - len,
2295
				 "ax_ul_mumimo_basic_sch_nusers_%u = %u\n", i,
2296
				 le32_to_cpu(htt_stats_buf->ax_ul_mumimo_nusers[i]));
2297
		len += scnprintf(buf + len, buf_len - len,
2298
				 "ax_ul_mumimo_brp_sch_nusers_%u = %u\n\n", i,
2299
				 le32_to_cpu(htt_stats_buf->ax_ul_mumimo_brp_nusers[i]));
2300
	}
2301

2302
	stats_req->buf_len = len;
2303
}
2304

2305
static void
2306
ath12k_htt_print_tx_pdev_mumimo_grp_stats_tlv(const void *tag_buf, u16 tag_len,
2307
					      struct debug_htt_stats_req *stats_req)
2308
{
2309
	const struct ath12k_htt_tx_pdev_mumimo_grp_stats_tlv *htt_stats_buf = tag_buf;
2310
	u8 *buf = stats_req->buf;
2311
	u32 len = stats_req->buf_len;
2312
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2313
	int j;
2314

2315
	if (tag_len < sizeof(*htt_stats_buf))
2316
		return;
2317

2318
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_MUMIMO_GRP_STATS:\n");
2319
	len += print_array_to_buf(buf, len,
2320
				  "dl_mumimo_grp_tputs_observed (per bin = 300 mbps)",
2321
				  htt_stats_buf->dl_mumimo_grp_tputs,
2322
				  ATH12K_HTT_STATS_MUMIMO_TPUT_NUM_BINS, "\n");
2323
	len += print_array_to_buf(buf, len, "dl_mumimo_grp eligible",
2324
				  htt_stats_buf->dl_mumimo_grp_eligible,
2325
				  ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n");
2326
	len += print_array_to_buf(buf, len, "dl_mumimo_grp_ineligible",
2327
				  htt_stats_buf->dl_mumimo_grp_ineligible,
2328
				  ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n");
2329
	len += scnprintf(buf + len, buf_len - len, "dl_mumimo_grp_invalid:\n");
2330
	for (j = 0; j < ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ; j++) {
2331
		len += scnprintf(buf + len, buf_len - len, "grp_id = %u", j);
2332
		len += print_array_to_buf(buf, len, "",
2333
					  htt_stats_buf->dl_mumimo_grp_invalid,
2334
					  ATH12K_HTT_STATS_MAX_INVALID_REASON_CODE,
2335
					  "\n");
2336
	}
2337

2338
	len += print_array_to_buf(buf, len, "ul_mumimo_grp_best_grp_size",
2339
				  htt_stats_buf->ul_mumimo_grp_best_grp_size,
2340
				  ATH12K_HTT_STATS_NUM_MAX_MUMIMO_SZ, "\n");
2341
	len += print_array_to_buf(buf, len, "ul_mumimo_grp_best_num_usrs = ",
2342
				  htt_stats_buf->ul_mumimo_grp_best_usrs,
2343
				  ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS, "\n");
2344
	len += print_array_to_buf(buf, len,
2345
				  "ul_mumimo_grp_tputs_observed (per bin = 300 mbps)",
2346
				  htt_stats_buf->ul_mumimo_grp_tputs,
2347
				  ATH12K_HTT_STATS_MUMIMO_TPUT_NUM_BINS, "\n\n");
2348

2349
	stats_req->buf_len = len;
2350
}
2351

2352
static void
2353
ath12k_htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(const void *tag_buf, u16 tag_len,
2354
						struct debug_htt_stats_req *stats_req)
2355
{
2356
	const struct ath12k_htt_tx_pdev_mpdu_stats_tlv *htt_stats_buf = tag_buf;
2357
	u8 *buf = stats_req->buf;
2358
	u32 len = stats_req->buf_len;
2359
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2360
	u32 user_index;
2361
	u32 tx_sched_mode;
2362

2363
	if (tag_len < sizeof(*htt_stats_buf))
2364
		return;
2365

2366
	user_index = __le32_to_cpu(htt_stats_buf->user_index);
2367
	tx_sched_mode = __le32_to_cpu(htt_stats_buf->tx_sched_mode);
2368

2369
	if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_MIMO_AC) {
2370
		if (!user_index)
2371
			len += scnprintf(buf + len, buf_len - len,
2372
					 "HTT_TX_PDEV_MU_MIMO_AC_MPDU_STATS:\n");
2373

2374
		if (user_index < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS) {
2375
			len += scnprintf(buf + len, buf_len - len,
2376
					 "ac_mu_mimo_mpdus_queued_usr_%u = %u\n",
2377
					 user_index,
2378
					 le32_to_cpu(htt_stats_buf->mpdus_queued_usr));
2379
			len += scnprintf(buf + len, buf_len - len,
2380
					 "ac_mu_mimo_mpdus_tried_usr_%u = %u\n",
2381
					 user_index,
2382
					 le32_to_cpu(htt_stats_buf->mpdus_tried_usr));
2383
			len += scnprintf(buf + len, buf_len - len,
2384
					 "ac_mu_mimo_mpdus_failed_usr_%u = %u\n",
2385
					 user_index,
2386
					 le32_to_cpu(htt_stats_buf->mpdus_failed_usr));
2387
			len += scnprintf(buf + len, buf_len - len,
2388
					 "ac_mu_mimo_mpdus_requeued_usr_%u = %u\n",
2389
					 user_index,
2390
					 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr));
2391
			len += scnprintf(buf + len, buf_len - len,
2392
					 "ac_mu_mimo_err_no_ba_usr_%u = %u\n",
2393
					 user_index,
2394
					 le32_to_cpu(htt_stats_buf->err_no_ba_usr));
2395
			len += scnprintf(buf + len, buf_len - len,
2396
					 "ac_mu_mimo_mpdu_underrun_usr_%u = %u\n",
2397
					 user_index,
2398
					 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr));
2399
			len += scnprintf(buf + len, buf_len - len,
2400
					"ac_mu_mimo_ampdu_underrun_usr_%u = %u\n\n",
2401
					 user_index,
2402
					 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr));
2403
		}
2404
	}
2405

2406
	if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_MIMO_AX) {
2407
		if (!user_index)
2408
			len += scnprintf(buf + len, buf_len - len,
2409
					 "HTT_TX_PDEV_MU_MIMO_AX_MPDU_STATS:\n");
2410

2411
		if (user_index < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS) {
2412
			len += scnprintf(buf + len, buf_len - len,
2413
					 "ax_mu_mimo_mpdus_queued_usr_%u = %u\n",
2414
					 user_index,
2415
					 le32_to_cpu(htt_stats_buf->mpdus_queued_usr));
2416
			len += scnprintf(buf + len, buf_len - len,
2417
					 "ax_mu_mimo_mpdus_tried_usr_%u = %u\n",
2418
					 user_index,
2419
					 le32_to_cpu(htt_stats_buf->mpdus_tried_usr));
2420
			len += scnprintf(buf + len, buf_len - len,
2421
					 "ax_mu_mimo_mpdus_failed_usr_%u = %u\n",
2422
					 user_index,
2423
					 le32_to_cpu(htt_stats_buf->mpdus_failed_usr));
2424
			len += scnprintf(buf + len, buf_len - len,
2425
					 "ax_mu_mimo_mpdus_requeued_usr_%u = %u\n",
2426
					 user_index,
2427
					 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr));
2428
			len += scnprintf(buf + len, buf_len - len,
2429
					 "ax_mu_mimo_err_no_ba_usr_%u = %u\n",
2430
					 user_index,
2431
					 le32_to_cpu(htt_stats_buf->err_no_ba_usr));
2432
			len += scnprintf(buf + len, buf_len - len,
2433
					 "ax_mu_mimo_mpdu_underrun_usr_%u = %u\n",
2434
					 user_index,
2435
					 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr));
2436
			len += scnprintf(buf + len, buf_len - len,
2437
					 "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n\n",
2438
					 user_index,
2439
					 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr));
2440
		}
2441
	}
2442

2443
	if (tx_sched_mode == ATH12K_HTT_STATS_TX_SCHED_MODE_MU_OFDMA_AX) {
2444
		if (!user_index)
2445
			len += scnprintf(buf + len, buf_len - len,
2446
					 "HTT_TX_PDEV_AX_MU_OFDMA_MPDU_STATS:\n");
2447

2448
		if (user_index < ATH12K_HTT_TX_NUM_OFDMA_USER_STATS) {
2449
			len += scnprintf(buf + len, buf_len - len,
2450
					 "ax_mu_ofdma_mpdus_queued_usr_%u = %u\n",
2451
					 user_index,
2452
					 le32_to_cpu(htt_stats_buf->mpdus_queued_usr));
2453
			len += scnprintf(buf + len, buf_len - len,
2454
					 "ax_mu_ofdma_mpdus_tried_usr_%u = %u\n",
2455
					 user_index,
2456
					 le32_to_cpu(htt_stats_buf->mpdus_tried_usr));
2457
			len += scnprintf(buf + len, buf_len - len,
2458
					 "ax_mu_ofdma_mpdus_failed_usr_%u = %u\n",
2459
					 user_index,
2460
					 le32_to_cpu(htt_stats_buf->mpdus_failed_usr));
2461
			len += scnprintf(buf + len, buf_len - len,
2462
					 "ax_mu_ofdma_mpdus_requeued_usr_%u = %u\n",
2463
					 user_index,
2464
					 le32_to_cpu(htt_stats_buf->mpdus_requeued_usr));
2465
			len += scnprintf(buf + len, buf_len - len,
2466
					 "ax_mu_ofdma_err_no_ba_usr_%u = %u\n",
2467
					 user_index,
2468
					 le32_to_cpu(htt_stats_buf->err_no_ba_usr));
2469
			len += scnprintf(buf + len, buf_len - len,
2470
					 "ax_mu_ofdma_mpdu_underrun_usr_%u = %u\n",
2471
					 user_index,
2472
					 le32_to_cpu(htt_stats_buf->mpdu_underrun_usr));
2473
			len += scnprintf(buf + len, buf_len - len,
2474
					 "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n\n",
2475
					 user_index,
2476
					 le32_to_cpu(htt_stats_buf->ampdu_underrun_usr));
2477
		}
2478
	}
2479

2480
	stats_req->buf_len = len;
2481
}
2482

2483
static void
2484
ath12k_htt_print_pdev_cca_stats_hist_tlv(const void *tag_buf, u16 tag_len,
2485
					 struct debug_htt_stats_req *stats_req)
2486
{
2487
	const struct ath12k_htt_pdev_cca_stats_hist_v1_tlv *htt_stats_buf = tag_buf;
2488
	u8 *buf = stats_req->buf;
2489
	u32 len = stats_req->buf_len;
2490
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2491

2492
	if (tag_len < sizeof(*htt_stats_buf))
2493
		return;
2494

2495
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_CCA_STATS_HIST_TLV :\n");
2496
	len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n",
2497
			 le32_to_cpu(htt_stats_buf->chan_num));
2498
	len += scnprintf(buf + len, buf_len - len, "num_records = %u\n",
2499
			 le32_to_cpu(htt_stats_buf->num_records));
2500
	len += scnprintf(buf + len, buf_len - len, "valid_cca_counters_bitmap = 0x%x\n",
2501
			 le32_to_cpu(htt_stats_buf->valid_cca_counters_bitmap));
2502
	len += scnprintf(buf + len, buf_len - len, "collection_interval = %u\n\n",
2503
			 le32_to_cpu(htt_stats_buf->collection_interval));
2504

2505
	stats_req->buf_len = len;
2506
}
2507

2508
static void
2509
ath12k_htt_print_pdev_stats_cca_counters_tlv(const void *tag_buf, u16 tag_len,
2510
					     struct debug_htt_stats_req *stats_req)
2511
{
2512
	const struct ath12k_htt_pdev_stats_cca_counters_tlv *htt_stats_buf = tag_buf;
2513
	u8 *buf = stats_req->buf;
2514
	u32 len = stats_req->buf_len;
2515
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2516

2517
	if (tag_len < sizeof(*htt_stats_buf))
2518
		return;
2519

2520
	len += scnprintf(buf + len, buf_len - len,
2521
			 "HTT_PDEV_STATS_CCA_COUNTERS_TLV:(in usec)\n");
2522
	len += scnprintf(buf + len, buf_len - len, "tx_frame_usec = %u\n",
2523
			 le32_to_cpu(htt_stats_buf->tx_frame_usec));
2524
	len += scnprintf(buf + len, buf_len - len, "rx_frame_usec = %u\n",
2525
			 le32_to_cpu(htt_stats_buf->rx_frame_usec));
2526
	len += scnprintf(buf + len, buf_len - len, "rx_clear_usec = %u\n",
2527
			 le32_to_cpu(htt_stats_buf->rx_clear_usec));
2528
	len += scnprintf(buf + len, buf_len - len, "my_rx_frame_usec = %u\n",
2529
			 le32_to_cpu(htt_stats_buf->my_rx_frame_usec));
2530
	len += scnprintf(buf + len, buf_len - len, "usec_cnt = %u\n",
2531
			 le32_to_cpu(htt_stats_buf->usec_cnt));
2532
	len += scnprintf(buf + len, buf_len - len, "med_rx_idle_usec = %u\n",
2533
			 le32_to_cpu(htt_stats_buf->med_rx_idle_usec));
2534
	len += scnprintf(buf + len, buf_len - len, "med_tx_idle_global_usec = %u\n",
2535
			 le32_to_cpu(htt_stats_buf->med_tx_idle_global_usec));
2536
	len += scnprintf(buf + len, buf_len - len, "cca_obss_usec = %u\n\n",
2537
			 le32_to_cpu(htt_stats_buf->cca_obss_usec));
2538

2539
	stats_req->buf_len = len;
2540
}
2541

2542
static void
2543
ath12k_htt_print_tx_sounding_stats_tlv(const void *tag_buf, u16 tag_len,
2544
				       struct debug_htt_stats_req *stats_req)
2545
{
2546
	const struct ath12k_htt_tx_sounding_stats_tlv *htt_stats_buf = tag_buf;
2547
	const __le32 *cbf_20, *cbf_40, *cbf_80, *cbf_160, *cbf_320;
2548
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2549
	u32 len = stats_req->buf_len;
2550
	u8 *buf = stats_req->buf;
2551
	u32 tx_sounding_mode;
2552
	u8 i, u;
2553

2554
	if (tag_len < sizeof(*htt_stats_buf))
2555
		return;
2556

2557
	cbf_20 = htt_stats_buf->cbf_20;
2558
	cbf_40 = htt_stats_buf->cbf_40;
2559
	cbf_80 = htt_stats_buf->cbf_80;
2560
	cbf_160 = htt_stats_buf->cbf_160;
2561
	cbf_320 = htt_stats_buf->cbf_320;
2562
	tx_sounding_mode = le32_to_cpu(htt_stats_buf->tx_sounding_mode);
2563

2564
	if (tx_sounding_mode == ATH12K_HTT_TX_AC_SOUNDING_MODE) {
2565
		len += scnprintf(buf + len, buf_len - len,
2566
				 "HTT_TX_AC_SOUNDING_STATS_TLV:\n");
2567
		len += scnprintf(buf + len, buf_len - len,
2568
				 "ac_cbf_20 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2569
				 le32_to_cpu(cbf_20[ATH12K_HTT_IMPL_STEER_STATS]),
2570
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2571
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2572
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2573
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2574
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2575
		len += scnprintf(buf + len, buf_len - len,
2576
				 "ac_cbf_40 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2577
				 le32_to_cpu(cbf_40[ATH12K_HTT_IMPL_STEER_STATS]),
2578
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2579
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2580
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2581
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2582
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2583
		len += scnprintf(buf + len, buf_len - len,
2584
				 "ac_cbf_80 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2585
				 le32_to_cpu(cbf_80[ATH12K_HTT_IMPL_STEER_STATS]),
2586
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2587
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2588
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2589
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2590
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2591
		len += scnprintf(buf + len, buf_len - len,
2592
				 "ac_cbf_160 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2593
				 le32_to_cpu(cbf_160[ATH12K_HTT_IMPL_STEER_STATS]),
2594
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2595
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2596
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2597
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2598
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2599

2600
		for (u = 0, i = 0; u < ATH12K_HTT_TX_NUM_AC_MUMIMO_USER_STATS; u++) {
2601
			len += scnprintf(buf + len, buf_len - len,
2602
					 "Sounding User_%u = 20MHz: %u, ", u,
2603
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2604
			len += scnprintf(buf + len, buf_len - len, "40MHz: %u, ",
2605
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2606
			len += scnprintf(buf + len, buf_len - len, "80MHz: %u, ",
2607
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2608
			len += scnprintf(buf + len, buf_len - len, "160MHz: %u\n",
2609
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2610
		}
2611
	} else if (tx_sounding_mode == ATH12K_HTT_TX_AX_SOUNDING_MODE) {
2612
		len += scnprintf(buf + len, buf_len - len,
2613
				 "\nHTT_TX_AX_SOUNDING_STATS_TLV:\n");
2614
		len += scnprintf(buf + len, buf_len - len,
2615
				 "ax_cbf_20 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2616
				 le32_to_cpu(cbf_20[ATH12K_HTT_IMPL_STEER_STATS]),
2617
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2618
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2619
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2620
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2621
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2622
		len += scnprintf(buf + len, buf_len - len,
2623
				 "ax_cbf_40 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2624
				 le32_to_cpu(cbf_40[ATH12K_HTT_IMPL_STEER_STATS]),
2625
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2626
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2627
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2628
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2629
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2630
		len += scnprintf(buf + len, buf_len - len,
2631
				 "ax_cbf_80 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2632
				 le32_to_cpu(cbf_80[ATH12K_HTT_IMPL_STEER_STATS]),
2633
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2634
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2635
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2636
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2637
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2638
		len += scnprintf(buf + len, buf_len - len,
2639
				 "ax_cbf_160 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2640
				 le32_to_cpu(cbf_160[ATH12K_HTT_IMPL_STEER_STATS]),
2641
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2642
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2643
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2644
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2645
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2646

2647
		for (u = 0, i = 0; u < ATH12K_HTT_TX_NUM_AX_MUMIMO_USER_STATS; u++) {
2648
			len += scnprintf(buf + len, buf_len - len,
2649
					 "Sounding User_%u = 20MHz: %u, ", u,
2650
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2651
			len += scnprintf(buf + len, buf_len - len, "40MHz: %u, ",
2652
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2653
			len += scnprintf(buf + len, buf_len - len, "80MHz: %u, ",
2654
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2655
			len += scnprintf(buf + len, buf_len - len, "160MHz: %u\n",
2656
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2657
		}
2658
	} else if (tx_sounding_mode == ATH12K_HTT_TX_BE_SOUNDING_MODE) {
2659
		len += scnprintf(buf + len, buf_len - len,
2660
				 "\nHTT_TX_BE_SOUNDING_STATS_TLV:\n");
2661
		len += scnprintf(buf + len, buf_len - len,
2662
				 "be_cbf_20 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2663
				 le32_to_cpu(cbf_20[ATH12K_HTT_IMPL_STEER_STATS]),
2664
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2665
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2666
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2667
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2668
				 le32_to_cpu(cbf_20[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2669
		len += scnprintf(buf + len, buf_len - len,
2670
				 "be_cbf_40 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2671
				 le32_to_cpu(cbf_40[ATH12K_HTT_IMPL_STEER_STATS]),
2672
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2673
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2674
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2675
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2676
				 le32_to_cpu(cbf_40[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2677
		len += scnprintf(buf + len, buf_len - len,
2678
				 "be_cbf_80 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2679
				 le32_to_cpu(cbf_80[ATH12K_HTT_IMPL_STEER_STATS]),
2680
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2681
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2682
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2683
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2684
				 le32_to_cpu(cbf_80[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2685
		len += scnprintf(buf + len, buf_len - len,
2686
				 "be_cbf_160 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2687
				 le32_to_cpu(cbf_160[ATH12K_HTT_IMPL_STEER_STATS]),
2688
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2689
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2690
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2691
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2692
				 le32_to_cpu(cbf_160[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2693
		len += scnprintf(buf + len, buf_len - len,
2694
				 "be_cbf_320 = IBF: %u, SU_SIFS: %u, SU_RBO: %u, ",
2695
				 le32_to_cpu(cbf_320[ATH12K_HTT_IMPL_STEER_STATS]),
2696
				 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_SUSIFS_STEER_STATS]),
2697
				 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_SURBO_STEER_STATS]));
2698
		len += scnprintf(buf + len, buf_len - len, "MU_SIFS: %u, MU_RBO: %u\n",
2699
				 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_MUSIFS_STEER_STATS]),
2700
				 le32_to_cpu(cbf_320[ATH12K_HTT_EXPL_MURBO_STEER_STATS]));
2701
		for (u = 0, i = 0; u < ATH12K_HTT_TX_NUM_BE_MUMIMO_USER_STATS; u++) {
2702
			len += scnprintf(buf + len, buf_len - len,
2703
					 "Sounding User_%u = 20MHz: %u, ", u,
2704
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2705
			len += scnprintf(buf + len, buf_len - len, "40MHz: %u, ",
2706
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2707
			len += scnprintf(buf + len, buf_len - len, "80MHz: %u, ",
2708
					 le32_to_cpu(htt_stats_buf->sounding[i++]));
2709
			len += scnprintf(buf + len, buf_len - len,
2710
					 "160MHz: %u, 320MHz: %u\n",
2711
					 le32_to_cpu(htt_stats_buf->sounding[i++]),
2712
					 le32_to_cpu(htt_stats_buf->sounding_320[u]));
2713
		}
2714
	} else if (tx_sounding_mode == ATH12K_HTT_TX_CMN_SOUNDING_MODE) {
2715
		len += scnprintf(buf + len, buf_len - len,
2716
				 "\nCV UPLOAD HANDLER STATS:\n");
2717
		len += scnprintf(buf + len, buf_len - len, "cv_nc_mismatch_err = %u\n",
2718
				 le32_to_cpu(htt_stats_buf->cv_nc_mismatch_err));
2719
		len += scnprintf(buf + len, buf_len - len, "cv_fcs_err = %u\n",
2720
				 le32_to_cpu(htt_stats_buf->cv_fcs_err));
2721
		len += scnprintf(buf + len, buf_len - len, "cv_frag_idx_mismatch = %u\n",
2722
				 le32_to_cpu(htt_stats_buf->cv_frag_idx_mismatch));
2723
		len += scnprintf(buf + len, buf_len - len, "cv_invalid_peer_id = %u\n",
2724
				 le32_to_cpu(htt_stats_buf->cv_invalid_peer_id));
2725
		len += scnprintf(buf + len, buf_len - len, "cv_no_txbf_setup = %u\n",
2726
				 le32_to_cpu(htt_stats_buf->cv_no_txbf_setup));
2727
		len += scnprintf(buf + len, buf_len - len, "cv_expiry_in_update = %u\n",
2728
				 le32_to_cpu(htt_stats_buf->cv_expiry_in_update));
2729
		len += scnprintf(buf + len, buf_len - len, "cv_pkt_bw_exceed = %u\n",
2730
				 le32_to_cpu(htt_stats_buf->cv_pkt_bw_exceed));
2731
		len += scnprintf(buf + len, buf_len - len, "cv_dma_not_done_err = %u\n",
2732
				 le32_to_cpu(htt_stats_buf->cv_dma_not_done_err));
2733
		len += scnprintf(buf + len, buf_len - len, "cv_update_failed = %u\n",
2734
				 le32_to_cpu(htt_stats_buf->cv_update_failed));
2735
		len += scnprintf(buf + len, buf_len - len, "cv_dma_timeout_error = %u\n",
2736
				 le32_to_cpu(htt_stats_buf->cv_dma_timeout_error));
2737
		len += scnprintf(buf + len, buf_len - len, "cv_buf_ibf_uploads = %u\n",
2738
				 le32_to_cpu(htt_stats_buf->cv_buf_ibf_uploads));
2739
		len += scnprintf(buf + len, buf_len - len, "cv_buf_ebf_uploads = %u\n",
2740
				 le32_to_cpu(htt_stats_buf->cv_buf_ebf_uploads));
2741
		len += scnprintf(buf + len, buf_len - len, "cv_buf_received = %u\n",
2742
				 le32_to_cpu(htt_stats_buf->cv_buf_received));
2743
		len += scnprintf(buf + len, buf_len - len, "cv_buf_fed_back = %u\n\n",
2744
				 le32_to_cpu(htt_stats_buf->cv_buf_fed_back));
2745

2746
		len += scnprintf(buf + len, buf_len - len, "CV QUERY STATS:\n");
2747
		len += scnprintf(buf + len, buf_len - len, "cv_total_query = %u\n",
2748
				 le32_to_cpu(htt_stats_buf->cv_total_query));
2749
		len += scnprintf(buf + len, buf_len - len,
2750
				 "cv_total_pattern_query = %u\n",
2751
				 le32_to_cpu(htt_stats_buf->cv_total_pattern_query));
2752
		len += scnprintf(buf + len, buf_len - len, "cv_total_bw_query = %u\n",
2753
				 le32_to_cpu(htt_stats_buf->cv_total_bw_query));
2754
		len += scnprintf(buf + len, buf_len - len, "cv_invalid_bw_coding = %u\n",
2755
				 le32_to_cpu(htt_stats_buf->cv_invalid_bw_coding));
2756
		len += scnprintf(buf + len, buf_len - len, "cv_forced_sounding = %u\n",
2757
				 le32_to_cpu(htt_stats_buf->cv_forced_sounding));
2758
		len += scnprintf(buf + len, buf_len - len,
2759
				 "cv_standalone_sounding = %u\n",
2760
				 le32_to_cpu(htt_stats_buf->cv_standalone_sounding));
2761
		len += scnprintf(buf + len, buf_len - len, "cv_nc_mismatch = %u\n",
2762
				 le32_to_cpu(htt_stats_buf->cv_nc_mismatch));
2763
		len += scnprintf(buf + len, buf_len - len, "cv_fb_type_mismatch = %u\n",
2764
				 le32_to_cpu(htt_stats_buf->cv_fb_type_mismatch));
2765
		len += scnprintf(buf + len, buf_len - len, "cv_ofdma_bw_mismatch = %u\n",
2766
				 le32_to_cpu(htt_stats_buf->cv_ofdma_bw_mismatch));
2767
		len += scnprintf(buf + len, buf_len - len, "cv_bw_mismatch = %u\n",
2768
				 le32_to_cpu(htt_stats_buf->cv_bw_mismatch));
2769
		len += scnprintf(buf + len, buf_len - len, "cv_pattern_mismatch = %u\n",
2770
				 le32_to_cpu(htt_stats_buf->cv_pattern_mismatch));
2771
		len += scnprintf(buf + len, buf_len - len, "cv_preamble_mismatch = %u\n",
2772
				 le32_to_cpu(htt_stats_buf->cv_preamble_mismatch));
2773
		len += scnprintf(buf + len, buf_len - len, "cv_nr_mismatch = %u\n",
2774
				 le32_to_cpu(htt_stats_buf->cv_nr_mismatch));
2775
		len += scnprintf(buf + len, buf_len - len,
2776
				 "cv_in_use_cnt_exceeded = %u\n",
2777
				 le32_to_cpu(htt_stats_buf->cv_in_use_cnt_exceeded));
2778
		len += scnprintf(buf + len, buf_len - len, "cv_ntbr_sounding = %u\n",
2779
				 le32_to_cpu(htt_stats_buf->cv_ntbr_sounding));
2780
		len += scnprintf(buf + len, buf_len - len,
2781
				 "cv_found_upload_in_progress = %u\n",
2782
				 le32_to_cpu(htt_stats_buf->cv_found_upload_in_progress));
2783
		len += scnprintf(buf + len, buf_len - len,
2784
				 "cv_expired_during_query = %u\n",
2785
				 le32_to_cpu(htt_stats_buf->cv_expired_during_query));
2786
		len += scnprintf(buf + len, buf_len - len, "cv_found = %u\n",
2787
				 le32_to_cpu(htt_stats_buf->cv_found));
2788
		len += scnprintf(buf + len, buf_len - len, "cv_not_found = %u\n",
2789
				 le32_to_cpu(htt_stats_buf->cv_not_found));
2790
		len += scnprintf(buf + len, buf_len - len, "cv_total_query_ibf = %u\n",
2791
				 le32_to_cpu(htt_stats_buf->cv_total_query_ibf));
2792
		len += scnprintf(buf + len, buf_len - len, "cv_found_ibf = %u\n",
2793
				 le32_to_cpu(htt_stats_buf->cv_found_ibf));
2794
		len += scnprintf(buf + len, buf_len - len, "cv_not_found_ibf = %u\n",
2795
				 le32_to_cpu(htt_stats_buf->cv_not_found_ibf));
2796
		len += scnprintf(buf + len, buf_len - len,
2797
				 "cv_expired_during_query_ibf = %u\n\n",
2798
				 le32_to_cpu(htt_stats_buf->cv_expired_during_query_ibf));
2799
	}
2800

2801
	stats_req->buf_len = len;
2802
}
2803

2804
static void
2805
ath12k_htt_print_pdev_obss_pd_stats_tlv(const void *tag_buf, u16 tag_len,
2806
					struct debug_htt_stats_req *stats_req)
2807
{
2808
	const struct ath12k_htt_pdev_obss_pd_stats_tlv *htt_stats_buf = tag_buf;
2809
	u8 *buf = stats_req->buf;
2810
	u32 len = stats_req->buf_len;
2811
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2812
	u8 i;
2813
	static const char *access_cat_names[ATH12K_HTT_NUM_AC_WMM] = {"best effort",
2814
								      "background",
2815
								      "video", "voice"};
2816

2817
	if (tag_len < sizeof(*htt_stats_buf))
2818
		return;
2819

2820
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_STATS_TLV:\n");
2821
	len += scnprintf(buf + len, buf_len - len, "num_spatial_reuse_tx = %u\n",
2822
			 le32_to_cpu(htt_stats_buf->num_sr_tx_transmissions));
2823
	len += scnprintf(buf + len, buf_len - len,
2824
			 "num_spatial_reuse_opportunities = %u\n",
2825
			 le32_to_cpu(htt_stats_buf->num_spatial_reuse_opportunities));
2826
	len += scnprintf(buf + len, buf_len - len, "num_non_srg_opportunities = %u\n",
2827
			 le32_to_cpu(htt_stats_buf->num_non_srg_opportunities));
2828
	len += scnprintf(buf + len, buf_len - len, "num_non_srg_ppdu_tried = %u\n",
2829
			 le32_to_cpu(htt_stats_buf->num_non_srg_ppdu_tried));
2830
	len += scnprintf(buf + len, buf_len - len, "num_non_srg_ppdu_success = %u\n",
2831
			 le32_to_cpu(htt_stats_buf->num_non_srg_ppdu_success));
2832
	len += scnprintf(buf + len, buf_len - len, "num_srg_opportunities = %u\n",
2833
			 le32_to_cpu(htt_stats_buf->num_srg_opportunities));
2834
	len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_tried = %u\n",
2835
			 le32_to_cpu(htt_stats_buf->num_srg_ppdu_tried));
2836
	len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_success = %u\n",
2837
			 le32_to_cpu(htt_stats_buf->num_srg_ppdu_success));
2838
	len += scnprintf(buf + len, buf_len - len, "num_psr_opportunities = %u\n",
2839
			 le32_to_cpu(htt_stats_buf->num_psr_opportunities));
2840
	len += scnprintf(buf + len, buf_len - len, "num_psr_ppdu_tried = %u\n",
2841
			 le32_to_cpu(htt_stats_buf->num_psr_ppdu_tried));
2842
	len += scnprintf(buf + len, buf_len - len, "num_psr_ppdu_success = %u\n",
2843
			 le32_to_cpu(htt_stats_buf->num_psr_ppdu_success));
2844
	len += scnprintf(buf + len, buf_len - len, "min_duration_check_flush_cnt = %u\n",
2845
			 le32_to_cpu(htt_stats_buf->num_obss_min_dur_check_flush_cnt));
2846
	len += scnprintf(buf + len, buf_len - len, "sr_ppdu_abort_flush_cnt = %u\n\n",
2847
			 le32_to_cpu(htt_stats_buf->num_sr_ppdu_abort_flush_cnt));
2848

2849
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_OBSS_PD_PER_AC_STATS:\n");
2850
	for (i = 0; i < ATH12K_HTT_NUM_AC_WMM; i++) {
2851
		len += scnprintf(buf + len, buf_len - len, "Access Category %u (%s)\n",
2852
				 i, access_cat_names[i]);
2853
		len += scnprintf(buf + len, buf_len - len,
2854
				 "num_non_srg_ppdu_tried = %u\n",
2855
				 le32_to_cpu(htt_stats_buf->num_non_srg_tried_per_ac[i]));
2856
		len += scnprintf(buf + len, buf_len - len,
2857
				 "num_non_srg_ppdu_success = %u\n",
2858
				 le32_to_cpu(htt_stats_buf->num_non_srg_success_ac[i]));
2859
		len += scnprintf(buf + len, buf_len - len, "num_srg_ppdu_tried = %u\n",
2860
				 le32_to_cpu(htt_stats_buf->num_srg_tried_per_ac[i]));
2861
		len += scnprintf(buf + len, buf_len - len,
2862
				 "num_srg_ppdu_success = %u\n\n",
2863
				 le32_to_cpu(htt_stats_buf->num_srg_success_per_ac[i]));
2864
	}
2865

2866
	stats_req->buf_len = len;
2867
}
2868

2869
static void
2870
ath12k_htt_print_latency_prof_ctx_tlv(const void *tag_buf, u16 tag_len,
2871
				      struct debug_htt_stats_req *stats_req)
2872
{
2873
	const struct ath12k_htt_latency_prof_ctx_tlv *htt_stats_buf = tag_buf;
2874
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2875
	u32 len = stats_req->buf_len;
2876
	u8 *buf = stats_req->buf;
2877

2878
	if (tag_len < sizeof(*htt_stats_buf))
2879
		return;
2880

2881
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_LATENCY_CTX_TLV:\n");
2882
	len += scnprintf(buf + len, buf_len - len, "duration = %u\n",
2883
			 le32_to_cpu(htt_stats_buf->duration));
2884
	len += scnprintf(buf + len, buf_len - len, "tx_msdu_cnt = %u\n",
2885
			 le32_to_cpu(htt_stats_buf->tx_msdu_cnt));
2886
	len += scnprintf(buf + len, buf_len - len, "tx_mpdu_cnt = %u\n",
2887
			 le32_to_cpu(htt_stats_buf->tx_mpdu_cnt));
2888
	len += scnprintf(buf + len, buf_len - len, "rx_msdu_cnt = %u\n",
2889
			 le32_to_cpu(htt_stats_buf->rx_msdu_cnt));
2890
	len += scnprintf(buf + len, buf_len - len, "rx_mpdu_cnt = %u\n\n",
2891
			 le32_to_cpu(htt_stats_buf->rx_mpdu_cnt));
2892

2893
	stats_req->buf_len = len;
2894
}
2895

2896
static void
2897
ath12k_htt_print_latency_prof_cnt(const void *tag_buf, u16 tag_len,
2898
				  struct debug_htt_stats_req *stats_req)
2899
{
2900
	const struct ath12k_htt_latency_prof_cnt_tlv *htt_stats_buf = tag_buf;
2901
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2902
	u32 len = stats_req->buf_len;
2903
	u8 *buf = stats_req->buf;
2904

2905
	if (tag_len < sizeof(*htt_stats_buf))
2906
		return;
2907

2908
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_LATENCY_CNT_TLV:\n");
2909
	len += scnprintf(buf + len, buf_len - len, "prof_enable_cnt = %u\n\n",
2910
			 le32_to_cpu(htt_stats_buf->prof_enable_cnt));
2911

2912
	stats_req->buf_len = len;
2913
}
2914

2915
static void
2916
ath12k_htt_print_latency_prof_stats_tlv(const void *tag_buf, u16 tag_len,
2917
					struct debug_htt_stats_req *stats_req)
2918
{
2919
	const struct ath12k_htt_latency_prof_stats_tlv *htt_stats_buf = tag_buf;
2920
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2921
	u32 len = stats_req->buf_len;
2922
	u8 *buf = stats_req->buf;
2923

2924
	if (tag_len < sizeof(*htt_stats_buf))
2925
		return;
2926

2927
	if (le32_to_cpu(htt_stats_buf->print_header) == 1) {
2928
		len += scnprintf(buf + len, buf_len - len,
2929
				 "HTT_STATS_LATENCY_PROF_TLV:\n");
2930
	}
2931

2932
	len += scnprintf(buf + len, buf_len - len, "Latency name = %s\n",
2933
			 htt_stats_buf->latency_prof_name);
2934
	len += scnprintf(buf + len, buf_len - len, "count = %u\n",
2935
			 le32_to_cpu(htt_stats_buf->cnt));
2936
	len += scnprintf(buf + len, buf_len - len, "minimum = %u\n",
2937
			 le32_to_cpu(htt_stats_buf->min));
2938
	len += scnprintf(buf + len, buf_len - len, "maximum = %u\n",
2939
			 le32_to_cpu(htt_stats_buf->max));
2940
	len += scnprintf(buf + len, buf_len - len, "last = %u\n",
2941
			 le32_to_cpu(htt_stats_buf->last));
2942
	len += scnprintf(buf + len, buf_len - len, "total = %u\n",
2943
			 le32_to_cpu(htt_stats_buf->tot));
2944
	len += scnprintf(buf + len, buf_len - len, "average = %u\n",
2945
			 le32_to_cpu(htt_stats_buf->avg));
2946
	len += scnprintf(buf + len, buf_len - len, "histogram interval = %u\n",
2947
			 le32_to_cpu(htt_stats_buf->hist_intvl));
2948
	len += print_array_to_buf(buf, len, "histogram", htt_stats_buf->hist,
2949
				  ATH12K_HTT_LATENCY_PROFILE_NUM_MAX_HIST, "\n\n");
2950

2951
	stats_req->buf_len = len;
2952
}
2953

2954
static void
2955
ath12k_htt_print_ul_ofdma_trigger_stats(const void *tag_buf, u16 tag_len,
2956
					struct debug_htt_stats_req *stats_req)
2957
{
2958
	const struct ath12k_htt_rx_pdev_ul_trigger_stats_tlv *htt_stats_buf = tag_buf;
2959
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
2960
	u32 len = stats_req->buf_len;
2961
	u8 *buf = stats_req->buf;
2962
	u32 mac_id;
2963
	u8 j;
2964

2965
	if (tag_len < sizeof(*htt_stats_buf))
2966
		return;
2967

2968
	mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word);
2969

2970
	len += scnprintf(buf + len, buf_len - len,
2971
			 "HTT_RX_PDEV_UL_TRIGGER_STATS_TLV:\n");
2972
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
2973
			 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID));
2974
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_ofdma = %u\n",
2975
			 le32_to_cpu(htt_stats_buf->rx_11ax_ul_ofdma));
2976
	len += print_array_to_buf(buf, len, "ul_ofdma_rx_mcs",
2977
				  htt_stats_buf->ul_ofdma_rx_mcs,
2978
				  ATH12K_HTT_RX_NUM_MCS_CNTRS, "\n");
2979
	for (j = 0; j < ATH12K_HTT_RX_NUM_GI_CNTRS; j++) {
2980
		len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_gi[%u]", j);
2981
		len += print_array_to_buf(buf, len, "",
2982
					  htt_stats_buf->ul_ofdma_rx_gi[j],
2983
					  ATH12K_HTT_RX_NUM_MCS_CNTRS, "\n");
2984
	}
2985

2986
	len += print_array_to_buf_index(buf, len, "ul_ofdma_rx_nss", 1,
2987
					htt_stats_buf->ul_ofdma_rx_nss,
2988
					ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n");
2989
	len += print_array_to_buf(buf, len, "ul_ofdma_rx_bw",
2990
				  htt_stats_buf->ul_ofdma_rx_bw,
2991
				  ATH12K_HTT_RX_NUM_BW_CNTRS, "\n");
2992

2993
	for (j = 0; j < ATH12K_HTT_RX_NUM_REDUCED_CHAN_TYPES; j++) {
2994
		len += scnprintf(buf + len, buf_len - len, j == 0 ?
2995
				 "half_ul_ofdma_rx_bw" :
2996
				 "quarter_ul_ofdma_rx_bw");
2997
		len += print_array_to_buf(buf, len, "", htt_stats_buf->red_bw[j],
2998
					  ATH12K_HTT_RX_NUM_BW_CNTRS, "\n");
2999
	}
3000
	len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_stbc = %u\n",
3001
			 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_stbc));
3002
	len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_ldpc = %u\n",
3003
			 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_ldpc));
3004

3005
	len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_data_ru_size_ppdu = ");
3006
	for (j = 0; j < ATH12K_HTT_RX_NUM_RU_SIZE_CNTRS; j++)
3007
		len += scnprintf(buf + len, buf_len - len, " %s:%u ",
3008
				 ath12k_htt_ax_tx_rx_ru_size_to_str(j),
3009
				 le32_to_cpu(htt_stats_buf->data_ru_size_ppdu[j]));
3010
	len += scnprintf(buf + len, buf_len - len, "\n");
3011

3012
	len += scnprintf(buf + len, buf_len - len,
3013
			 "rx_ulofdma_non_data_ru_size_ppdu = ");
3014
	for (j = 0; j < ATH12K_HTT_RX_NUM_RU_SIZE_CNTRS; j++)
3015
		len += scnprintf(buf + len, buf_len - len, " %s:%u ",
3016
				 ath12k_htt_ax_tx_rx_ru_size_to_str(j),
3017
				 le32_to_cpu(htt_stats_buf->non_data_ru_size_ppdu[j]));
3018
	len += scnprintf(buf + len, buf_len - len, "\n");
3019

3020
	len += print_array_to_buf(buf, len, "rx_rssi_track_sta_aid",
3021
				  htt_stats_buf->uplink_sta_aid,
3022
				  ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n");
3023
	len += print_array_to_buf(buf, len, "rx_sta_target_rssi",
3024
				  htt_stats_buf->uplink_sta_target_rssi,
3025
				  ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n");
3026
	len += print_array_to_buf(buf, len, "rx_sta_fd_rssi",
3027
				  htt_stats_buf->uplink_sta_fd_rssi,
3028
				  ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n");
3029
	len += print_array_to_buf(buf, len, "rx_sta_power_headroom",
3030
				  htt_stats_buf->uplink_sta_power_headroom,
3031
				  ATH12K_HTT_RX_UL_MAX_UPLINK_RSSI_TRACK, "\n");
3032
	len += scnprintf(buf + len, buf_len - len,
3033
			 "ul_ofdma_basic_trigger_rx_qos_null_only = %u\n\n",
3034
			 le32_to_cpu(htt_stats_buf->ul_ofdma_bsc_trig_rx_qos_null_only));
3035

3036
	stats_req->buf_len = len;
3037
}
3038

3039
static void
3040
ath12k_htt_print_ul_ofdma_user_stats(const void *tag_buf, u16 tag_len,
3041
				     struct debug_htt_stats_req *stats_req)
3042
{
3043
	const struct ath12k_htt_rx_pdev_ul_ofdma_user_stats_tlv *htt_stats_buf = tag_buf;
3044
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3045
	u32 len = stats_req->buf_len;
3046
	u8 *buf = stats_req->buf;
3047
	u32 user_index;
3048

3049
	if (tag_len < sizeof(*htt_stats_buf))
3050
		return;
3051

3052
	user_index = __le32_to_cpu(htt_stats_buf->user_index);
3053

3054
	if (!user_index)
3055
		len += scnprintf(buf + len, buf_len - len,
3056
				 "HTT_RX_PDEV_UL_OFDMA_USER_STAS_TLV:\n");
3057
	len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_non_data_ppdu_%u = %u\n",
3058
			 user_index,
3059
			 le32_to_cpu(htt_stats_buf->rx_ulofdma_non_data_ppdu));
3060
	len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_data_ppdu_%u = %u\n",
3061
			 user_index,
3062
			 le32_to_cpu(htt_stats_buf->rx_ulofdma_data_ppdu));
3063
	len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_mpdu_ok_%u = %u\n",
3064
			 user_index,
3065
			 le32_to_cpu(htt_stats_buf->rx_ulofdma_mpdu_ok));
3066
	len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_mpdu_fail_%u = %u\n",
3067
			 user_index,
3068
			 le32_to_cpu(htt_stats_buf->rx_ulofdma_mpdu_fail));
3069
	len += scnprintf(buf + len, buf_len - len,
3070
			 "rx_ulofdma_non_data_nusers_%u = %u\n", user_index,
3071
			 le32_to_cpu(htt_stats_buf->rx_ulofdma_non_data_nusers));
3072
	len += scnprintf(buf + len, buf_len - len, "rx_ulofdma_data_nusers_%u = %u\n\n",
3073
			 user_index,
3074
			 le32_to_cpu(htt_stats_buf->rx_ulofdma_data_nusers));
3075

3076
	stats_req->buf_len = len;
3077
}
3078

3079
static void
3080
ath12k_htt_print_ul_mumimo_trig_stats(const void *tag_buf, u16 tag_len,
3081
				      struct debug_htt_stats_req *stats_req)
3082
{
3083
	const struct ath12k_htt_rx_ul_mumimo_trig_stats_tlv *htt_stats_buf = tag_buf;
3084
	char str_buf[ATH12K_HTT_MAX_STRING_LEN] = {};
3085
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3086
	u32 len = stats_req->buf_len;
3087
	u8 *buf = stats_req->buf;
3088
	u32 mac_id;
3089
	u16 index;
3090
	u8 i, j;
3091

3092
	if (tag_len < sizeof(*htt_stats_buf))
3093
		return;
3094

3095
	mac_id = __le32_to_cpu(htt_stats_buf->mac_id__word);
3096

3097
	len += scnprintf(buf + len, buf_len - len,
3098
			 "HTT_RX_PDEV_UL_MUMIMO_TRIG_STATS_TLV:\n");
3099
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
3100
			 u32_get_bits(mac_id, ATH12K_HTT_STATS_MAC_ID));
3101
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_mumimo = %u\n",
3102
			 le32_to_cpu(htt_stats_buf->rx_11ax_ul_mumimo));
3103
	index = 0;
3104
	memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN);
3105
	for (i = 0; i < ATH12K_HTT_RX_NUM_MCS_CNTRS; i++)
3106
		index += scnprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index,
3107
				  " %u:%u,", i,
3108
				  le32_to_cpu(htt_stats_buf->ul_mumimo_rx_mcs[i]));
3109

3110
	for (i = 0; i < ATH12K_HTT_RX_NUM_EXTRA_MCS_CNTRS; i++)
3111
		index += scnprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index,
3112
				  " %u:%u,", i + ATH12K_HTT_RX_NUM_MCS_CNTRS,
3113
				  le32_to_cpu(htt_stats_buf->ul_mumimo_rx_mcs_ext[i]));
3114
	str_buf[--index] = '\0';
3115
	len += scnprintf(buf + len, buf_len - len, "ul_mumimo_rx_mcs = %s\n", str_buf);
3116

3117
	for (j = 0; j < ATH12K_HTT_RX_NUM_GI_CNTRS; j++) {
3118
		index = 0;
3119
		memset(&str_buf[index], 0x0, ATH12K_HTT_MAX_STRING_LEN);
3120
		for (i = 0; i < ATH12K_HTT_RX_NUM_MCS_CNTRS; i++)
3121
			index += scnprintf(&str_buf[index],
3122
					  ATH12K_HTT_MAX_STRING_LEN - index,
3123
					  " %u:%u,", i,
3124
					  le32_to_cpu(htt_stats_buf->ul_rx_gi[j][i]));
3125

3126
		for (i = 0; i < ATH12K_HTT_RX_NUM_EXTRA_MCS_CNTRS; i++)
3127
			index += scnprintf(&str_buf[index],
3128
					  ATH12K_HTT_MAX_STRING_LEN - index,
3129
					  " %u:%u,", i + ATH12K_HTT_RX_NUM_MCS_CNTRS,
3130
					  le32_to_cpu(htt_stats_buf->ul_gi_ext[j][i]));
3131
		str_buf[--index] = '\0';
3132
		len += scnprintf(buf + len, buf_len - len,
3133
				 "ul_mumimo_rx_gi_%u = %s\n", j, str_buf);
3134
	}
3135

3136
	index = 0;
3137
	memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN);
3138
	len += print_array_to_buf_index(buf, len, "ul_mumimo_rx_nss", 1,
3139
					htt_stats_buf->ul_mumimo_rx_nss,
3140
					ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n");
3141

3142
	len += print_array_to_buf(buf, len, "ul_mumimo_rx_bw",
3143
				  htt_stats_buf->ul_mumimo_rx_bw,
3144
				  ATH12K_HTT_RX_NUM_BW_CNTRS, "\n");
3145
	for (i = 0; i < ATH12K_HTT_RX_NUM_REDUCED_CHAN_TYPES; i++) {
3146
		index = 0;
3147
		memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN);
3148
		for (j = 0; j < ATH12K_HTT_RX_NUM_BW_CNTRS; j++)
3149
			index += scnprintf(&str_buf[index],
3150
					  ATH12K_HTT_MAX_STRING_LEN - index,
3151
					  " %u:%u,", j,
3152
					  le32_to_cpu(htt_stats_buf->red_bw[i][j]));
3153
		str_buf[--index] = '\0';
3154
		len += scnprintf(buf + len, buf_len - len, "%s = %s\n",
3155
				 i == 0 ? "half_ul_mumimo_rx_bw" :
3156
				 "quarter_ul_mumimo_rx_bw", str_buf);
3157
	}
3158

3159
	len += scnprintf(buf + len, buf_len - len, "ul_mumimo_rx_stbc = %u\n",
3160
			 le32_to_cpu(htt_stats_buf->ul_mumimo_rx_stbc));
3161
	len += scnprintf(buf + len, buf_len - len, "ul_mumimo_rx_ldpc = %u\n",
3162
			 le32_to_cpu(htt_stats_buf->ul_mumimo_rx_ldpc));
3163

3164
	for (j = 0; j < ATH12K_HTT_RX_NUM_SPATIAL_STREAMS; j++) {
3165
		len += scnprintf(buf + len, buf_len - len,
3166
				 "rx_ul_mumimo_rssi_in_dbm: chain%u ", j);
3167
		len += print_array_to_buf_s8(buf, len, "", 0,
3168
					     htt_stats_buf->ul_rssi[j],
3169
					     ATH12K_HTT_RX_NUM_BW_CNTRS, "\n");
3170
	}
3171

3172
	for (j = 0; j < ATH12K_HTT_TX_UL_MUMIMO_USER_STATS; j++) {
3173
		len += scnprintf(buf + len, buf_len - len,
3174
				 "rx_ul_mumimo_target_rssi: user_%u ", j);
3175
		len += print_array_to_buf_s8(buf, len, "", 0,
3176
					     htt_stats_buf->tgt_rssi[j],
3177
					     ATH12K_HTT_RX_NUM_BW_CNTRS, "\n");
3178
	}
3179

3180
	for (j = 0; j < ATH12K_HTT_TX_UL_MUMIMO_USER_STATS; j++) {
3181
		len += scnprintf(buf + len, buf_len - len,
3182
				 "rx_ul_mumimo_fd_rssi: user_%u ", j);
3183
		len += print_array_to_buf_s8(buf, len, "", 0,
3184
					     htt_stats_buf->fd[j],
3185
					     ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n");
3186
	}
3187

3188
	for (j = 0; j < ATH12K_HTT_TX_UL_MUMIMO_USER_STATS; j++) {
3189
		len += scnprintf(buf + len, buf_len - len,
3190
				 "rx_ulmumimo_pilot_evm_db_mean: user_%u ", j);
3191
		len += print_array_to_buf_s8(buf, len, "", 0,
3192
					     htt_stats_buf->db[j],
3193
					     ATH12K_HTT_RX_NUM_SPATIAL_STREAMS, "\n");
3194
	}
3195

3196
	len += scnprintf(buf + len, buf_len - len,
3197
			 "ul_mumimo_basic_trigger_rx_qos_null_only = %u\n\n",
3198
			 le32_to_cpu(htt_stats_buf->mumimo_bsc_trig_rx_qos_null_only));
3199

3200
	stats_req->buf_len = len;
3201
}
3202

3203
static void
3204
ath12k_htt_print_rx_fse_stats_tlv(const void *tag_buf, u16 tag_len,
3205
				  struct debug_htt_stats_req *stats_req)
3206
{
3207
	const struct ath12k_htt_rx_fse_stats_tlv *htt_stats_buf = tag_buf;
3208
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3209
	u32 len = stats_req->buf_len;
3210
	u8 *buf = stats_req->buf;
3211

3212
	if (tag_len < sizeof(*htt_stats_buf))
3213
		return;
3214

3215
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_RX_FSE_STATS_TLV:\n");
3216
	len += scnprintf(buf + len, buf_len - len, "=== Software RX FSE STATS ===\n");
3217
	len += scnprintf(buf + len, buf_len - len, "Enable count  = %u\n",
3218
			 le32_to_cpu(htt_stats_buf->fse_enable_cnt));
3219
	len += scnprintf(buf + len, buf_len - len, "Disable count = %u\n",
3220
			 le32_to_cpu(htt_stats_buf->fse_disable_cnt));
3221
	len += scnprintf(buf + len, buf_len - len, "Cache invalidate entry count = %u\n",
3222
			 le32_to_cpu(htt_stats_buf->fse_cache_invalidate_entry_cnt));
3223
	len += scnprintf(buf + len, buf_len - len, "Full cache invalidate count = %u\n",
3224
			 le32_to_cpu(htt_stats_buf->fse_full_cache_invalidate_cnt));
3225

3226
	len += scnprintf(buf + len, buf_len - len, "\n=== Hardware RX FSE STATS ===\n");
3227
	len += scnprintf(buf + len, buf_len - len, "Cache hits count = %u\n",
3228
			 le32_to_cpu(htt_stats_buf->fse_num_cache_hits_cnt));
3229
	len += scnprintf(buf + len, buf_len - len, "Cache no. of searches = %u\n",
3230
			 le32_to_cpu(htt_stats_buf->fse_num_searches_cnt));
3231
	len += scnprintf(buf + len, buf_len - len, "Cache occupancy peak count:\n");
3232
	len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-16] = %u [17-32] = %u ",
3233
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[0]),
3234
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[1]),
3235
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[2]));
3236
	len += scnprintf(buf + len, buf_len - len, "[33-48] = %u [49-64] = %u ",
3237
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[3]),
3238
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[4]));
3239
	len += scnprintf(buf + len, buf_len - len, "[65-80] = %u [81-96] = %u ",
3240
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[5]),
3241
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[6]));
3242
	len += scnprintf(buf + len, buf_len - len, "[97-112] = %u [113-127] = %u ",
3243
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[7]),
3244
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[8]));
3245
	len += scnprintf(buf + len, buf_len - len, "[128] = %u\n",
3246
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_peak_cnt[9]));
3247
	len += scnprintf(buf + len, buf_len - len, "Cache occupancy current count:\n");
3248
	len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-16] = %u [17-32] = %u ",
3249
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[0]),
3250
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[1]),
3251
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[2]));
3252
	len += scnprintf(buf + len, buf_len - len, "[33-48] = %u [49-64] = %u ",
3253
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[3]),
3254
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[4]));
3255
	len += scnprintf(buf + len, buf_len - len, "[65-80] = %u [81-96] = %u ",
3256
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[5]),
3257
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[6]));
3258
	len += scnprintf(buf + len, buf_len - len, "[97-112] = %u [113-127] = %u ",
3259
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[7]),
3260
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[8]));
3261
	len += scnprintf(buf + len, buf_len - len, "[128] = %u\n",
3262
			 le32_to_cpu(htt_stats_buf->fse_cache_occupancy_curr_cnt[9]));
3263
	len += scnprintf(buf + len, buf_len - len, "Cache search square count:\n");
3264
	len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-50] = %u [51-100] = %u ",
3265
			 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[0]),
3266
			 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[1]),
3267
			 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[2]));
3268
	len += scnprintf(buf + len, buf_len - len, "[101-200] = %u [201-255] = %u ",
3269
			 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[3]),
3270
			 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[4]));
3271
	len += scnprintf(buf + len, buf_len - len, "[256] = %u\n",
3272
			 le32_to_cpu(htt_stats_buf->fse_search_stat_square_cnt[5]));
3273
	len += scnprintf(buf + len, buf_len - len, "Cache search peak pending count:\n");
3274
	len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-2] = %u [3-4] = %u ",
3275
			 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[0]),
3276
			 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[1]),
3277
			 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[2]));
3278
	len += scnprintf(buf + len, buf_len - len, "[Greater/Equal to 5] = %u\n",
3279
			 le32_to_cpu(htt_stats_buf->fse_search_stat_peak_cnt[3]));
3280
	len += scnprintf(buf + len, buf_len - len, "Cache search tot pending count:\n");
3281
	len += scnprintf(buf + len, buf_len - len, "[0] = %u [1-2] = %u [3-4] = %u ",
3282
			 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[0]),
3283
			 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[1]),
3284
			 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[2]));
3285
	len += scnprintf(buf + len, buf_len - len, "[Greater/Equal to 5] = %u\n\n",
3286
			 le32_to_cpu(htt_stats_buf->fse_search_stat_pending_cnt[3]));
3287

3288
	stats_req->buf_len = len;
3289
}
3290

3291
static void
3292
ath12k_htt_print_pdev_tx_rate_txbf_stats_tlv(const void *tag_buf, u16 tag_len,
3293
					     struct debug_htt_stats_req *stats_req)
3294
{
3295
	const struct ath12k_htt_pdev_txrate_txbf_stats_tlv *htt_stats_buf = tag_buf;
3296
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3297
	u32 len = stats_req->buf_len;
3298
	u8 *buf = stats_req->buf;
3299
	u8 i;
3300

3301
	if (tag_len < sizeof(*htt_stats_buf))
3302
		return;
3303

3304
	len += scnprintf(buf + len, buf_len - len,
3305
			 "HTT_STATS_PDEV_TX_RATE_TXBF_STATS:\n");
3306
	len += scnprintf(buf + len, buf_len - len, "Legacy OFDM Rates: 6 Mbps: %u, ",
3307
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[0]));
3308
	len += scnprintf(buf + len, buf_len - len, "9 Mbps: %u, 12 Mbps: %u, ",
3309
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[1]),
3310
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[2]));
3311
	len += scnprintf(buf + len, buf_len - len, "18 Mbps: %u\n",
3312
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[3]));
3313
	len += scnprintf(buf + len, buf_len - len, "24 Mbps: %u, 36 Mbps: %u, ",
3314
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[4]),
3315
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[5]));
3316
	len += scnprintf(buf + len, buf_len - len, "48 Mbps: %u, 54 Mbps: %u\n",
3317
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[6]),
3318
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[7]));
3319

3320
	len += print_array_to_buf(buf, len, "tx_ol_mcs", htt_stats_buf->tx_su_ol_mcs,
3321
				  ATH12K_HTT_TX_BF_RATE_STATS_NUM_MCS_COUNTERS, "\n");
3322
	len += print_array_to_buf(buf, len, "tx_ibf_mcs", htt_stats_buf->tx_su_ibf_mcs,
3323
				  ATH12K_HTT_TX_BF_RATE_STATS_NUM_MCS_COUNTERS, "\n");
3324
	len += print_array_to_buf(buf, len, "tx_txbf_mcs", htt_stats_buf->tx_su_txbf_mcs,
3325
				  ATH12K_HTT_TX_BF_RATE_STATS_NUM_MCS_COUNTERS, "\n");
3326
	len += print_array_to_buf_index(buf, len, "tx_ol_nss", 1,
3327
					htt_stats_buf->tx_su_ol_nss,
3328
					ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS,
3329
					"\n");
3330
	len += print_array_to_buf_index(buf, len, "tx_ibf_nss", 1,
3331
					htt_stats_buf->tx_su_ibf_nss,
3332
					ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS,
3333
					"\n");
3334
	len += print_array_to_buf_index(buf, len, "tx_txbf_nss", 1,
3335
					htt_stats_buf->tx_su_txbf_nss,
3336
					ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS,
3337
					"\n");
3338
	len += print_array_to_buf(buf, len, "tx_ol_bw", htt_stats_buf->tx_su_ol_bw,
3339
				  ATH12K_HTT_TXBF_NUM_BW_CNTRS, "\n");
3340
	for (i = 0; i < ATH12K_HTT_TXBF_NUM_REDUCED_CHAN_TYPES; i++)
3341
		len += print_array_to_buf(buf, len, i ? "quarter_tx_ol_bw" :
3342
					  "half_tx_ol_bw",
3343
					  htt_stats_buf->ol[i],
3344
					  ATH12K_HTT_TXBF_NUM_BW_CNTRS,
3345
					  "\n");
3346

3347
	len += print_array_to_buf(buf, len, "tx_ibf_bw", htt_stats_buf->tx_su_ibf_bw,
3348
				  ATH12K_HTT_TXBF_NUM_BW_CNTRS, "\n");
3349
	for (i = 0; i < ATH12K_HTT_TXBF_NUM_REDUCED_CHAN_TYPES; i++)
3350
		len += print_array_to_buf(buf, len, i ? "quarter_tx_ibf_bw" :
3351
					  "half_tx_ibf_bw",
3352
					  htt_stats_buf->ibf[i],
3353
					  ATH12K_HTT_TXBF_NUM_BW_CNTRS,
3354
					  "\n");
3355

3356
	len += print_array_to_buf(buf, len, "tx_txbf_bw", htt_stats_buf->tx_su_txbf_bw,
3357
				  ATH12K_HTT_TXBF_NUM_BW_CNTRS, "\n");
3358
	for (i = 0; i < ATH12K_HTT_TXBF_NUM_REDUCED_CHAN_TYPES; i++)
3359
		len += print_array_to_buf(buf, len, i ? "quarter_tx_txbf_bw" :
3360
					  "half_tx_txbf_bw",
3361
					  htt_stats_buf->txbf[i],
3362
					  ATH12K_HTT_TXBF_NUM_BW_CNTRS,
3363
					  "\n");
3364
	len += scnprintf(buf + len, buf_len - len, "\n");
3365

3366
	len += scnprintf(buf + len, buf_len - len,
3367
			 "HTT_STATS_PDEV_TXBF_FLAG_RETURN_STATS:\n");
3368
	len += scnprintf(buf + len, buf_len - len, "TXBF_reason_code_stats: 0:%u, 1:%u,",
3369
			 le32_to_cpu(htt_stats_buf->txbf_flag_set_mu_mode),
3370
			 le32_to_cpu(htt_stats_buf->txbf_flag_set_final_status));
3371
	len += scnprintf(buf + len, buf_len - len, " 2:%u, 3:%u, 4:%u, 5:%u, ",
3372
			 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_verified_txbf_mode),
3373
			 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_disable_p2p_access),
3374
			 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_max_nss_in_he160),
3375
			 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_disable_uldlofdma));
3376
	len += scnprintf(buf + len, buf_len - len, "6:%u, 7:%u\n\n",
3377
			 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_mcs_threshold_val),
3378
			 le32_to_cpu(htt_stats_buf->txbf_flag_not_set_final_status));
3379

3380
	stats_req->buf_len = len;
3381
}
3382

3383
static void
3384
ath12k_htt_print_txbf_ofdma_ax_ndpa_stats_tlv(const void *tag_buf, u16 tag_len,
3385
					      struct debug_htt_stats_req *stats_req)
3386
{
3387
	const struct ath12k_htt_txbf_ofdma_ax_ndpa_stats_tlv *stats_buf = tag_buf;
3388
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3389
	u32 len = stats_req->buf_len;
3390
	u8 *buf = stats_req->buf;
3391
	u32 num_elements;
3392
	u8 i;
3393

3394
	if (tag_len < sizeof(*stats_buf))
3395
		return;
3396

3397
	num_elements = le32_to_cpu(stats_buf->num_elems_ax_ndpa_arr);
3398

3399
	len += scnprintf(buf + len, buf_len - len, "HTT_TXBF_OFDMA_AX_NDPA_STATS_TLV:\n");
3400
	len += scnprintf(buf + len, buf_len - len, "ax_ofdma_ndpa_queued =");
3401
	for (i = 0; i < num_elements; i++)
3402
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3403
				 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_queued));
3404
	len--;
3405
	*(buf + len) = '\0';
3406

3407
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndpa_tried =");
3408
	for (i = 0; i < num_elements; i++)
3409
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3410
				 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_tried));
3411
	len--;
3412
	*(buf + len) = '\0';
3413

3414
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndpa_flushed =");
3415
	for (i = 0; i < num_elements; i++)
3416
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3417
				 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_flush));
3418
	len--;
3419
	*(buf + len) = '\0';
3420

3421
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndpa_err =");
3422
	for (i = 0; i < num_elements; i++)
3423
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3424
				 le32_to_cpu(stats_buf->ax_ndpa[i].ax_ofdma_ndpa_err));
3425
	len--;
3426
	*(buf + len) = '\0';
3427

3428
	len += scnprintf(buf + len, buf_len - len, "\n\n");
3429

3430
	stats_req->buf_len = len;
3431
}
3432

3433
static void
3434
ath12k_htt_print_txbf_ofdma_ax_ndp_stats_tlv(const void *tag_buf, u16 tag_len,
3435
					     struct debug_htt_stats_req *stats_req)
3436
{
3437
	const struct ath12k_htt_txbf_ofdma_ax_ndp_stats_tlv *stats_buf = tag_buf;
3438
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3439
	u32 len = stats_req->buf_len;
3440
	u8 *buf = stats_req->buf;
3441
	u32 num_elements;
3442
	u8 i;
3443

3444
	if (tag_len < sizeof(*stats_buf))
3445
		return;
3446

3447
	num_elements = le32_to_cpu(stats_buf->num_elems_ax_ndp_arr);
3448

3449
	len += scnprintf(buf + len, buf_len - len, "HTT_TXBF_OFDMA_AX_NDP_STATS_TLV:\n");
3450
	len += scnprintf(buf + len, buf_len - len, "ax_ofdma_ndp_queued =");
3451
	for (i = 0; i < num_elements; i++)
3452
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3453
				 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_queued));
3454
	len--;
3455
	*(buf + len) = '\0';
3456

3457
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndp_tried =");
3458
	for (i = 0; i < num_elements; i++)
3459
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3460
				 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_tried));
3461
	len--;
3462
	*(buf + len) = '\0';
3463

3464
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndp_flushed =");
3465
	for (i = 0; i < num_elements; i++)
3466
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3467
				 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_flush));
3468
	len--;
3469
	*(buf + len) = '\0';
3470

3471
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_ndp_err =");
3472
	for (i = 0; i < num_elements; i++)
3473
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3474
				 le32_to_cpu(stats_buf->ax_ndp[i].ax_ofdma_ndp_err));
3475
	len--;
3476
	*(buf + len) = '\0';
3477

3478
	len += scnprintf(buf + len, buf_len - len, "\n\n");
3479

3480
	stats_req->buf_len = len;
3481
}
3482

3483
static void
3484
ath12k_htt_print_txbf_ofdma_ax_brp_stats_tlv(const void *tag_buf, u16 tag_len,
3485
					     struct debug_htt_stats_req *stats_req)
3486
{
3487
	const struct ath12k_htt_txbf_ofdma_ax_brp_stats_tlv *stats_buf = tag_buf;
3488
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3489
	u32 len = stats_req->buf_len;
3490
	u8 *buf = stats_req->buf;
3491
	u32 num_elements;
3492
	u8 i;
3493

3494
	if (tag_len < sizeof(*stats_buf))
3495
		return;
3496

3497
	num_elements = le32_to_cpu(stats_buf->num_elems_ax_brp_arr);
3498

3499
	len += scnprintf(buf + len, buf_len - len, "HTT_TXBF_OFDMA_AX_BRP_STATS_TLV:\n");
3500
	len += scnprintf(buf + len, buf_len - len, "ax_ofdma_brpoll_queued =");
3501
	for (i = 0; i < num_elements; i++)
3502
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3503
				 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_queued));
3504
	len--;
3505
	*(buf + len) = '\0';
3506

3507
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brpoll_tied =");
3508
	for (i = 0; i < num_elements; i++)
3509
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3510
				 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_tried));
3511
	len--;
3512
	*(buf + len) = '\0';
3513

3514
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brpoll_flushed =");
3515
	for (i = 0; i < num_elements; i++)
3516
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3517
				 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_flushed));
3518
	len--;
3519
	*(buf + len) = '\0';
3520

3521
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brp_err =");
3522
	for (i = 0; i < num_elements; i++)
3523
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3524
				 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_brp_err));
3525
	len--;
3526
	*(buf + len) = '\0';
3527

3528
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_brp_err_num_cbf_rcvd =");
3529
	for (i = 0; i < num_elements; i++)
3530
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3531
				 le32_to_cpu(stats_buf->ax_brp[i].ax_ofdma_num_cbf_rcvd));
3532
	len--;
3533
	*(buf + len) = '\0';
3534

3535
	len += scnprintf(buf + len, buf_len - len, "\n\n");
3536

3537
	stats_req->buf_len = len;
3538
}
3539

3540
static void
3541
ath12k_htt_print_txbf_ofdma_ax_steer_stats_tlv(const void *tag_buf, u16 tag_len,
3542
					       struct debug_htt_stats_req *stats_req)
3543
{
3544
	const struct ath12k_htt_txbf_ofdma_ax_steer_stats_tlv *stats_buf = tag_buf;
3545
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3546
	u32 len = stats_req->buf_len;
3547
	u8 *buf = stats_req->buf;
3548
	u32 num_elements;
3549
	u8 i;
3550

3551
	if (tag_len < sizeof(*stats_buf))
3552
		return;
3553

3554
	num_elements = le32_to_cpu(stats_buf->num_elems_ax_steer_arr);
3555

3556
	len += scnprintf(buf + len, buf_len - len,
3557
			 "HTT_TXBF_OFDMA_AX_STEER_STATS_TLV:\n");
3558
	len += scnprintf(buf + len, buf_len - len, "ax_ofdma_num_ppdu_steer =");
3559
	for (i = 0; i < num_elements; i++)
3560
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3561
				 le32_to_cpu(stats_buf->ax_steer[i].num_ppdu_steer));
3562
	len--;
3563
	*(buf + len) = '\0';
3564

3565
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_num_usrs_prefetch =");
3566
	for (i = 0; i < num_elements; i++)
3567
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3568
				 le32_to_cpu(stats_buf->ax_steer[i].num_usr_prefetch));
3569
	len--;
3570
	*(buf + len) = '\0';
3571

3572
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_num_usrs_sound =");
3573
	for (i = 0; i < num_elements; i++)
3574
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3575
				 le32_to_cpu(stats_buf->ax_steer[i].num_usr_sound));
3576
	len--;
3577
	*(buf + len) = '\0';
3578

3579
	len += scnprintf(buf + len, buf_len - len, "\nax_ofdma_num_usrs_force_sound =");
3580
	for (i = 0; i < num_elements; i++)
3581
		len += scnprintf(buf + len, buf_len - len, " %u:%u,", i + 1,
3582
				 le32_to_cpu(stats_buf->ax_steer[i].num_usr_force_sound));
3583
	len--;
3584
	*(buf + len) = '\0';
3585

3586
	len += scnprintf(buf + len, buf_len - len, "\n\n");
3587

3588
	stats_req->buf_len = len;
3589
}
3590

3591
static void
3592
ath12k_htt_print_txbf_ofdma_ax_steer_mpdu_stats_tlv(const void *tag_buf, u16 tag_len,
3593
						    struct debug_htt_stats_req *stats_req)
3594
{
3595
	const struct ath12k_htt_txbf_ofdma_ax_steer_mpdu_stats_tlv *stats_buf = tag_buf;
3596
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3597
	u32 len = stats_req->buf_len;
3598
	u8 *buf = stats_req->buf;
3599

3600
	if (tag_len < sizeof(*stats_buf))
3601
		return;
3602

3603
	len += scnprintf(buf + len, buf_len - len,
3604
			 "HTT_TXBF_OFDMA_AX_STEER_MPDU_STATS_TLV:\n");
3605
	len += scnprintf(buf + len, buf_len - len, "rbo_steer_mpdus_tried = %u\n",
3606
			 le32_to_cpu(stats_buf->ax_ofdma_rbo_steer_mpdus_tried));
3607
	len += scnprintf(buf + len, buf_len - len, "rbo_steer_mpdus_failed = %u\n",
3608
			 le32_to_cpu(stats_buf->ax_ofdma_rbo_steer_mpdus_failed));
3609
	len += scnprintf(buf + len, buf_len - len, "sifs_steer_mpdus_tried = %u\n",
3610
			 le32_to_cpu(stats_buf->ax_ofdma_sifs_steer_mpdus_tried));
3611
	len += scnprintf(buf + len, buf_len - len, "sifs_steer_mpdus_failed = %u\n\n",
3612
			 le32_to_cpu(stats_buf->ax_ofdma_sifs_steer_mpdus_failed));
3613

3614
	stats_req->buf_len = len;
3615
}
3616

3617
static void ath12k_htt_print_dlpager_entry(const struct ath12k_htt_pgs_info *pg_info,
3618
					   int idx, char *str_buf)
3619
{
3620
	u64 page_timestamp;
3621
	u16 index = 0;
3622

3623
	page_timestamp = ath12k_le32hilo_to_u64(pg_info->ts_msb, pg_info->ts_lsb);
3624

3625
	index += snprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index,
3626
			  "Index - %u ; Page Number - %u ; ",
3627
			  idx, le32_to_cpu(pg_info->page_num));
3628
	index += snprintf(&str_buf[index], ATH12K_HTT_MAX_STRING_LEN - index,
3629
			  "Num of pages - %u ; Timestamp - %lluus\n",
3630
			  le32_to_cpu(pg_info->num_pgs), page_timestamp);
3631
}
3632

3633
static void
3634
ath12k_htt_print_dlpager_stats_tlv(const void *tag_buf, u16 tag_len,
3635
				   struct debug_htt_stats_req *stats_req)
3636
{
3637
	const struct ath12k_htt_dl_pager_stats_tlv *stat_buf = tag_buf;
3638
	u32 len = stats_req->buf_len;
3639
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3640
	u32 dword_lock, dword_unlock;
3641
	int i;
3642
	u8 *buf = stats_req->buf;
3643
	u8 pg_locked;
3644
	u8 pg_unlock;
3645
	char str_buf[ATH12K_HTT_MAX_STRING_LEN] = {};
3646

3647
	if (tag_len < sizeof(*stat_buf))
3648
		return;
3649

3650
	dword_lock = le32_get_bits(stat_buf->info2,
3651
				   ATH12K_HTT_DLPAGER_TOTAL_LOCK_PAGES_INFO2);
3652
	dword_unlock = le32_get_bits(stat_buf->info2,
3653
				     ATH12K_HTT_DLPAGER_TOTAL_FREE_PAGES_INFO2);
3654

3655
	pg_locked = ATH12K_HTT_STATS_PAGE_LOCKED;
3656
	pg_unlock = ATH12K_HTT_STATS_PAGE_UNLOCKED;
3657

3658
	len += scnprintf(buf + len, buf_len - len, "HTT_DLPAGER_STATS_TLV:\n");
3659
	len += scnprintf(buf + len, buf_len - len, "ASYNC locked pages = %u\n",
3660
			 le32_get_bits(stat_buf->info0,
3661
				       ATH12K_HTT_DLPAGER_ASYNC_LOCK_PG_CNT_INFO0));
3662
	len += scnprintf(buf + len, buf_len - len, "SYNC locked pages = %u\n",
3663
			 le32_get_bits(stat_buf->info0,
3664
				       ATH12K_HTT_DLPAGER_SYNC_LOCK_PG_CNT_INFO0));
3665
	len += scnprintf(buf + len, buf_len - len, "Total locked pages = %u\n",
3666
			 le32_get_bits(stat_buf->info1,
3667
				       ATH12K_HTT_DLPAGER_TOTAL_LOCK_PAGES_INFO1));
3668
	len += scnprintf(buf + len, buf_len - len, "Total free pages = %u\n",
3669
			 le32_get_bits(stat_buf->info1,
3670
				       ATH12K_HTT_DLPAGER_TOTAL_FREE_PAGES_INFO1));
3671

3672
	len += scnprintf(buf + len, buf_len - len, "\nLOCKED PAGES HISTORY\n");
3673
	len += scnprintf(buf + len, buf_len - len, "last_locked_page_idx = %u\n",
3674
			 dword_lock ? dword_lock - 1 : (ATH12K_PAGER_MAX - 1));
3675

3676
	for (i = 0; i < ATH12K_PAGER_MAX; i++) {
3677
		memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN);
3678
		ath12k_htt_print_dlpager_entry(&stat_buf->pgs_info[pg_locked][i],
3679
					       i, str_buf);
3680
		len += scnprintf(buf + len, buf_len - len, "%s", str_buf);
3681
	}
3682

3683
	len += scnprintf(buf + len, buf_len - len, "\nUNLOCKED PAGES HISTORY\n");
3684
	len += scnprintf(buf + len, buf_len - len, "last_unlocked_page_idx = %u\n",
3685
			 dword_unlock ? dword_unlock - 1 : ATH12K_PAGER_MAX - 1);
3686

3687
	for (i = 0; i < ATH12K_PAGER_MAX; i++) {
3688
		memset(str_buf, 0x0, ATH12K_HTT_MAX_STRING_LEN);
3689
		ath12k_htt_print_dlpager_entry(&stat_buf->pgs_info[pg_unlock][i],
3690
					       i, str_buf);
3691
		len += scnprintf(buf + len, buf_len - len, "%s", str_buf);
3692
	}
3693

3694
	len += scnprintf(buf + len, buf_len - len, "\n");
3695

3696
	stats_req->buf_len = len;
3697
}
3698

3699
static void
3700
ath12k_htt_print_phy_stats_tlv(const void *tag_buf, u16 tag_len,
3701
			       struct debug_htt_stats_req *stats_req)
3702
{
3703
	const struct ath12k_htt_phy_stats_tlv *htt_stats_buf = tag_buf;
3704
	u32 len = stats_req->buf_len;
3705
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3706
	u8 *buf = stats_req->buf, i;
3707

3708
	if (tag_len < sizeof(*htt_stats_buf))
3709
		return;
3710

3711
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_STATS_TLV:\n");
3712
	for (i = 0; i < ATH12K_HTT_STATS_MAX_CHAINS; i++)
3713
		len += scnprintf(buf + len, buf_len - len, "bdf_nf_chain[%d] = %d\n",
3714
				 i, a_sle32_to_cpu(htt_stats_buf->nf_chain[i]));
3715
	for (i = 0; i < ATH12K_HTT_STATS_MAX_CHAINS; i++)
3716
		len += scnprintf(buf + len, buf_len - len, "runtime_nf_chain[%d] = %d\n",
3717
				 i, a_sle32_to_cpu(htt_stats_buf->runtime_nf_chain[i]));
3718
	len += scnprintf(buf + len, buf_len - len, "false_radar_cnt = %u / %u (mins)\n",
3719
			 le32_to_cpu(htt_stats_buf->false_radar_cnt),
3720
			 le32_to_cpu(htt_stats_buf->fw_run_time));
3721
	len += scnprintf(buf + len, buf_len - len, "radar_cs_cnt = %u\n",
3722
			 le32_to_cpu(htt_stats_buf->radar_cs_cnt));
3723
	len += scnprintf(buf + len, buf_len - len, "ani_level = %d\n\n",
3724
			 a_sle32_to_cpu(htt_stats_buf->ani_level));
3725

3726
	stats_req->buf_len = len;
3727
}
3728

3729
static void
3730
ath12k_htt_print_phy_counters_tlv(const void *tag_buf, u16 tag_len,
3731
				  struct debug_htt_stats_req *stats_req)
3732
{
3733
	const struct ath12k_htt_phy_counters_tlv *htt_stats_buf = tag_buf;
3734
	u32 len = stats_req->buf_len;
3735
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3736
	u8 *buf = stats_req->buf;
3737

3738
	if (tag_len < sizeof(*htt_stats_buf))
3739
		return;
3740

3741
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_COUNTERS_TLV:\n");
3742
	len += scnprintf(buf + len, buf_len - len, "rx_ofdma_timing_err_cnt = %u\n",
3743
			 le32_to_cpu(htt_stats_buf->rx_ofdma_timing_err_cnt));
3744
	len += scnprintf(buf + len, buf_len - len, "rx_cck_fail_cnt = %u\n",
3745
			 le32_to_cpu(htt_stats_buf->rx_cck_fail_cnt));
3746
	len += scnprintf(buf + len, buf_len - len, "mactx_abort_cnt = %u\n",
3747
			 le32_to_cpu(htt_stats_buf->mactx_abort_cnt));
3748
	len += scnprintf(buf + len, buf_len - len, "macrx_abort_cnt = %u\n",
3749
			 le32_to_cpu(htt_stats_buf->macrx_abort_cnt));
3750
	len += scnprintf(buf + len, buf_len - len, "phytx_abort_cnt = %u\n",
3751
			 le32_to_cpu(htt_stats_buf->phytx_abort_cnt));
3752
	len += scnprintf(buf + len, buf_len - len, "phyrx_abort_cnt = %u\n",
3753
			 le32_to_cpu(htt_stats_buf->phyrx_abort_cnt));
3754
	len += scnprintf(buf + len, buf_len - len, "phyrx_defer_abort_cnt = %u\n",
3755
			 le32_to_cpu(htt_stats_buf->phyrx_defer_abort_cnt));
3756
	len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_lstf_event_cnt = %u\n",
3757
			 le32_to_cpu(htt_stats_buf->rx_gain_adj_lstf_event_cnt));
3758
	len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_non_legacy_cnt = %u\n",
3759
			 le32_to_cpu(htt_stats_buf->rx_gain_adj_non_legacy_cnt));
3760
	len += print_array_to_buf(buf, len, "rx_pkt_cnt", htt_stats_buf->rx_pkt_cnt,
3761
				  ATH12K_HTT_MAX_RX_PKT_CNT, "\n");
3762
	len += print_array_to_buf(buf, len, "rx_pkt_crc_pass_cnt",
3763
				  htt_stats_buf->rx_pkt_crc_pass_cnt,
3764
				  ATH12K_HTT_MAX_RX_PKT_CRC_PASS_CNT, "\n");
3765
	len += print_array_to_buf(buf, len, "per_blk_err_cnt",
3766
				  htt_stats_buf->per_blk_err_cnt,
3767
				  ATH12K_HTT_MAX_PER_BLK_ERR_CNT, "\n");
3768
	len += print_array_to_buf(buf, len, "rx_ota_err_cnt",
3769
				  htt_stats_buf->rx_ota_err_cnt,
3770
				  ATH12K_HTT_MAX_RX_OTA_ERR_CNT, "\n\n");
3771

3772
	stats_req->buf_len = len;
3773
}
3774

3775
static void
3776
ath12k_htt_print_phy_reset_stats_tlv(const void *tag_buf, u16 tag_len,
3777
				     struct debug_htt_stats_req *stats_req)
3778
{
3779
	const struct ath12k_htt_phy_reset_stats_tlv *htt_stats_buf = tag_buf;
3780
	u32 len = stats_req->buf_len;
3781
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3782
	u8 *buf = stats_req->buf;
3783

3784
	if (tag_len < sizeof(*htt_stats_buf))
3785
		return;
3786

3787
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_STATS_TLV:\n");
3788
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
3789
			 le32_to_cpu(htt_stats_buf->pdev_id));
3790
	len += scnprintf(buf + len, buf_len - len, "chan_mhz = %u\n",
3791
			 le32_to_cpu(htt_stats_buf->chan_mhz));
3792
	len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq1 = %u\n",
3793
			 le32_to_cpu(htt_stats_buf->chan_band_center_freq1));
3794
	len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq2 = %u\n",
3795
			 le32_to_cpu(htt_stats_buf->chan_band_center_freq2));
3796
	len += scnprintf(buf + len, buf_len - len, "chan_phy_mode = %u\n",
3797
			 le32_to_cpu(htt_stats_buf->chan_phy_mode));
3798
	len += scnprintf(buf + len, buf_len - len, "chan_flags = 0x%0x\n",
3799
			 le32_to_cpu(htt_stats_buf->chan_flags));
3800
	len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n",
3801
			 le32_to_cpu(htt_stats_buf->chan_num));
3802
	len += scnprintf(buf + len, buf_len - len, "reset_cause = 0x%0x\n",
3803
			 le32_to_cpu(htt_stats_buf->reset_cause));
3804
	len += scnprintf(buf + len, buf_len - len, "prev_reset_cause = 0x%0x\n",
3805
			 le32_to_cpu(htt_stats_buf->prev_reset_cause));
3806
	len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_src = 0x%0x\n",
3807
			 le32_to_cpu(htt_stats_buf->phy_warm_reset_src));
3808
	len += scnprintf(buf + len, buf_len - len, "rx_gain_tbl_mode = %d\n",
3809
			 le32_to_cpu(htt_stats_buf->rx_gain_tbl_mode));
3810
	len += scnprintf(buf + len, buf_len - len, "xbar_val = 0x%0x\n",
3811
			 le32_to_cpu(htt_stats_buf->xbar_val));
3812
	len += scnprintf(buf + len, buf_len - len, "force_calibration = %u\n",
3813
			 le32_to_cpu(htt_stats_buf->force_calibration));
3814
	len += scnprintf(buf + len, buf_len - len, "phyrf_mode = %u\n",
3815
			 le32_to_cpu(htt_stats_buf->phyrf_mode));
3816
	len += scnprintf(buf + len, buf_len - len, "phy_homechan = %u\n",
3817
			 le32_to_cpu(htt_stats_buf->phy_homechan));
3818
	len += scnprintf(buf + len, buf_len - len, "phy_tx_ch_mask = 0x%0x\n",
3819
			 le32_to_cpu(htt_stats_buf->phy_tx_ch_mask));
3820
	len += scnprintf(buf + len, buf_len - len, "phy_rx_ch_mask = 0x%0x\n",
3821
			 le32_to_cpu(htt_stats_buf->phy_rx_ch_mask));
3822
	len += scnprintf(buf + len, buf_len - len, "phybb_ini_mask = 0x%0x\n",
3823
			 le32_to_cpu(htt_stats_buf->phybb_ini_mask));
3824
	len += scnprintf(buf + len, buf_len - len, "phyrf_ini_mask = 0x%0x\n",
3825
			 le32_to_cpu(htt_stats_buf->phyrf_ini_mask));
3826
	len += scnprintf(buf + len, buf_len - len, "phy_dfs_en_mask = 0x%0x\n",
3827
			 le32_to_cpu(htt_stats_buf->phy_dfs_en_mask));
3828
	len += scnprintf(buf + len, buf_len - len, "phy_sscan_en_mask = 0x%0x\n",
3829
			 le32_to_cpu(htt_stats_buf->phy_sscan_en_mask));
3830
	len += scnprintf(buf + len, buf_len - len, "phy_synth_sel_mask = 0x%0x\n",
3831
			 le32_to_cpu(htt_stats_buf->phy_synth_sel_mask));
3832
	len += scnprintf(buf + len, buf_len - len, "phy_adfs_freq = %u\n",
3833
			 le32_to_cpu(htt_stats_buf->phy_adfs_freq));
3834
	len += scnprintf(buf + len, buf_len - len, "cck_fir_settings = 0x%0x\n",
3835
			 le32_to_cpu(htt_stats_buf->cck_fir_settings));
3836
	len += scnprintf(buf + len, buf_len - len, "phy_dyn_pri_chan = %u\n",
3837
			 le32_to_cpu(htt_stats_buf->phy_dyn_pri_chan));
3838
	len += scnprintf(buf + len, buf_len - len, "cca_thresh = 0x%0x\n",
3839
			 le32_to_cpu(htt_stats_buf->cca_thresh));
3840
	len += scnprintf(buf + len, buf_len - len, "dyn_cca_status = %u\n",
3841
			 le32_to_cpu(htt_stats_buf->dyn_cca_status));
3842
	len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_hw = 0x%x\n",
3843
			 le32_to_cpu(htt_stats_buf->rxdesense_thresh_hw));
3844
	len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_sw = 0x%x\n\n",
3845
			 le32_to_cpu(htt_stats_buf->rxdesense_thresh_sw));
3846

3847
	stats_req->buf_len = len;
3848
}
3849

3850
static void
3851
ath12k_htt_print_phy_reset_counters_tlv(const void *tag_buf, u16 tag_len,
3852
					struct debug_htt_stats_req *stats_req)
3853
{
3854
	const struct ath12k_htt_phy_reset_counters_tlv *htt_stats_buf = tag_buf;
3855
	u32 len = stats_req->buf_len;
3856
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3857
	u8 *buf = stats_req->buf;
3858

3859
	if (tag_len < sizeof(*htt_stats_buf))
3860
		return;
3861

3862
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_COUNTERS_TLV:\n");
3863
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
3864
			 le32_to_cpu(htt_stats_buf->pdev_id));
3865
	len += scnprintf(buf + len, buf_len - len, "cf_active_low_fail_cnt = %u\n",
3866
			 le32_to_cpu(htt_stats_buf->cf_active_low_fail_cnt));
3867
	len += scnprintf(buf + len, buf_len - len, "cf_active_low_pass_cnt = %u\n",
3868
			 le32_to_cpu(htt_stats_buf->cf_active_low_pass_cnt));
3869
	len += scnprintf(buf + len, buf_len - len, "phy_off_through_vreg_cnt = %u\n",
3870
			 le32_to_cpu(htt_stats_buf->phy_off_through_vreg_cnt));
3871
	len += scnprintf(buf + len, buf_len - len, "force_calibration_cnt = %u\n",
3872
			 le32_to_cpu(htt_stats_buf->force_calibration_cnt));
3873
	len += scnprintf(buf + len, buf_len - len, "rf_mode_switch_phy_off_cnt = %u\n",
3874
			 le32_to_cpu(htt_stats_buf->rf_mode_switch_phy_off_cnt));
3875
	len += scnprintf(buf + len, buf_len - len, "temperature_recal_cnt = %u\n\n",
3876
			 le32_to_cpu(htt_stats_buf->temperature_recal_cnt));
3877

3878
	stats_req->buf_len = len;
3879
}
3880

3881
static void
3882
ath12k_htt_print_phy_tpc_stats_tlv(const void *tag_buf, u16 tag_len,
3883
				   struct debug_htt_stats_req *stats_req)
3884
{
3885
	const struct ath12k_htt_phy_tpc_stats_tlv *htt_stats_buf = tag_buf;
3886
	u32 len = stats_req->buf_len;
3887
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3888
	u8 *buf = stats_req->buf;
3889

3890
	if (tag_len < sizeof(*htt_stats_buf))
3891
		return;
3892

3893
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_TPC_STATS_TLV:\n");
3894
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
3895
			 le32_to_cpu(htt_stats_buf->pdev_id));
3896
	len += scnprintf(buf + len, buf_len - len, "tx_power_scale = %u\n",
3897
			 le32_to_cpu(htt_stats_buf->tx_power_scale));
3898
	len += scnprintf(buf + len, buf_len - len, "tx_power_scale_db = %u\n",
3899
			 le32_to_cpu(htt_stats_buf->tx_power_scale_db));
3900
	len += scnprintf(buf + len, buf_len - len, "min_negative_tx_power = %d\n",
3901
			 le32_to_cpu(htt_stats_buf->min_negative_tx_power));
3902
	len += scnprintf(buf + len, buf_len - len, "reg_ctl_domain = %u\n",
3903
			 le32_to_cpu(htt_stats_buf->reg_ctl_domain));
3904
	len += scnprintf(buf + len, buf_len - len, "twice_max_rd_power = %u\n",
3905
			 le32_to_cpu(htt_stats_buf->twice_max_rd_power));
3906
	len += scnprintf(buf + len, buf_len - len, "max_tx_power = %u\n",
3907
			 le32_to_cpu(htt_stats_buf->max_tx_power));
3908
	len += scnprintf(buf + len, buf_len - len, "home_max_tx_power = %u\n",
3909
			 le32_to_cpu(htt_stats_buf->home_max_tx_power));
3910
	len += scnprintf(buf + len, buf_len - len, "psd_power = %d\n",
3911
			 le32_to_cpu(htt_stats_buf->psd_power));
3912
	len += scnprintf(buf + len, buf_len - len, "eirp_power = %u\n",
3913
			 le32_to_cpu(htt_stats_buf->eirp_power));
3914
	len += scnprintf(buf + len, buf_len - len, "power_type_6ghz = %u\n",
3915
			 le32_to_cpu(htt_stats_buf->power_type_6ghz));
3916
	len += print_array_to_buf(buf, len, "max_reg_allowed_power",
3917
				  htt_stats_buf->max_reg_allowed_power,
3918
				  ATH12K_HTT_STATS_MAX_CHAINS, "\n");
3919
	len += print_array_to_buf(buf, len, "max_reg_allowed_power_6ghz",
3920
				  htt_stats_buf->max_reg_allowed_power_6ghz,
3921
				  ATH12K_HTT_STATS_MAX_CHAINS, "\n");
3922
	len += print_array_to_buf(buf, len, "sub_band_cfreq",
3923
				  htt_stats_buf->sub_band_cfreq,
3924
				  ATH12K_HTT_MAX_CH_PWR_INFO_SIZE, "\n");
3925
	len += print_array_to_buf(buf, len, "sub_band_txpower",
3926
				  htt_stats_buf->sub_band_txpower,
3927
				  ATH12K_HTT_MAX_CH_PWR_INFO_SIZE, "\n\n");
3928

3929
	stats_req->buf_len = len;
3930
}
3931

3932
static void
3933
ath12k_htt_print_soc_txrx_stats_common_tlv(const void *tag_buf, u16 tag_len,
3934
					   struct debug_htt_stats_req *stats_req)
3935
{
3936
	const struct ath12k_htt_t2h_soc_txrx_stats_common_tlv *htt_stats_buf = tag_buf;
3937
	u64 drop_count;
3938
	u32 len = stats_req->buf_len;
3939
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3940
	u8 *buf = stats_req->buf;
3941

3942
	if (tag_len < sizeof(*htt_stats_buf))
3943
		return;
3944

3945
	drop_count = ath12k_le32hilo_to_u64(htt_stats_buf->inv_peers_msdu_drop_count_hi,
3946
					    htt_stats_buf->inv_peers_msdu_drop_count_lo);
3947

3948
	len += scnprintf(buf + len, buf_len - len, "HTT_SOC_COMMON_STATS_TLV:\n");
3949
	len += scnprintf(buf + len, buf_len - len, "soc_drop_count = %llu\n\n",
3950
			 drop_count);
3951

3952
	stats_req->buf_len = len;
3953
}
3954

3955
static void
3956
ath12k_htt_print_tx_per_rate_stats_tlv(const void *tag_buf, u16 tag_len,
3957
				       struct debug_htt_stats_req *stats_req)
3958
{
3959
	const struct ath12k_htt_tx_per_rate_stats_tlv *stats_buf = tag_buf;
3960
	u32 len = stats_req->buf_len;
3961
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
3962
	u32 ru_size_cnt = 0;
3963
	u32 rc_mode, ru_type;
3964
	u8 *buf = stats_req->buf, i;
3965
	const char *mode_prefix;
3966

3967
	if (tag_len < sizeof(*stats_buf))
3968
		return;
3969

3970
	rc_mode = le32_to_cpu(stats_buf->rc_mode);
3971
	ru_type = le32_to_cpu(stats_buf->ru_type);
3972

3973
	switch (rc_mode) {
3974
	case ATH12K_HTT_STATS_RC_MODE_DLSU:
3975
		len += scnprintf(buf + len, buf_len - len, "HTT_TX_PER_STATS:\n");
3976
		len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_SU:\n");
3977
		mode_prefix = "su";
3978
		break;
3979
	case ATH12K_HTT_STATS_RC_MODE_DLMUMIMO:
3980
		len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_DL_MUMIMO:\n");
3981
		mode_prefix = "mu";
3982
		break;
3983
	case ATH12K_HTT_STATS_RC_MODE_DLOFDMA:
3984
		len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_DL_OFDMA:\n");
3985
		mode_prefix = "ofdma";
3986
		if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY)
3987
			ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_STATS_NUM_AX_RU_SIZE_CNTRS;
3988
		else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU)
3989
			ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS;
3990
		break;
3991
	case ATH12K_HTT_STATS_RC_MODE_ULMUMIMO:
3992
		len += scnprintf(buf + len, buf_len - len, "HTT_RX_PER_STATS:\n");
3993
		len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_UL_MUMIMO:\n");
3994
		mode_prefix = "ulmu";
3995
		break;
3996
	case ATH12K_HTT_STATS_RC_MODE_ULOFDMA:
3997
		len += scnprintf(buf + len, buf_len - len, "\nPER_STATS_UL_OFDMA:\n");
3998
		mode_prefix = "ulofdma";
3999
		if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_RU_ONLY)
4000
			ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_STATS_NUM_AX_RU_SIZE_CNTRS;
4001
		else if (ru_type == ATH12K_HTT_STATS_RU_TYPE_SINGLE_AND_MULTI_RU)
4002
			ru_size_cnt = ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS;
4003
		break;
4004
	default:
4005
		return;
4006
	}
4007

4008
	len += scnprintf(buf + len, buf_len - len, "\nPER per BW:\n");
4009
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA ||
4010
	    rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO)
4011
		len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ",
4012
				 mode_prefix);
4013
	else
4014
		len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ",
4015
				 mode_prefix);
4016
	for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++)
4017
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4018
				 le32_to_cpu(stats_buf->per_bw[i].ppdus_tried));
4019
	len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i,
4020
			 le32_to_cpu(stats_buf->per_bw320.ppdus_tried));
4021

4022
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA ||
4023
	    rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO)
4024
		len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ",
4025
				 mode_prefix);
4026
	else
4027
		len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ",
4028
				 mode_prefix);
4029
	for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++)
4030
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4031
				 le32_to_cpu(stats_buf->per_bw[i].ppdus_ack_failed));
4032
	len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i,
4033
			 le32_to_cpu(stats_buf->per_bw320.ppdus_ack_failed));
4034

4035
	len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix);
4036
	for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++)
4037
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4038
				 le32_to_cpu(stats_buf->per_bw[i].mpdus_tried));
4039
	len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i,
4040
			 le32_to_cpu(stats_buf->per_bw320.mpdus_tried));
4041

4042
	len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix);
4043
	for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_BW_CNTRS; i++)
4044
		len += scnprintf(buf + len, buf_len - len, " %u:%u", i,
4045
				 le32_to_cpu(stats_buf->per_bw[i].mpdus_failed));
4046
	len += scnprintf(buf + len, buf_len - len, " %u:%u\n", i,
4047
			 le32_to_cpu(stats_buf->per_bw320.mpdus_failed));
4048

4049
	len += scnprintf(buf + len, buf_len - len, "\nPER per NSS:\n");
4050
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA ||
4051
	    rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO)
4052
		len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ",
4053
				 mode_prefix);
4054
	else
4055
		len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ",
4056
				 mode_prefix);
4057
	for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++)
4058
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1,
4059
				 le32_to_cpu(stats_buf->per_nss[i].ppdus_tried));
4060
	len += scnprintf(buf + len, buf_len - len, "\n");
4061

4062
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA ||
4063
	    rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO)
4064
		len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ",
4065
				 mode_prefix);
4066
	else
4067
		len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ",
4068
				 mode_prefix);
4069
	for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++)
4070
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1,
4071
				 le32_to_cpu(stats_buf->per_nss[i].ppdus_ack_failed));
4072
	len += scnprintf(buf + len, buf_len - len, "\n");
4073

4074
	len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix);
4075
	for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++)
4076
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1,
4077
				 le32_to_cpu(stats_buf->per_nss[i].mpdus_tried));
4078
	len += scnprintf(buf + len, buf_len - len, "\n");
4079

4080
	len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix);
4081
	for (i = 0; i < ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS; i++)
4082
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i + 1,
4083
				 le32_to_cpu(stats_buf->per_nss[i].mpdus_failed));
4084
	len += scnprintf(buf + len, buf_len - len, "\n");
4085

4086
	len += scnprintf(buf + len, buf_len - len, "\nPER per MCS:\n");
4087
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA ||
4088
	    rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO)
4089
		len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ",
4090
				 mode_prefix);
4091
	else
4092
		len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ",
4093
				 mode_prefix);
4094
	for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++)
4095
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4096
				 le32_to_cpu(stats_buf->per_mcs[i].ppdus_tried));
4097
	len += scnprintf(buf + len, buf_len - len, "\n");
4098

4099
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA ||
4100
	    rc_mode == ATH12K_HTT_STATS_RC_MODE_ULMUMIMO)
4101
		len += scnprintf(buf + len, buf_len - len, "non_data_ppdus_%s = ",
4102
				 mode_prefix);
4103
	else
4104
		len += scnprintf(buf + len, buf_len - len, "ppdus_ack_failed_%s = ",
4105
				 mode_prefix);
4106
	for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++)
4107
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4108
				 le32_to_cpu(stats_buf->per_mcs[i].ppdus_ack_failed));
4109
	len += scnprintf(buf + len, buf_len - len, "\n");
4110

4111
	len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ", mode_prefix);
4112
	for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++)
4113
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4114
				 le32_to_cpu(stats_buf->per_mcs[i].mpdus_tried));
4115
	len += scnprintf(buf + len, buf_len - len, "\n");
4116

4117
	len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ", mode_prefix);
4118
	for (i = 0; i < ATH12K_HTT_TXBF_RATE_STAT_NUM_MCS_CNTRS; i++)
4119
		len += scnprintf(buf + len, buf_len - len, " %u:%u ", i,
4120
				 le32_to_cpu(stats_buf->per_mcs[i].mpdus_failed));
4121
	len += scnprintf(buf + len, buf_len - len, "\n");
4122

4123
	if ((rc_mode == ATH12K_HTT_STATS_RC_MODE_DLOFDMA ||
4124
	     rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA) &&
4125
	     ru_type != ATH12K_HTT_STATS_RU_TYPE_INVALID) {
4126
		len += scnprintf(buf + len, buf_len - len, "\nPER per RU:\n");
4127

4128
		if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA)
4129
			len += scnprintf(buf + len, buf_len - len, "data_ppdus_%s = ",
4130
					 mode_prefix);
4131
		else
4132
			len += scnprintf(buf + len, buf_len - len, "ppdus_tried_%s = ",
4133
					 mode_prefix);
4134
		for (i = 0; i < ru_size_cnt; i++)
4135
			len += scnprintf(buf + len, buf_len - len, " %s:%u ",
4136
					 ath12k_tx_ru_size_to_str(ru_type, i),
4137
					 le32_to_cpu(stats_buf->ru[i].ppdus_tried));
4138
		len += scnprintf(buf + len, buf_len - len, "\n");
4139

4140
		if (rc_mode == ATH12K_HTT_STATS_RC_MODE_ULOFDMA)
4141
			len += scnprintf(buf + len, buf_len - len,
4142
					 "non_data_ppdus_%s = ", mode_prefix);
4143
		else
4144
			len += scnprintf(buf + len, buf_len - len,
4145
					 "ppdus_ack_failed_%s = ", mode_prefix);
4146
		for (i = 0; i < ru_size_cnt; i++)
4147
			len += scnprintf(buf + len, buf_len - len, " %s:%u ",
4148
					 ath12k_tx_ru_size_to_str(ru_type, i),
4149
					 le32_to_cpu(stats_buf->ru[i].ppdus_ack_failed));
4150
		len += scnprintf(buf + len, buf_len - len, "\n");
4151

4152
		len += scnprintf(buf + len, buf_len - len, "mpdus_tried_%s = ",
4153
				 mode_prefix);
4154
		for (i = 0; i < ru_size_cnt; i++)
4155
			len += scnprintf(buf + len, buf_len - len, " %s:%u ",
4156
					 ath12k_tx_ru_size_to_str(ru_type, i),
4157
					 le32_to_cpu(stats_buf->ru[i].mpdus_tried));
4158
		len += scnprintf(buf + len, buf_len - len, "\n");
4159

4160
		len += scnprintf(buf + len, buf_len - len, "mpdus_failed_%s = ",
4161
				 mode_prefix);
4162
		for (i = 0; i < ru_size_cnt; i++)
4163
			len += scnprintf(buf + len, buf_len - len, " %s:%u ",
4164
					 ath12k_tx_ru_size_to_str(ru_type, i),
4165
					 le32_to_cpu(stats_buf->ru[i].mpdus_failed));
4166
		len += scnprintf(buf + len, buf_len - len, "\n\n");
4167
	}
4168

4169
	if (rc_mode == ATH12K_HTT_STATS_RC_MODE_DLMUMIMO) {
4170
		len += scnprintf(buf + len, buf_len - len, "\nlast_probed_bw  = %u\n",
4171
				 le32_to_cpu(stats_buf->last_probed_bw));
4172
		len += scnprintf(buf + len, buf_len - len, "last_probed_nss = %u\n",
4173
				 le32_to_cpu(stats_buf->last_probed_nss));
4174
		len += scnprintf(buf + len, buf_len - len, "last_probed_mcs = %u\n",
4175
				 le32_to_cpu(stats_buf->last_probed_mcs));
4176
		len += print_array_to_buf(buf, len, "MU Probe count per RC MODE",
4177
					  stats_buf->probe_cnt,
4178
					  ATH12K_HTT_RC_MODE_2D_COUNT, "\n\n");
4179
	}
4180

4181
	stats_req->buf_len = len;
4182
}
4183

4184
static void
4185
ath12k_htt_print_ast_entry_tlv(const void *tag_buf, u16 tag_len,
4186
			       struct debug_htt_stats_req *stats_req)
4187
{
4188
	const struct ath12k_htt_ast_entry_tlv *htt_stats_buf = tag_buf;
4189
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4190
	u32 len = stats_req->buf_len;
4191
	u8 *buf = stats_req->buf;
4192
	u32 mac_addr_l32;
4193
	u32 mac_addr_h16;
4194
	u32 ast_info;
4195

4196
	if (tag_len < sizeof(*htt_stats_buf))
4197
		return;
4198

4199
	mac_addr_l32 = le32_to_cpu(htt_stats_buf->mac_addr.mac_addr_l32);
4200
	mac_addr_h16 = le32_to_cpu(htt_stats_buf->mac_addr.mac_addr_h16);
4201
	ast_info = le32_to_cpu(htt_stats_buf->info);
4202

4203
	len += scnprintf(buf + len, buf_len - len, "HTT_AST_ENTRY_TLV:\n");
4204
	len += scnprintf(buf + len, buf_len - len, "ast_index = %u\n",
4205
			 le32_to_cpu(htt_stats_buf->ast_index));
4206
	len += scnprintf(buf + len, buf_len - len,
4207
			 "mac_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
4208
			 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_0),
4209
			 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_1),
4210
			 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_2),
4211
			 u32_get_bits(mac_addr_l32, ATH12K_HTT_MAC_ADDR_L32_3),
4212
			 u32_get_bits(mac_addr_h16, ATH12K_HTT_MAC_ADDR_H16_0),
4213
			 u32_get_bits(mac_addr_h16, ATH12K_HTT_MAC_ADDR_H16_1));
4214

4215
	len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n",
4216
			 le32_to_cpu(htt_stats_buf->sw_peer_id));
4217
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
4218
			 u32_get_bits(ast_info, ATH12K_HTT_AST_PDEV_ID_INFO));
4219
	len += scnprintf(buf + len, buf_len - len, "vdev_id = %u\n",
4220
			 u32_get_bits(ast_info, ATH12K_HTT_AST_VDEV_ID_INFO));
4221
	len += scnprintf(buf + len, buf_len - len, "next_hop = %u\n",
4222
			 u32_get_bits(ast_info, ATH12K_HTT_AST_NEXT_HOP_INFO));
4223
	len += scnprintf(buf + len, buf_len - len, "mcast = %u\n",
4224
			 u32_get_bits(ast_info, ATH12K_HTT_AST_MCAST_INFO));
4225
	len += scnprintf(buf + len, buf_len - len, "monitor_direct = %u\n",
4226
			 u32_get_bits(ast_info, ATH12K_HTT_AST_MONITOR_DIRECT_INFO));
4227
	len += scnprintf(buf + len, buf_len - len, "mesh_sta = %u\n",
4228
			 u32_get_bits(ast_info, ATH12K_HTT_AST_MESH_STA_INFO));
4229
	len += scnprintf(buf + len, buf_len - len, "mec = %u\n",
4230
			 u32_get_bits(ast_info, ATH12K_HTT_AST_MEC_INFO));
4231
	len += scnprintf(buf + len, buf_len - len, "intra_bss = %u\n\n",
4232
			 u32_get_bits(ast_info, ATH12K_HTT_AST_INTRA_BSS_INFO));
4233

4234
	stats_req->buf_len = len;
4235
}
4236

4237
static const char*
4238
ath12k_htt_get_punct_dir_type_str(enum ath12k_htt_stats_direction direction)
4239
{
4240
	switch (direction) {
4241
	case ATH12K_HTT_STATS_DIRECTION_TX:
4242
		return "tx";
4243
	case ATH12K_HTT_STATS_DIRECTION_RX:
4244
		return "rx";
4245
	default:
4246
		return "unknown";
4247
	}
4248
}
4249

4250
static const char*
4251
ath12k_htt_get_punct_ppdu_type_str(enum ath12k_htt_stats_ppdu_type ppdu_type)
4252
{
4253
	switch (ppdu_type) {
4254
	case ATH12K_HTT_STATS_PPDU_TYPE_MODE_SU:
4255
		return "su";
4256
	case ATH12K_HTT_STATS_PPDU_TYPE_DL_MU_MIMO:
4257
		return "dl_mu_mimo";
4258
	case ATH12K_HTT_STATS_PPDU_TYPE_UL_MU_MIMO:
4259
		return "ul_mu_mimo";
4260
	case ATH12K_HTT_STATS_PPDU_TYPE_DL_MU_OFDMA:
4261
		return "dl_mu_ofdma";
4262
	case ATH12K_HTT_STATS_PPDU_TYPE_UL_MU_OFDMA:
4263
		return "ul_mu_ofdma";
4264
	default:
4265
		return "unknown";
4266
	}
4267
}
4268

4269
static const char*
4270
ath12k_htt_get_punct_pream_type_str(enum ath12k_htt_stats_param_type pream_type)
4271
{
4272
	switch (pream_type) {
4273
	case ATH12K_HTT_STATS_PREAM_OFDM:
4274
		return "ofdm";
4275
	case ATH12K_HTT_STATS_PREAM_CCK:
4276
		return "cck";
4277
	case ATH12K_HTT_STATS_PREAM_HT:
4278
		return "ht";
4279
	case ATH12K_HTT_STATS_PREAM_VHT:
4280
		return "ac";
4281
	case ATH12K_HTT_STATS_PREAM_HE:
4282
		return "ax";
4283
	case ATH12K_HTT_STATS_PREAM_EHT:
4284
		return "be";
4285
	default:
4286
		return "unknown";
4287
	}
4288
}
4289

4290
static void
4291
ath12k_htt_print_puncture_stats_tlv(const void *tag_buf, u16 tag_len,
4292
				    struct debug_htt_stats_req *stats_req)
4293
{
4294
	const struct ath12k_htt_pdev_puncture_stats_tlv *stats_buf = tag_buf;
4295
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4296
	u32 len = stats_req->buf_len;
4297
	u8 *buf = stats_req->buf;
4298
	const char *direction;
4299
	const char *ppdu_type;
4300
	const char *preamble;
4301
	u32 mac_id__word;
4302
	u32 subband_limit;
4303
	u8 i;
4304

4305
	if (tag_len < sizeof(*stats_buf))
4306
		return;
4307

4308
	mac_id__word = le32_to_cpu(stats_buf->mac_id__word);
4309
	subband_limit = min(le32_to_cpu(stats_buf->subband_cnt),
4310
			    ATH12K_HTT_PUNCT_STATS_MAX_SUBBAND_CNT);
4311

4312
	direction = ath12k_htt_get_punct_dir_type_str(le32_to_cpu(stats_buf->direction));
4313
	ppdu_type = ath12k_htt_get_punct_ppdu_type_str(le32_to_cpu(stats_buf->ppdu_type));
4314
	preamble = ath12k_htt_get_punct_pream_type_str(le32_to_cpu(stats_buf->preamble));
4315

4316
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_PUNCTURE_STATS_TLV:\n");
4317
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
4318
			 u32_get_bits(mac_id__word, ATH12K_HTT_STATS_MAC_ID));
4319
	len += scnprintf(buf + len, buf_len - len,
4320
			 "%s_%s_%s_last_used_pattern_mask = 0x%08x\n",
4321
			 direction, preamble, ppdu_type,
4322
			 le32_to_cpu(stats_buf->last_used_pattern_mask));
4323

4324
	for (i = 0; i < subband_limit; i++) {
4325
		len += scnprintf(buf + len, buf_len - len,
4326
				 "%s_%s_%s_num_subbands_used_cnt_%02d = %u\n",
4327
				 direction, preamble, ppdu_type, i + 1,
4328
				 le32_to_cpu(stats_buf->num_subbands_used_cnt[i]));
4329
	}
4330
	len += scnprintf(buf + len, buf_len - len, "\n");
4331

4332
	stats_req->buf_len = len;
4333
}
4334

4335
static void
4336
ath12k_htt_print_dmac_reset_stats_tlv(const void *tag_buf, u16 tag_len,
4337
				      struct debug_htt_stats_req *stats_req)
4338
{
4339
	const struct ath12k_htt_dmac_reset_stats_tlv *htt_stats_buf = tag_buf;
4340
	u8 *buf = stats_req->buf;
4341
	u32 len = stats_req->buf_len;
4342
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4343
	u64 time;
4344

4345
	if (tag_len < sizeof(*htt_stats_buf))
4346
		return;
4347

4348
	len += scnprintf(buf + len, buf_len - len, "HTT_DMAC_RESET_STATS_TLV:\n");
4349
	len += scnprintf(buf + len, buf_len - len, "reset_count = %u\n",
4350
			 le32_to_cpu(htt_stats_buf->reset_count));
4351
	time = ath12k_le32hilo_to_u64(htt_stats_buf->reset_time_hi_ms,
4352
				      htt_stats_buf->reset_time_lo_ms);
4353
	len += scnprintf(buf + len, buf_len - len, "reset_time_ms = %llu\n", time);
4354
	time = ath12k_le32hilo_to_u64(htt_stats_buf->disengage_time_hi_ms,
4355
				      htt_stats_buf->disengage_time_lo_ms);
4356
	len += scnprintf(buf + len, buf_len - len, "disengage_time_ms = %llu\n", time);
4357

4358
	time = ath12k_le32hilo_to_u64(htt_stats_buf->engage_time_hi_ms,
4359
				      htt_stats_buf->engage_time_lo_ms);
4360
	len += scnprintf(buf + len, buf_len - len, "engage_time_ms = %llu\n", time);
4361

4362
	len += scnprintf(buf + len, buf_len - len, "disengage_count = %u\n",
4363
			 le32_to_cpu(htt_stats_buf->disengage_count));
4364
	len += scnprintf(buf + len, buf_len - len, "engage_count = %u\n",
4365
			 le32_to_cpu(htt_stats_buf->engage_count));
4366
	len += scnprintf(buf + len, buf_len - len, "drain_dest_ring_mask = 0x%x\n\n",
4367
			 le32_to_cpu(htt_stats_buf->drain_dest_ring_mask));
4368

4369
	stats_req->buf_len = len;
4370
}
4371

4372
static void
4373
ath12k_htt_print_pdev_sched_algo_ofdma_stats_tlv(const void *tag_buf, u16 tag_len,
4374
						 struct debug_htt_stats_req *stats_req)
4375
{
4376
	const struct ath12k_htt_pdev_sched_algo_ofdma_stats_tlv *htt_stats_buf = tag_buf;
4377
	u8 *buf = stats_req->buf;
4378
	u32 len = stats_req->buf_len;
4379
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4380
	u32 mac_id_word;
4381

4382
	if (tag_len < sizeof(*htt_stats_buf))
4383
		return;
4384

4385
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word);
4386

4387
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_SCHED_ALGO_TLV:\n");
4388
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
4389
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
4390
	len += print_array_to_buf(buf, len, "rate_based_dlofdma_enabled_count",
4391
				  htt_stats_buf->rate_based_dlofdma_enabled_cnt,
4392
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4393
	len += print_array_to_buf(buf, len, "rate_based_dlofdma_disabled_count",
4394
				  htt_stats_buf->rate_based_dlofdma_disabled_cnt,
4395
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4396
	len += print_array_to_buf(buf, len, "rate_based_dlofdma_probing_count",
4397
				  htt_stats_buf->rate_based_dlofdma_disabled_cnt,
4398
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4399
	len += print_array_to_buf(buf, len, "rate_based_dlofdma_monitoring_count",
4400
				  htt_stats_buf->rate_based_dlofdma_monitor_cnt,
4401
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4402
	len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_enabled_count",
4403
				  htt_stats_buf->chan_acc_lat_based_dlofdma_enabled_cnt,
4404
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4405
	len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_disabled_count",
4406
				  htt_stats_buf->chan_acc_lat_based_dlofdma_disabled_cnt,
4407
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4408
	len += print_array_to_buf(buf, len, "chan_acc_lat_based_dlofdma_monitoring_count",
4409
				  htt_stats_buf->chan_acc_lat_based_dlofdma_monitor_cnt,
4410
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4411
	len += print_array_to_buf(buf, len, "downgrade_to_dl_su_ru_alloc_fail",
4412
				  htt_stats_buf->downgrade_to_dl_su_ru_alloc_fail,
4413
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4414
	len += print_array_to_buf(buf, len, "candidate_list_single_user_disable_ofdma",
4415
				  htt_stats_buf->candidate_list_single_user_disable_ofdma,
4416
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4417
	len += print_array_to_buf(buf, len, "dl_cand_list_dropped_high_ul_qos_weight",
4418
				  htt_stats_buf->dl_cand_list_dropped_high_ul_qos_weight,
4419
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4420
	len += print_array_to_buf(buf, len, "ax_dlofdma_disabled_due_to_pipelining",
4421
				  htt_stats_buf->ax_dlofdma_disabled_due_to_pipelining,
4422
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4423
	len += print_array_to_buf(buf, len, "dlofdma_disabled_su_only_eligible",
4424
				  htt_stats_buf->dlofdma_disabled_su_only_eligible,
4425
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4426
	len += print_array_to_buf(buf, len, "dlofdma_disabled_consec_no_mpdus_tried",
4427
				  htt_stats_buf->dlofdma_disabled_consec_no_mpdus_tried,
4428
				  ATH12K_HTT_NUM_AC_WMM, "\n");
4429
	len += print_array_to_buf(buf, len, "dlofdma_disabled_consec_no_mpdus_success",
4430
				  htt_stats_buf->dlofdma_disabled_consec_no_mpdus_success,
4431
				  ATH12K_HTT_NUM_AC_WMM, "\n\n");
4432

4433
	stats_req->buf_len = len;
4434
}
4435

4436
static void
4437
ath12k_htt_print_tx_pdev_rate_stats_be_ofdma_tlv(const void *tag_buf, u16 tag_len,
4438
						 struct debug_htt_stats_req *stats_req)
4439
{
4440
	const struct ath12k_htt_tx_pdev_rate_stats_be_ofdma_tlv *htt_stats_buf = tag_buf;
4441
	u8 *buf = stats_req->buf;
4442
	u32 len = stats_req->buf_len;
4443
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4444
	u32 mac_id_word;
4445
	u8 i;
4446

4447
	if (tag_len < sizeof(*htt_stats_buf))
4448
		return;
4449

4450
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word);
4451

4452
	len += scnprintf(buf + len, buf_len - len,
4453
			 "HTT_TX_PDEV_RATE_STATS_BE_OFDMA_TLV:\n");
4454
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
4455
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
4456
	len += scnprintf(buf + len, buf_len - len, "be_ofdma_tx_ldpc = %u\n",
4457
			 le32_to_cpu(htt_stats_buf->be_ofdma_tx_ldpc));
4458
	len += print_array_to_buf(buf, len, "be_ofdma_tx_mcs",
4459
				  htt_stats_buf->be_ofdma_tx_mcs,
4460
				  ATH12K_HTT_TX_PDEV_NUM_BE_MCS_CNTRS, "\n");
4461
	len += print_array_to_buf(buf, len, "be_ofdma_eht_sig_mcs",
4462
				  htt_stats_buf->be_ofdma_eht_sig_mcs,
4463
				  ATH12K_HTT_TX_PDEV_NUM_EHT_SIG_MCS_CNTRS, "\n");
4464
	len += scnprintf(buf + len, buf_len - len, "be_ofdma_tx_ru_size = ");
4465
	for (i = 0; i < ATH12K_HTT_TX_RX_PDEV_NUM_BE_RU_SIZE_CNTRS; i++)
4466
		len += scnprintf(buf + len, buf_len - len, " %s:%u ",
4467
				 ath12k_htt_be_tx_rx_ru_size_to_str(i),
4468
				 le32_to_cpu(htt_stats_buf->be_ofdma_tx_ru_size[i]));
4469
	len += scnprintf(buf + len, buf_len - len, "\n");
4470
	len += print_array_to_buf_index(buf, len, "be_ofdma_tx_nss = ", 1,
4471
					htt_stats_buf->be_ofdma_tx_nss,
4472
					ATH12K_HTT_PDEV_STAT_NUM_SPATIAL_STREAMS,
4473
					"\n");
4474
	len += print_array_to_buf(buf, len, "be_ofdma_tx_bw",
4475
				  htt_stats_buf->be_ofdma_tx_bw,
4476
				  ATH12K_HTT_TX_PDEV_NUM_BE_BW_CNTRS, "\n");
4477
	for (i = 0; i < ATH12K_HTT_TX_PDEV_NUM_GI_CNTRS; i++) {
4478
		len += scnprintf(buf + len, buf_len - len,
4479
				 "be_ofdma_tx_gi[%u]", i);
4480
		len += print_array_to_buf(buf, len, "", htt_stats_buf->gi[i],
4481
					  ATH12K_HTT_TX_PDEV_NUM_BE_MCS_CNTRS, "\n");
4482
	}
4483
	len += scnprintf(buf + len, buf_len - len, "\n");
4484

4485
	stats_req->buf_len = len;
4486
}
4487

4488
static void
4489
ath12k_htt_print_pdev_mbssid_ctrl_frame_stats_tlv(const void *tag_buf, u16 tag_len,
4490
						  struct debug_htt_stats_req *stats_req)
4491
{
4492
	const struct ath12k_htt_pdev_mbssid_ctrl_frame_tlv *htt_stats_buf = tag_buf;
4493
	u8 *buf = stats_req->buf;
4494
	u32 len = stats_req->buf_len;
4495
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4496
	u32 mac_id_word;
4497

4498
	if (tag_len < sizeof(*htt_stats_buf))
4499
		return;
4500

4501
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word);
4502

4503
	len += scnprintf(buf + len, buf_len - len, "HTT_MBSSID_CTRL_FRAME_STATS_TLV:\n");
4504
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
4505
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
4506
	len += scnprintf(buf + len, buf_len - len, "basic_trigger_across_bss = %u\n",
4507
			 le32_to_cpu(htt_stats_buf->basic_trigger_across_bss));
4508
	len += scnprintf(buf + len, buf_len - len, "basic_trigger_within_bss = %u\n",
4509
			 le32_to_cpu(htt_stats_buf->basic_trigger_within_bss));
4510
	len += scnprintf(buf + len, buf_len - len, "bsr_trigger_across_bss = %u\n",
4511
			 le32_to_cpu(htt_stats_buf->bsr_trigger_across_bss));
4512
	len += scnprintf(buf + len, buf_len - len, "bsr_trigger_within_bss = %u\n",
4513
			 le32_to_cpu(htt_stats_buf->bsr_trigger_within_bss));
4514
	len += scnprintf(buf + len, buf_len - len, "mu_rts_across_bss = %u\n",
4515
			 le32_to_cpu(htt_stats_buf->mu_rts_across_bss));
4516
	len += scnprintf(buf + len, buf_len - len, "mu_rts_within_bss = %u\n",
4517
			 le32_to_cpu(htt_stats_buf->mu_rts_within_bss));
4518
	len += scnprintf(buf + len, buf_len - len, "ul_mumimo_trigger_across_bss = %u\n",
4519
			 le32_to_cpu(htt_stats_buf->ul_mumimo_trigger_across_bss));
4520
	len += scnprintf(buf + len, buf_len - len,
4521
			 "ul_mumimo_trigger_within_bss = %u\n\n",
4522
			 le32_to_cpu(htt_stats_buf->ul_mumimo_trigger_within_bss));
4523

4524
	stats_req->buf_len = len;
4525
}
4526

4527
static inline void
4528
ath12k_htt_print_tx_pdev_rate_stats_tlv(const void *tag_buf, u16 tag_len,
4529
					struct debug_htt_stats_req *stats_req)
4530
{
4531
	const struct ath12k_htt_tx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf;
4532
	u8 *buf = stats_req->buf;
4533
	u32 len = stats_req->buf_len;
4534
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4535
	u8 i, j;
4536
	u32 mac_id_word;
4537

4538
	if (tag_len < sizeof(*htt_stats_buf))
4539
		return;
4540

4541
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id_word);
4542

4543
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_RATE_STATS_TLV:\n");
4544
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
4545
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
4546
	len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n",
4547
			 le32_to_cpu(htt_stats_buf->tx_ldpc));
4548
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_tx_ldpc = %u\n",
4549
			 le32_to_cpu(htt_stats_buf->ac_mu_mimo_tx_ldpc));
4550
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_tx_ldpc = %u\n",
4551
			 le32_to_cpu(htt_stats_buf->ax_mu_mimo_tx_ldpc));
4552
	len += scnprintf(buf + len, buf_len - len, "ofdma_tx_ldpc = %u\n",
4553
			 le32_to_cpu(htt_stats_buf->ofdma_tx_ldpc));
4554
	len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
4555
			 le32_to_cpu(htt_stats_buf->rts_cnt));
4556
	len += scnprintf(buf + len, buf_len - len, "rts_success = %u\n",
4557
			 le32_to_cpu(htt_stats_buf->rts_success));
4558
	len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n",
4559
			 le32_to_cpu(htt_stats_buf->ack_rssi));
4560
	len += scnprintf(buf + len, buf_len - len,
4561
			 "Legacy CCK Rates: 1 Mbps: %u, 2 Mbps: %u, 5.5 Mbps: %u, 12 Mbps: %u\n",
4562
			 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[0]),
4563
			 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[1]),
4564
			 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[2]),
4565
			 le32_to_cpu(htt_stats_buf->tx_legacy_cck_rate[3]));
4566
	len += scnprintf(buf + len, buf_len - len,
4567
			 "Legacy OFDM Rates: 6 Mbps: %u, 9 Mbps: %u, 12 Mbps: %u, 18 Mbps: %u\n"
4568
			 "                   24 Mbps: %u, 36 Mbps: %u, 48 Mbps: %u, 54 Mbps: %u\n",
4569
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[0]),
4570
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[1]),
4571
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[2]),
4572
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[3]),
4573
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[4]),
4574
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[5]),
4575
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[6]),
4576
			 le32_to_cpu(htt_stats_buf->tx_legacy_ofdm_rate[7]));
4577
	len += scnprintf(buf + len, buf_len - len, "HE LTF: 1x: %u, 2x: %u, 4x: %u\n",
4578
			 le32_to_cpu(htt_stats_buf->tx_he_ltf[1]),
4579
			 le32_to_cpu(htt_stats_buf->tx_he_ltf[2]),
4580
			 le32_to_cpu(htt_stats_buf->tx_he_ltf[3]));
4581

4582
	len += print_array_to_buf(buf, len, "tx_mcs", htt_stats_buf->tx_mcs,
4583
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL);
4584
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++)
4585
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4586
				 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4587
				 le32_to_cpu(htt_stats_buf->tx_mcs_ext[j]));
4588
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA2_MCS_COUNTERS; j++)
4589
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4590
				 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS +
4591
				 ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA2_MCS_COUNTERS,
4592
				 le32_to_cpu(htt_stats_buf->tx_mcs_ext_2[j]));
4593
	len += scnprintf(buf + len, buf_len - len, "\n");
4594

4595
	len += print_array_to_buf(buf, len, "ax_mu_mimo_tx_mcs",
4596
				  htt_stats_buf->ax_mu_mimo_tx_mcs,
4597
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL);
4598
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++)
4599
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4600
				 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4601
				 le32_to_cpu(htt_stats_buf->ax_mu_mimo_tx_mcs_ext[j]));
4602
	len += scnprintf(buf + len, buf_len - len, "\n");
4603

4604
	len += print_array_to_buf(buf, len, "ofdma_tx_mcs",
4605
				  htt_stats_buf->ofdma_tx_mcs,
4606
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL);
4607
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++)
4608
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4609
				 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4610
				 le32_to_cpu(htt_stats_buf->ofdma_tx_mcs_ext[j]));
4611
	len += scnprintf(buf + len, buf_len - len, "\n");
4612

4613
	len += scnprintf(buf + len, buf_len - len, "tx_nss =");
4614
	for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++)
4615
		len += scnprintf(buf + len, buf_len - len, " %u:%u,",
4616
				 j, le32_to_cpu(htt_stats_buf->tx_nss[j - 1]));
4617
	len--;
4618
	len += scnprintf(buf + len, buf_len - len, "\n");
4619

4620
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_tx_nss =");
4621
	for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++)
4622
		len += scnprintf(buf + len, buf_len - len, " %u:%u,",
4623
				 j, le32_to_cpu(htt_stats_buf->ac_mu_mimo_tx_nss[j - 1]));
4624
	len--;
4625
	len += scnprintf(buf + len, buf_len - len, "\n");
4626

4627
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_tx_nss =");
4628
	for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++)
4629
		len += scnprintf(buf + len, buf_len - len, " %u:%u,",
4630
				 j, le32_to_cpu(htt_stats_buf->ax_mu_mimo_tx_nss[j - 1]));
4631
	len--;
4632
	len += scnprintf(buf + len, buf_len - len, "\n");
4633

4634
	len += scnprintf(buf + len, buf_len - len, "ofdma_tx_nss =");
4635
	for (j = 1; j <= ATH12K_HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++)
4636
		len += scnprintf(buf + len, buf_len - len, " %u:%u,",
4637
				 j, le32_to_cpu(htt_stats_buf->ofdma_tx_nss[j - 1]));
4638
	len--;
4639
	len += scnprintf(buf + len, buf_len - len, "\n");
4640

4641
	len += print_array_to_buf(buf, len, "tx_bw", htt_stats_buf->tx_bw,
4642
				  ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, NULL);
4643
	len += scnprintf(buf + len, buf_len - len, ", %u:%u\n",
4644
			 ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS,
4645
			 le32_to_cpu(htt_stats_buf->tx_bw_320mhz));
4646

4647
	len += print_array_to_buf(buf, len, "tx_stbc",
4648
				  htt_stats_buf->tx_stbc,
4649
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, NULL);
4650
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++)
4651
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4652
				 j + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4653
				 le32_to_cpu(htt_stats_buf->tx_stbc_ext[j]));
4654
	len += scnprintf(buf + len, buf_len - len, "\n");
4655

4656
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
4657
		len += scnprintf(buf + len, (buf_len - len),
4658
				 "tx_gi[%u] =", j);
4659
		len += print_array_to_buf(buf, len, NULL, htt_stats_buf->tx_gi[j],
4660
					  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4661
					  NULL);
4662
		for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; i++)
4663
			len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4664
					 i + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4665
					 le32_to_cpu(htt_stats_buf->tx_gi_ext[j][i]));
4666
		len += scnprintf(buf + len, buf_len - len, "\n");
4667
	}
4668

4669
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
4670
		len += scnprintf(buf + len, (buf_len - len),
4671
				 "ac_mu_mimo_tx_gi[%u] =", j);
4672
		len += print_array_to_buf(buf, len, NULL,
4673
					  htt_stats_buf->ac_mu_mimo_tx_gi[j],
4674
					  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4675
					  "\n");
4676
	}
4677

4678
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
4679
		len += scnprintf(buf + len, (buf_len - len),
4680
				 "ax_mu_mimo_tx_gi[%u] =", j);
4681
		len += print_array_to_buf(buf, len, NULL, htt_stats_buf->ax_mimo_tx_gi[j],
4682
					  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4683
					  NULL);
4684
		for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; i++)
4685
			len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4686
					 i + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4687
					 le32_to_cpu(htt_stats_buf->ax_tx_gi_ext[j][i]));
4688
		len += scnprintf(buf + len, buf_len - len, "\n");
4689
	}
4690

4691
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
4692
		len += scnprintf(buf + len, (buf_len - len),
4693
				 "ofdma_tx_gi[%u] = ", j);
4694
		len += print_array_to_buf(buf, len, NULL, htt_stats_buf->ofdma_tx_gi[j],
4695
					  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4696
					  NULL);
4697
		for (i = 0; i < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; i++)
4698
			len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4699
					 i + ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS,
4700
					 le32_to_cpu(htt_stats_buf->ofd_tx_gi_ext[j][i]));
4701
		len += scnprintf(buf + len, buf_len - len, "\n");
4702
	}
4703

4704
	len += print_array_to_buf(buf, len, "tx_su_mcs", htt_stats_buf->tx_su_mcs,
4705
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4706
	len += print_array_to_buf(buf, len, "tx_mu_mcs", htt_stats_buf->tx_mu_mcs,
4707
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4708
	len += print_array_to_buf(buf, len, "ac_mu_mimo_tx_mcs",
4709
				  htt_stats_buf->ac_mu_mimo_tx_mcs,
4710
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4711
	len += print_array_to_buf(buf, len, "ac_mu_mimo_tx_bw",
4712
				  htt_stats_buf->ac_mu_mimo_tx_bw,
4713
				  ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
4714
	len += print_array_to_buf(buf, len, "ax_mu_mimo_tx_bw",
4715
				  htt_stats_buf->ax_mu_mimo_tx_bw,
4716
				  ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
4717
	len += print_array_to_buf(buf, len, "ofdma_tx_bw",
4718
				  htt_stats_buf->ofdma_tx_bw,
4719
				  ATH12K_HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
4720
	len += print_array_to_buf(buf, len, "tx_pream", htt_stats_buf->tx_pream,
4721
				  ATH12K_HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");
4722
	len += print_array_to_buf(buf, len, "tx_dcm", htt_stats_buf->tx_dcm,
4723
				  ATH12K_HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\n");
4724

4725
	stats_req->buf_len = len;
4726
}
4727

4728
static void
4729
ath12k_htt_print_histogram_stats_tlv(const void *tag_buf, u16 tag_len,
4730
				     struct debug_htt_stats_req *stats_req)
4731
{
4732
	const struct ath12k_htt_tx_histogram_stats_tlv *stats_buf = tag_buf;
4733
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4734
	u32 len = stats_req->buf_len;
4735
	u8 *buf = stats_req->buf;
4736

4737
	if (tag_len < sizeof(*stats_buf))
4738
		return;
4739

4740
	len += scnprintf(buf + len, buf_len - len, "low_latency_rate_cnt =  %u\n",
4741
			 le32_to_cpu(stats_buf->low_latency_rate_cnt));
4742
	len += scnprintf(buf + len, buf_len - len, "su_burst_rate_drop_cnt = %u\n",
4743
			 le32_to_cpu(stats_buf->su_burst_rate_drop_cnt));
4744
	len += scnprintf(buf + len, buf_len - len, "su_burst_rate_drop_fail_cnt = %u\n",
4745
			 le32_to_cpu(stats_buf->su_burst_rate_drop_fail_cnt));
4746
	len += scnprintf(buf + len, buf_len - len, "rate_retry_mcs_drop_cnt = %u\n",
4747
			 le32_to_cpu(stats_buf->rate_retry_mcs_drop_cnt));
4748

4749
	len += scnprintf(buf + len, buf_len - len, "\nPER_HISTOGRAM_STATS\n");
4750
	len += print_array_to_buf(buf, len, "mcs_drop_rate", stats_buf->mcs_drop_rate,
4751
				  ATH12K_HTT_TX_PDEV_STATS_NUM_MCS_DROP_COUNTERS, "\n");
4752
	len += print_array_to_buf(buf, len, "per_histogram_count",
4753
				  stats_buf->per_histogram_cnt,
4754
				  ATH12K_HTT_TX_PDEV_STATS_NUM_PER_COUNTERS, "\n\n");
4755

4756
	stats_req->buf_len = len;
4757
}
4758

4759
static inline void
4760
ath12k_htt_print_rx_pdev_rate_stats_tlv(const void *tag_buf, u16 tag_len,
4761
					struct debug_htt_stats_req *stats_req)
4762
{
4763
	const struct ath12k_htt_rx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf;
4764
	u8 *buf = stats_req->buf;
4765
	u32 len = stats_req->buf_len;
4766
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4767
	u8 i, j;
4768
	u32 mac_id_word;
4769

4770
	if (tag_len < sizeof(*htt_stats_buf))
4771
		return;
4772

4773
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id_word);
4774

4775
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_STATS_TLV:\n");
4776
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
4777
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
4778
	len += scnprintf(buf + len, buf_len - len, "nsts = %u\n",
4779
			 le32_to_cpu(htt_stats_buf->nsts));
4780
	len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n",
4781
			 le32_to_cpu(htt_stats_buf->rx_ldpc));
4782
	len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
4783
			 le32_to_cpu(htt_stats_buf->rts_cnt));
4784
	len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n",
4785
			 le32_to_cpu(htt_stats_buf->rssi_mgmt));
4786
	len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n",
4787
			 le32_to_cpu(htt_stats_buf->rssi_data));
4788
	len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n",
4789
			 le32_to_cpu(htt_stats_buf->rssi_comb));
4790
	len += scnprintf(buf + len, buf_len - len, "rssi_in_dbm = %d\n",
4791
			 le32_to_cpu(htt_stats_buf->rssi_in_dbm));
4792
	len += scnprintf(buf + len, buf_len - len, "rx_evm_nss_count = %u\n",
4793
			 le32_to_cpu(htt_stats_buf->nss_count));
4794
	len += scnprintf(buf + len, buf_len - len, "rx_evm_pilot_count = %u\n",
4795
			 le32_to_cpu(htt_stats_buf->pilot_count));
4796
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_su_ext = %u\n",
4797
			 le32_to_cpu(htt_stats_buf->rx_11ax_su_ext));
4798
	len += scnprintf(buf + len, buf_len - len, "rx_11ac_mumimo = %u\n",
4799
			 le32_to_cpu(htt_stats_buf->rx_11ac_mumimo));
4800
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_mumimo = %u\n",
4801
			 le32_to_cpu(htt_stats_buf->rx_11ax_mumimo));
4802
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_ofdma = %u\n",
4803
			 le32_to_cpu(htt_stats_buf->rx_11ax_ofdma));
4804
	len += scnprintf(buf + len, buf_len - len, "txbf = %u\n",
4805
			 le32_to_cpu(htt_stats_buf->txbf));
4806
	len += scnprintf(buf + len, buf_len - len, "rx_su_ndpa = %u\n",
4807
			 le32_to_cpu(htt_stats_buf->rx_su_ndpa));
4808
	len += scnprintf(buf + len, buf_len - len, "rx_mu_ndpa = %u\n",
4809
			 le32_to_cpu(htt_stats_buf->rx_mu_ndpa));
4810
	len += scnprintf(buf + len, buf_len - len, "rx_br_poll = %u\n",
4811
			 le32_to_cpu(htt_stats_buf->rx_br_poll));
4812
	len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_low = %u\n",
4813
			 le32_to_cpu(htt_stats_buf->rx_active_dur_us_low));
4814
	len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_high = %u\n",
4815
			 le32_to_cpu(htt_stats_buf->rx_active_dur_us_high));
4816
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_ofdma = %u\n",
4817
			 le32_to_cpu(htt_stats_buf->rx_11ax_ul_ofdma));
4818
	len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_stbc = %u\n",
4819
			 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_stbc));
4820
	len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_ldpc = %u\n",
4821
			 le32_to_cpu(htt_stats_buf->ul_ofdma_rx_ldpc));
4822
	len += scnprintf(buf + len, buf_len - len, "per_chain_rssi_pkt_type = %#x\n",
4823
			 le32_to_cpu(htt_stats_buf->per_chain_rssi_pkt_type));
4824

4825
	len += print_array_to_buf(buf, len, "rx_nss", htt_stats_buf->rx_nss,
4826
				  ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
4827
	len += print_array_to_buf(buf, len, "rx_dcm", htt_stats_buf->rx_dcm,
4828
				  ATH12K_HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n");
4829
	len += print_array_to_buf(buf, len, "rx_stbc", htt_stats_buf->rx_stbc,
4830
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4831
	len += print_array_to_buf(buf, len, "rx_bw", htt_stats_buf->rx_bw,
4832
				  ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
4833
	len += print_array_to_buf(buf, len, "rx_pream", htt_stats_buf->rx_pream,
4834
				  ATH12K_HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");
4835
	len += print_array_to_buf(buf, len, "rx_11ax_su_txbf_mcs",
4836
				  htt_stats_buf->rx_11ax_su_txbf_mcs,
4837
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4838
	len += print_array_to_buf(buf, len, "rx_11ax_mu_txbf_mcs",
4839
				  htt_stats_buf->rx_11ax_mu_txbf_mcs,
4840
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4841
	len += print_array_to_buf(buf, len, "rx_legacy_cck_rate",
4842
				  htt_stats_buf->rx_legacy_cck_rate,
4843
				  ATH12K_HTT_RX_PDEV_STATS_NUM_LEGACY_CCK_STATS, "\n");
4844
	len += print_array_to_buf(buf, len, "rx_legacy_ofdm_rate",
4845
				  htt_stats_buf->rx_legacy_ofdm_rate,
4846
				  ATH12K_HTT_RX_PDEV_STATS_NUM_LEGACY_OFDM_STATS, "\n");
4847
	len += print_array_to_buf(buf, len, "ul_ofdma_rx_mcs",
4848
				  htt_stats_buf->ul_ofdma_rx_mcs,
4849
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4850
	len += print_array_to_buf(buf, len, "ul_ofdma_rx_nss",
4851
				  htt_stats_buf->ul_ofdma_rx_nss,
4852
				  ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
4853
	len += print_array_to_buf(buf, len, "ul_ofdma_rx_bw",
4854
				  htt_stats_buf->ul_ofdma_rx_bw,
4855
				  ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
4856
	len += print_array_to_buf(buf, len, "rx_ulofdma_non_data_ppdu",
4857
				  htt_stats_buf->rx_ulofdma_non_data_ppdu,
4858
				  ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
4859
	len += print_array_to_buf(buf, len, "rx_ulofdma_data_ppdu",
4860
				  htt_stats_buf->rx_ulofdma_data_ppdu,
4861
				  ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
4862
	len += print_array_to_buf(buf, len, "rx_ulofdma_mpdu_ok",
4863
				  htt_stats_buf->rx_ulofdma_mpdu_ok,
4864
				  ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
4865
	len += print_array_to_buf(buf, len, "rx_ulofdma_mpdu_fail",
4866
				  htt_stats_buf->rx_ulofdma_mpdu_fail,
4867
				  ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
4868
	len += print_array_to_buf(buf, len, "rx_ulofdma_non_data_nusers",
4869
				  htt_stats_buf->rx_ulofdma_non_data_nusers,
4870
				  ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
4871
	len += print_array_to_buf(buf, len, "rx_ulofdma_data_nusers",
4872
				  htt_stats_buf->rx_ulofdma_data_nusers,
4873
				  ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
4874
	len += print_array_to_buf(buf, len, "rx_11ax_dl_ofdma_mcs",
4875
				  htt_stats_buf->rx_11ax_dl_ofdma_mcs,
4876
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
4877
	len += print_array_to_buf(buf, len, "rx_11ax_dl_ofdma_ru",
4878
				  htt_stats_buf->rx_11ax_dl_ofdma_ru,
4879
				  ATH12K_HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS, "\n");
4880
	len += print_array_to_buf(buf, len, "rx_ulmumimo_non_data_ppdu",
4881
				  htt_stats_buf->rx_ulmumimo_non_data_ppdu,
4882
				  ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n");
4883
	len += print_array_to_buf(buf, len, "rx_ulmumimo_data_ppdu",
4884
				  htt_stats_buf->rx_ulmumimo_data_ppdu,
4885
				  ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n");
4886
	len += print_array_to_buf(buf, len, "rx_ulmumimo_mpdu_ok",
4887
				  htt_stats_buf->rx_ulmumimo_mpdu_ok,
4888
				  ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n");
4889
	len += print_array_to_buf(buf, len, "rx_ulmumimo_mpdu_fail",
4890
				  htt_stats_buf->rx_ulmumimo_mpdu_fail,
4891
				  ATH12K_HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER, "\n");
4892

4893
	len += print_array_to_buf(buf, len, "rx_mcs",
4894
				  htt_stats_buf->rx_mcs,
4895
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, NULL);
4896
	for (j = 0; j < ATH12K_HTT_TX_PDEV_STATS_NUM_EXTRA_MCS_COUNTERS; j++)
4897
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
4898
				 j + ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS,
4899
				 le32_to_cpu(htt_stats_buf->rx_mcs_ext[j]));
4900
	len += scnprintf(buf + len, buf_len - len, "\n");
4901

4902
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
4903
		len += scnprintf(buf + len, buf_len - len,
4904
				 "pilot_evm_db[%u] =", j);
4905
		len += print_array_to_buf(buf, len, NULL,
4906
					  htt_stats_buf->rx_pil_evm_db[j],
4907
					  ATH12K_HTT_RX_PDEV_STATS_RXEVM_MAX_PILOTS_NSS,
4908
					  "\n");
4909
	}
4910

4911
	len += scnprintf(buf + len, buf_len - len, "pilot_evm_db_mean =");
4912
	for (i = 0; i < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
4913
		len += scnprintf(buf + len,
4914
				 buf_len - len,
4915
				 " %u:%d,", i,
4916
				 le32_to_cpu(htt_stats_buf->rx_pilot_evm_db_mean[i]));
4917
	len--;
4918
	len += scnprintf(buf + len, buf_len - len, "\n");
4919

4920
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
4921
		len += scnprintf(buf + len, buf_len - len,
4922
				 "rssi_chain_in_db[%u] = ", j);
4923
		for (i = 0; i < ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++)
4924
			len += scnprintf(buf + len,
4925
					 buf_len - len,
4926
					 " %u: %d,", i,
4927
					 htt_stats_buf->rssi_chain_in_db[j][i]);
4928
		len--;
4929
		len += scnprintf(buf + len, buf_len - len, "\n");
4930
	}
4931

4932
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
4933
		len += scnprintf(buf + len, buf_len - len,
4934
				 "rx_gi[%u] = ", j);
4935
		len += print_array_to_buf(buf, len, NULL,
4936
					  htt_stats_buf->rx_gi[j],
4937
					  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS,
4938
					  "\n");
4939
	}
4940

4941
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
4942
		len += scnprintf(buf + len, buf_len - len,
4943
				 "ul_ofdma_rx_gi[%u] = ", j);
4944
		len += print_array_to_buf(buf, len, NULL,
4945
					  htt_stats_buf->ul_ofdma_rx_gi[j],
4946
					  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS,
4947
					  "\n");
4948
	}
4949

4950
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
4951
		len += scnprintf(buf + len, buf_len - len,
4952
				 "rx_ul_fd_rssi: nss[%u] = ", j);
4953
		for (i = 0; i < ATH12K_HTT_RX_PDEV_MAX_OFDMA_NUM_USER; i++)
4954
			len += scnprintf(buf + len,
4955
					 buf_len - len,
4956
					 " %u:%d,",
4957
					 i, htt_stats_buf->rx_ul_fd_rssi[j][i]);
4958
		len--;
4959
		len += scnprintf(buf + len, buf_len - len, "\n");
4960
	}
4961

4962
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
4963
		len += scnprintf(buf + len, buf_len - len,
4964
				 "rx_per_chain_rssi_in_dbm[%u] =", j);
4965
		for (i = 0; i < ATH12K_HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++)
4966
			len += scnprintf(buf + len,
4967
					 buf_len - len,
4968
					 " %u:%d,",
4969
					 i,
4970
					 htt_stats_buf->rx_per_chain_rssi_in_dbm[j][i]);
4971
		len--;
4972
		len += scnprintf(buf + len, buf_len - len, "\n");
4973
	}
4974

4975
	stats_req->buf_len = len;
4976
}
4977

4978
static inline void
4979
ath12k_htt_print_rx_pdev_rate_ext_stats_tlv(const void *tag_buf, u16 tag_len,
4980
					    struct debug_htt_stats_req *stats_req)
4981
{
4982
	const struct ath12k_htt_rx_pdev_rate_ext_stats_tlv *htt_stats_buf = tag_buf;
4983
	u8 *buf = stats_req->buf;
4984
	u32 len = stats_req->buf_len;
4985
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
4986
	u8 j;
4987

4988
	if (tag_len < sizeof(*htt_stats_buf))
4989
		return;
4990

4991
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_EXT_STATS_TLV:\n");
4992
	len += scnprintf(buf + len, buf_len - len, "rssi_mgmt_in_dbm = %d\n",
4993
			 le32_to_cpu(htt_stats_buf->rssi_mgmt_in_dbm));
4994

4995
	len += print_array_to_buf(buf, len, "rx_stbc_ext",
4996
				  htt_stats_buf->rx_stbc_ext,
4997
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n");
4998
	len += print_array_to_buf(buf, len, "ul_ofdma_rx_mcs_ext",
4999
				  htt_stats_buf->ul_ofdma_rx_mcs_ext,
5000
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n");
5001
	len += print_array_to_buf(buf, len, "rx_11ax_su_txbf_mcs_ext",
5002
				  htt_stats_buf->rx_11ax_su_txbf_mcs_ext,
5003
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n");
5004
	len += print_array_to_buf(buf, len, "rx_11ax_mu_txbf_mcs_ext",
5005
				  htt_stats_buf->rx_11ax_mu_txbf_mcs_ext,
5006
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n");
5007
	len += print_array_to_buf(buf, len, "rx_11ax_dl_ofdma_mcs_ext",
5008
				  htt_stats_buf->rx_11ax_dl_ofdma_mcs_ext,
5009
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT, "\n");
5010
	len += print_array_to_buf(buf, len, "rx_bw_ext",
5011
				  htt_stats_buf->rx_bw_ext,
5012
				  ATH12K_HTT_RX_PDEV_STATS_NUM_BW_EXT2_COUNTERS, "\n");
5013
	len += print_array_to_buf(buf, len, "rx_su_punctured_mode",
5014
				  htt_stats_buf->rx_su_punctured_mode,
5015
				  ATH12K_HTT_RX_PDEV_STATS_NUM_PUNCTURED_MODE_COUNTERS,
5016
				  "\n");
5017

5018
	len += print_array_to_buf(buf, len, "rx_mcs_ext",
5019
				  htt_stats_buf->rx_mcs_ext,
5020
				  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT,
5021
				  NULL);
5022
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_EXTRA2_MCS_COUNTERS; j++)
5023
		len += scnprintf(buf + len, buf_len - len, ", %u:%u",
5024
				 j + ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT,
5025
				 le32_to_cpu(htt_stats_buf->rx_mcs_ext_2[j]));
5026
	len += scnprintf(buf + len, buf_len - len, "\n");
5027

5028
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
5029
		len += scnprintf(buf + len, buf_len - len,
5030
				 "rx_gi_ext[%u] = ", j);
5031
		len += print_array_to_buf(buf, len, NULL,
5032
					  htt_stats_buf->rx_gi_ext[j],
5033
					  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT,
5034
					  "\n");
5035
	}
5036

5037
	for (j = 0; j < ATH12K_HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
5038
		len += scnprintf(buf + len, buf_len - len,
5039
				 "ul_ofdma_rx_gi_ext[%u] = ", j);
5040
		len += print_array_to_buf(buf, len, NULL,
5041
					  htt_stats_buf->ul_ofdma_rx_gi_ext[j],
5042
					  ATH12K_HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS_EXT,
5043
					  "\n");
5044
	}
5045

5046
	stats_req->buf_len = len;
5047
}
5048

5049
static void
5050
ath12k_htt_print_pdev_tdma_stats_tlv(const void *tag_buf, u16 tag_len,
5051
				     struct debug_htt_stats_req *stats_req)
5052
{
5053
	const struct ath12k_htt_pdev_tdma_stats_tlv *htt_stats_buf = tag_buf;
5054
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5055
	u32 len = stats_req->buf_len;
5056
	u8 *buf = stats_req->buf;
5057
	u32 mac_id_word;
5058

5059
	if (tag_len < sizeof(*htt_stats_buf))
5060
		return;
5061

5062
	mac_id_word = le32_to_cpu(htt_stats_buf->mac_id__word);
5063

5064
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_TDMA_STATS_TLV:\n");
5065
	len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n",
5066
			 u32_get_bits(mac_id_word, ATH12K_HTT_STATS_MAC_ID));
5067
	len += scnprintf(buf + len, buf_len - len, "num_tdma_active_schedules = %u\n",
5068
			 le32_to_cpu(htt_stats_buf->num_tdma_active_schedules));
5069
	len += scnprintf(buf + len, buf_len - len, "num_tdma_reserved_schedules = %u\n",
5070
			 le32_to_cpu(htt_stats_buf->num_tdma_reserved_schedules));
5071
	len += scnprintf(buf + len, buf_len - len,
5072
			 "num_tdma_restricted_schedules = %u\n",
5073
			 le32_to_cpu(htt_stats_buf->num_tdma_restricted_schedules));
5074
	len += scnprintf(buf + len, buf_len - len,
5075
			 "num_tdma_unconfigured_schedules = %u\n",
5076
			 le32_to_cpu(htt_stats_buf->num_tdma_unconfigured_schedules));
5077
	len += scnprintf(buf + len, buf_len - len, "num_tdma_slot_switches = %u\n",
5078
			 le32_to_cpu(htt_stats_buf->num_tdma_slot_switches));
5079
	len += scnprintf(buf + len, buf_len - len, "num_tdma_edca_switches = %u\n\n",
5080
			 le32_to_cpu(htt_stats_buf->num_tdma_edca_switches));
5081

5082
	stats_req->buf_len = len;
5083
}
5084

5085
static void
5086
ath12k_htt_print_mlo_sched_stats_tlv(const void *tag_buf, u16 tag_len,
5087
				     struct debug_htt_stats_req *stats_req)
5088
{
5089
	const struct ath12k_htt_mlo_sched_stats_tlv *stats_buf = tag_buf;
5090
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5091
	u32 len = stats_req->buf_len;
5092
	u8 *buf = stats_req->buf;
5093

5094
	if (tag_len < sizeof(*stats_buf))
5095
		return;
5096

5097
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_MLO_SCHED_STATS:\n");
5098
	len += scnprintf(buf + len, buf_len - len, "num_sec_link_sched = %u\n",
5099
			 le32_to_cpu(stats_buf->pref_link_num_sec_link_sched));
5100
	len += scnprintf(buf + len, buf_len - len, "num_pref_link_timeout = %u\n",
5101
			 le32_to_cpu(stats_buf->pref_link_num_pref_link_timeout));
5102
	len += scnprintf(buf + len, buf_len - len, "num_pref_link_sch_delay_ipc = %u\n",
5103
			 le32_to_cpu(stats_buf->pref_link_num_pref_link_sch_delay_ipc));
5104
	len += scnprintf(buf + len, buf_len - len, "num_pref_link_timeout_ipc = %u\n\n",
5105
			 le32_to_cpu(stats_buf->pref_link_num_pref_link_timeout_ipc));
5106

5107
	stats_req->buf_len = len;
5108
}
5109

5110
static void
5111
ath12k_htt_print_mlo_ipc_stats_tlv(const void *tag_buf, u16 tag_len,
5112
				   struct debug_htt_stats_req *stats_req)
5113
{
5114
	const struct ath12k_htt_pdev_mlo_ipc_stats_tlv *stats_buf = tag_buf;
5115
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5116
	u32 len = stats_req->buf_len;
5117
	u8 *buf = stats_req->buf;
5118
	u8 i, j;
5119

5120
	if (tag_len < sizeof(*stats_buf))
5121
		return;
5122

5123
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_MLO_IPC_STATS:\n");
5124
	for (i = 0; i < ATH12K_HTT_HWMLO_MAX_LINKS; i++) {
5125
		len += scnprintf(buf + len, buf_len - len, "src_link: %u\n", i);
5126
		for (j = 0; j < ATH12K_HTT_MLO_MAX_IPC_RINGS; j++)
5127
			len += scnprintf(buf + len, buf_len - len,
5128
					 "mlo_ipc_ring_full_cnt[%u]: %u\n", j,
5129
					 le32_to_cpu(stats_buf->mlo_ipc_ring_cnt[i][j]));
5130
		len += scnprintf(buf + len, buf_len - len, "\n");
5131
	}
5132

5133
	stats_req->buf_len = len;
5134
}
5135

5136
static void
5137
ath12k_htt_print_pdev_rtt_resp_stats_tlv(const void *tag_buf, u16 tag_len,
5138
					 struct debug_htt_stats_req *stats_req)
5139
{
5140
	const struct ath12k_htt_stats_pdev_rtt_resp_stats_tlv *sbuf = tag_buf;
5141
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5142
	u32 len = stats_req->buf_len;
5143
	u8 *buf = stats_req->buf;
5144

5145
	if (tag_len < sizeof(*sbuf))
5146
		return;
5147

5148
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_RTT_RESP_STATS_TLV:\n");
5149
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
5150
			 le32_to_cpu(sbuf->pdev_id));
5151
	len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftm_suc = %u\n",
5152
			 le32_to_cpu(sbuf->tx_11mc_ftm_suc));
5153
	len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftm_suc_retry = %u\n",
5154
			 le32_to_cpu(sbuf->tx_11mc_ftm_suc_retry));
5155
	len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftm_fail = %u\n",
5156
			 le32_to_cpu(sbuf->tx_11mc_ftm_fail));
5157
	len += scnprintf(buf + len, buf_len - len, "rx_11mc_ftmr_cnt = %u\n",
5158
			 le32_to_cpu(sbuf->rx_11mc_ftmr_cnt));
5159
	len += scnprintf(buf + len, buf_len - len, "rx_11mc_ftmr_dup_cnt = %u\n",
5160
			 le32_to_cpu(sbuf->rx_11mc_ftmr_dup_cnt));
5161
	len += scnprintf(buf + len, buf_len - len, "rx_11mc_iftmr_cnt = %u\n",
5162
			 le32_to_cpu(sbuf->rx_11mc_iftmr_cnt));
5163
	len += scnprintf(buf + len, buf_len - len, "rx_11mc_iftmr_dup_cnt = %u\n",
5164
			 le32_to_cpu(sbuf->rx_11mc_iftmr_dup_cnt));
5165
	len += scnprintf(buf + len, buf_len - len,
5166
			 "ftmr_drop_11mc_resp_role_not_enabled_cnt = %u\n",
5167
			 le32_to_cpu(sbuf->ftmr_drop_11mc_resp_role_not_enabled_cnt));
5168
	len += scnprintf(buf + len, buf_len - len, "tx_11az_ftm_successful = %u\n",
5169
			 le32_to_cpu(sbuf->tx_11az_ftm_successful));
5170
	len += scnprintf(buf + len, buf_len - len, "tx_11az_ftm_failed = %u\n",
5171
			 le32_to_cpu(sbuf->tx_11az_ftm_failed));
5172
	len += scnprintf(buf + len, buf_len - len, "rx_11az_ftmr_cnt = %u\n",
5173
			 le32_to_cpu(sbuf->rx_11az_ftmr_cnt));
5174
	len += scnprintf(buf + len, buf_len - len, "rx_11az_ftmr_dup_cnt = %u\n",
5175
			 le32_to_cpu(sbuf->rx_11az_ftmr_dup_cnt));
5176
	len += scnprintf(buf + len, buf_len - len, "rx_11az_iftmr_dup_cnt = %u\n",
5177
			 le32_to_cpu(sbuf->rx_11az_iftmr_dup_cnt));
5178
	len += scnprintf(buf + len, buf_len - len,
5179
			 "initiator_active_responder_rejected_cnt = %u\n",
5180
			 le32_to_cpu(sbuf->initiator_active_responder_rejected_cnt));
5181
	len += scnprintf(buf + len, buf_len - len, "malformed_ftmr = %u\n",
5182
			 le32_to_cpu(sbuf->malformed_ftmr));
5183
	len += scnprintf(buf + len, buf_len - len,
5184
			 "ftmr_drop_ntb_resp_role_not_enabled_cnt = %u\n",
5185
			 le32_to_cpu(sbuf->ftmr_drop_ntb_resp_role_not_enabled_cnt));
5186
	len += scnprintf(buf + len, buf_len - len,
5187
			 "ftmr_drop_tb_resp_role_not_enabled_cnt = %u\n",
5188
			 le32_to_cpu(sbuf->ftmr_drop_tb_resp_role_not_enabled_cnt));
5189
	len += scnprintf(buf + len, buf_len - len, "responder_alloc_cnt = %u\n",
5190
			 le32_to_cpu(sbuf->responder_alloc_cnt));
5191
	len += scnprintf(buf + len, buf_len - len, "responder_alloc_failure = %u\n",
5192
			 le32_to_cpu(sbuf->responder_alloc_failure));
5193
	len += scnprintf(buf + len, buf_len - len, "responder_terminate_cnt = %u\n",
5194
			 le32_to_cpu(sbuf->responder_terminate_cnt));
5195
	len += scnprintf(buf + len, buf_len - len, "active_rsta_open = %u\n",
5196
			 le32_to_cpu(sbuf->active_rsta_open));
5197
	len += scnprintf(buf + len, buf_len - len, "active_rsta_mac = %u\n",
5198
			 le32_to_cpu(sbuf->active_rsta_mac));
5199
	len += scnprintf(buf + len, buf_len - len, "active_rsta_mac_phy = %u\n",
5200
			 le32_to_cpu(sbuf->active_rsta_mac_phy));
5201
	len += scnprintf(buf + len, buf_len - len, "pn_check_failure_cnt = %u\n",
5202
			 le32_to_cpu(sbuf->pn_check_failure_cnt));
5203
	len += scnprintf(buf + len, buf_len - len, "num_assoc_ranging_peers = %u\n",
5204
			 le32_to_cpu(sbuf->num_assoc_ranging_peers));
5205
	len += scnprintf(buf + len, buf_len - len, "num_unassoc_ranging_peers = %u\n",
5206
			 le32_to_cpu(sbuf->num_unassoc_ranging_peers));
5207
	len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_recv_cnt = %u\n",
5208
			 le32_to_cpu(sbuf->pasn_m1_auth_recv_cnt));
5209
	len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_drop_cnt = %u\n",
5210
			 le32_to_cpu(sbuf->pasn_m1_auth_drop_cnt));
5211
	len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_recv_cnt = %u\n",
5212
			 le32_to_cpu(sbuf->pasn_m2_auth_recv_cnt));
5213
	len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_tx_fail_cnt = %u\n",
5214
			 le32_to_cpu(sbuf->pasn_m2_auth_tx_fail_cnt));
5215
	len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_recv_cnt = %u\n",
5216
			 le32_to_cpu(sbuf->pasn_m3_auth_recv_cnt));
5217
	len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_drop_cnt = %u\n",
5218
			 le32_to_cpu(sbuf->pasn_m3_auth_drop_cnt));
5219
	len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_request_cnt = %u\n",
5220
			 le32_to_cpu(sbuf->pasn_peer_create_request_cnt));
5221
	len += scnprintf(buf + len, buf_len - len, "pasn_peer_created_cnt = %u\n",
5222
			 le32_to_cpu(sbuf->pasn_peer_created_cnt));
5223
	len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_timeout_cnt = %u\n",
5224
			 le32_to_cpu(sbuf->pasn_peer_create_timeout_cnt));
5225
	len += scnprintf(buf + len, buf_len - len,
5226
			 "sec_ranging_not_supported_mfp_not_setup = %u\n",
5227
			 le32_to_cpu(sbuf->sec_ranging_not_supported_mfp_not_setup));
5228
	len += scnprintf(buf + len, buf_len - len,
5229
			 "non_sec_ranging_discarded_for_assoc_peer_with_mfpr_set = %u\n",
5230
			 le32_to_cpu(sbuf->non_sec_ranging_discarded_for_assoc_peer));
5231
	len += scnprintf(buf + len, buf_len - len,
5232
			 "open_ranging_discarded_with_URNM_MFPR_set_for_pasn_peer = %u\n",
5233
			 le32_to_cpu(sbuf->open_ranging_discarded_set_for_pasn_peer));
5234
	len += scnprintf(buf + len, buf_len - len,
5235
			 "unassoc_non_pasn_ranging_not_supported_with_URNM_MFPR = %u\n",
5236
			 le32_to_cpu(sbuf->unassoc_non_pasn_ranging_not_supported));
5237
	len += scnprintf(buf + len, buf_len - len, "invalid_ftm_request_params = %u\n",
5238
			 le32_to_cpu(sbuf->invalid_ftm_request_params));
5239
	len += scnprintf(buf + len, buf_len - len,
5240
			 "requested_bw_format_not_supported = %u\n",
5241
			 le32_to_cpu(sbuf->requested_bw_format_not_supported));
5242
	len += scnprintf(buf + len, buf_len - len,
5243
			 "ntb_unsec_unassoc_mode_ranging_peer_alloc_failed = %u\n",
5244
			 le32_to_cpu(sbuf->ntb_unsec_unassoc_ranging_peer_alloc_failed));
5245
	len += scnprintf(buf + len, buf_len - len,
5246
			 "tb_unassoc_unsec_mode_pasn_peer_creation_failed = %u\n",
5247
			 le32_to_cpu(sbuf->tb_unassoc_unsec_pasn_peer_creation_failed));
5248
	len += scnprintf(buf + len, buf_len - len,
5249
			 "num_ranging_sequences_processed = %u\n",
5250
			 le32_to_cpu(sbuf->num_ranging_sequences_processed));
5251
	len += scnprintf(buf + len, buf_len - len, "ndp_rx_cnt = %u\n",
5252
			 le32_to_cpu(sbuf->ndp_rx_cnt));
5253
	len += scnprintf(buf + len, buf_len - len, "num_req_bw_20_MHz = %u\n",
5254
			 le32_to_cpu(sbuf->num_req_bw_20_mhz));
5255
	len += scnprintf(buf + len, buf_len - len, "num_req_bw_40_MHz = %u\n",
5256
			 le32_to_cpu(sbuf->num_req_bw_40_mhz));
5257
	len += scnprintf(buf + len, buf_len - len, "num_req_bw_80_MHz = %u\n",
5258
			 le32_to_cpu(sbuf->num_req_bw_80_mhz));
5259
	len += scnprintf(buf + len, buf_len - len, "num_req_bw_160_MHz = %u\n",
5260
			 le32_to_cpu(sbuf->num_req_bw_160_mhz));
5261
	len += scnprintf(buf + len, buf_len - len, "ntb_tx_ndp = %u\n",
5262
			 le32_to_cpu(sbuf->ntb_tx_ndp));
5263
	len += scnprintf(buf + len, buf_len - len, "num_ntb_ranging_NDPAs_recv = %u\n",
5264
			 le32_to_cpu(sbuf->num_ntb_ranging_ndpas_recv));
5265
	len += scnprintf(buf + len, buf_len - len, "recv_lmr = %u\n",
5266
			 le32_to_cpu(sbuf->recv_lmr));
5267
	len += scnprintf(buf + len, buf_len - len, "invalid_ftmr_cnt = %u\n",
5268
			 le32_to_cpu(sbuf->invalid_ftmr_cnt));
5269
	len += scnprintf(buf + len, buf_len - len, "max_time_bw_meas_exp_cnt = %u\n\n",
5270
			 le32_to_cpu(sbuf->max_time_bw_meas_exp_cnt));
5271

5272
	stats_req->buf_len = len;
5273
}
5274

5275
static void
5276
ath12k_htt_print_pdev_rtt_init_stats_tlv(const void *tag_buf, u16 tag_len,
5277
					 struct debug_htt_stats_req *stats_req)
5278
{
5279
	const struct ath12k_htt_stats_pdev_rtt_init_stats_tlv *htt_stats_buf = tag_buf;
5280
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5281
	u32 len = stats_req->buf_len;
5282
	u8 *buf = stats_req->buf, i;
5283
	__le32 sch_fail;
5284

5285
	if (tag_len < sizeof(*htt_stats_buf))
5286
		return;
5287

5288
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_RTT_INIT_STATS_TLV:\n");
5289
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
5290
			 le32_to_cpu(htt_stats_buf->pdev_id));
5291
	len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftmr_cnt = %u\n",
5292
			 le32_to_cpu(htt_stats_buf->tx_11mc_ftmr_cnt));
5293
	len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftmr_fail = %u\n",
5294
			 le32_to_cpu(htt_stats_buf->tx_11mc_ftmr_fail));
5295
	len += scnprintf(buf + len, buf_len - len, "tx_11mc_ftmr_suc_retry = %u\n",
5296
			 le32_to_cpu(htt_stats_buf->tx_11mc_ftmr_suc_retry));
5297
	len += scnprintf(buf + len, buf_len - len, "rx_11mc_ftm_cnt = %u\n",
5298
			 le32_to_cpu(htt_stats_buf->rx_11mc_ftm_cnt));
5299
	len += scnprintf(buf + len, buf_len - len, "rx_11az_ftm_cnt = %u\n",
5300
			 le32_to_cpu(htt_stats_buf->rx_11az_ftm_cnt));
5301
	len += scnprintf(buf + len, buf_len - len, "initiator_terminate_cnt = %u\n",
5302
			 le32_to_cpu(htt_stats_buf->initiator_terminate_cnt));
5303
	len += scnprintf(buf + len, buf_len - len, "tx_meas_req_count = %u\n",
5304
			 le32_to_cpu(htt_stats_buf->tx_meas_req_count));
5305
	len += scnprintf(buf + len, buf_len - len, "tx_11az_ftmr_start = %u\n",
5306
			 le32_to_cpu(htt_stats_buf->tx_11az_ftmr_start));
5307
	len += scnprintf(buf + len, buf_len - len, "tx_11az_ftmr_stop = %u\n",
5308
			 le32_to_cpu(htt_stats_buf->tx_11az_ftmr_stop));
5309
	len += scnprintf(buf + len, buf_len - len, "tx_11az_ftmr_fail = %u\n",
5310
			 le32_to_cpu(htt_stats_buf->tx_11az_ftmr_fail));
5311
	len += scnprintf(buf + len, buf_len - len,
5312
			 "ftmr_tx_failed_null_11az_peer = %u\n",
5313
			 le32_to_cpu(htt_stats_buf->ftmr_tx_failed_null_11az_peer));
5314
	len += scnprintf(buf + len, buf_len - len, "ftmr_retry_timeout = %u\n",
5315
			 le32_to_cpu(htt_stats_buf->ftmr_retry_timeout));
5316
	len += scnprintf(buf + len, buf_len - len, "ftm_parse_failure = %u\n",
5317
			 le32_to_cpu(htt_stats_buf->ftm_parse_failure));
5318
	len += scnprintf(buf + len, buf_len - len, "incompatible_ftm_params = %u\n",
5319
			 le32_to_cpu(htt_stats_buf->incompatible_ftm_params));
5320
	len += scnprintf(buf + len, buf_len - len,
5321
			 "ranging_negotiation_successful_cnt = %u\n",
5322
			 le32_to_cpu(htt_stats_buf->ranging_negotiation_successful_cnt));
5323
	len += scnprintf(buf + len, buf_len - len, "active_ista = %u\n",
5324
			 le32_to_cpu(htt_stats_buf->active_ista));
5325
	len += scnprintf(buf + len, buf_len - len, "init_role_not_enabled = %u\n",
5326
			 le32_to_cpu(htt_stats_buf->init_role_not_enabled));
5327
	len += scnprintf(buf + len, buf_len - len, "invalid_preamble = %u\n",
5328
			 le32_to_cpu(htt_stats_buf->invalid_preamble));
5329
	len += scnprintf(buf + len, buf_len - len, "invalid_chan_bw_format = %u\n",
5330
			 le32_to_cpu(htt_stats_buf->invalid_chan_bw_format));
5331
	len += scnprintf(buf + len, buf_len - len, "mgmt_buff_alloc_fail_cnt = %u\n",
5332
			 le32_to_cpu(htt_stats_buf->mgmt_buff_alloc_fail_cnt));
5333
	len += scnprintf(buf + len, buf_len - len, "sec_ranging_req_in_open_mode = %u\n",
5334
			 le32_to_cpu(htt_stats_buf->sec_ranging_req_in_open_mode));
5335
	len += scnprintf(buf + len, buf_len - len, "max_time_bw_meas_exp_cnt = %u\n",
5336
			 le32_to_cpu(htt_stats_buf->max_time_bw_meas_exp_cnt));
5337
	len += scnprintf(buf + len, buf_len - len, "num_tb_ranging_requests = %u\n",
5338
			 le32_to_cpu(htt_stats_buf->num_tb_ranging_requests));
5339
	len += scnprintf(buf + len, buf_len - len, "tb_meas_duration_expiry_cnt = %u\n",
5340
			 le32_to_cpu(htt_stats_buf->tb_meas_duration_expiry_cnt));
5341
	len += scnprintf(buf + len, buf_len - len, "ntbr_triggered_successfully = %u\n",
5342
			 le32_to_cpu(htt_stats_buf->ntbr_triggered_successfully));
5343
	len += scnprintf(buf + len, buf_len - len, "ntbr_trigger_failed = %u\n",
5344
			 le32_to_cpu(htt_stats_buf->ntbr_trigger_failed));
5345
	len += scnprintf(buf + len, buf_len - len, "invalid_or_no_vreg_idx = %u\n",
5346
			 le32_to_cpu(htt_stats_buf->invalid_or_no_vreg_idx));
5347
	len += scnprintf(buf + len, buf_len - len, "set_vreg_params_failed = %u\n",
5348
			 le32_to_cpu(htt_stats_buf->set_vreg_params_failed));
5349
	len += scnprintf(buf + len, buf_len - len, "sac_mismatch = %u\n",
5350
			 le32_to_cpu(htt_stats_buf->sac_mismatch));
5351
	len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_recv_cnt = %u\n",
5352
			 le32_to_cpu(htt_stats_buf->pasn_m1_auth_recv_cnt));
5353
	len += scnprintf(buf + len, buf_len - len, "pasn_m1_auth_tx_fail_cnt = %u\n",
5354
			 le32_to_cpu(htt_stats_buf->pasn_m1_auth_tx_fail_cnt));
5355
	len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_recv_cnt = %u\n",
5356
			 le32_to_cpu(htt_stats_buf->pasn_m2_auth_recv_cnt));
5357
	len += scnprintf(buf + len, buf_len - len, "pasn_m2_auth_drop_cnt = %u\n",
5358
			 le32_to_cpu(htt_stats_buf->pasn_m2_auth_drop_cnt));
5359
	len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_recv_cnt = %u\n",
5360
			 le32_to_cpu(htt_stats_buf->pasn_m3_auth_recv_cnt));
5361
	len += scnprintf(buf + len, buf_len - len, "pasn_m3_auth_tx_fail_cnt = %u\n",
5362
			 le32_to_cpu(htt_stats_buf->pasn_m3_auth_tx_fail_cnt));
5363
	len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_request_cnt = %u\n",
5364
			 le32_to_cpu(htt_stats_buf->pasn_peer_create_request_cnt));
5365
	len += scnprintf(buf + len, buf_len - len, "pasn_peer_created_cnt = %u\n",
5366
			 le32_to_cpu(htt_stats_buf->pasn_peer_created_cnt));
5367
	len += scnprintf(buf + len, buf_len - len, "pasn_peer_create_timeout_cnt = %u\n",
5368
			 le32_to_cpu(htt_stats_buf->pasn_peer_create_timeout_cnt));
5369
	len += scnprintf(buf + len, buf_len - len, "ntbr_ndpa_failed = %u\n",
5370
			 le32_to_cpu(htt_stats_buf->ntbr_ndpa_failed));
5371
	len += scnprintf(buf + len, buf_len - len, "ntbr_sequence_successful = %u\n",
5372
			 le32_to_cpu(htt_stats_buf->ntbr_sequence_successful));
5373
	len += scnprintf(buf + len, buf_len - len, "ntbr_ndp_failed = %u\n",
5374
			 le32_to_cpu(htt_stats_buf->ntbr_ndp_failed));
5375
	len += scnprintf(buf + len, buf_len - len, "num_tb_ranging_NDPAs_recv = %u\n",
5376
			 le32_to_cpu(htt_stats_buf->num_tb_ranging_ndpas_recv));
5377
	len += scnprintf(buf + len, buf_len - len, "ndp_rx_cnt = %u\n",
5378
			 le32_to_cpu(htt_stats_buf->ndp_rx_cnt));
5379
	len += scnprintf(buf + len, buf_len - len, "num_trigger_frames_received = %u\n",
5380
			 le32_to_cpu(htt_stats_buf->num_trigger_frames_received));
5381
	for (i = 0; i < (ATH12K_HTT_SCH_CMD_STATUS_CNT - 1); i++)
5382
		len += scnprintf(buf + len, buf_len - len,
5383
				 "num_sch_cmd_status_%d = %u\n", i,
5384
				 le32_to_cpu(htt_stats_buf->sch_cmd_status_cnts[i]));
5385
	sch_fail = htt_stats_buf->sch_cmd_status_cnts[ATH12K_HTT_SCH_CMD_STATUS_CNT - 1];
5386
	len += scnprintf(buf + len, buf_len - len,
5387
			 "num_sch_cmd_status_other_failure = %u\n",
5388
			 le32_to_cpu(sch_fail));
5389
	len += scnprintf(buf + len, buf_len - len, "lmr_timeout = %u\n",
5390
			 le32_to_cpu(htt_stats_buf->lmr_timeout));
5391
	len += scnprintf(buf + len, buf_len - len, "lmr_recv = %u\n\n",
5392
			 le32_to_cpu(htt_stats_buf->lmr_recv));
5393

5394
	stats_req->buf_len = len;
5395
}
5396

5397
static void
5398
ath12k_htt_print_pdev_rtt_hw_stats_tlv(const void *tag_buf, u16 tag_len,
5399
				       struct debug_htt_stats_req *stats_req)
5400
{
5401
	const struct ath12k_htt_stats_pdev_rtt_hw_stats_tlv *htt_stats_buf = tag_buf;
5402
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5403
	u32 len = stats_req->buf_len;
5404
	u8 *buf = stats_req->buf;
5405

5406
	if (tag_len < sizeof(*htt_stats_buf))
5407
		return;
5408

5409
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_PDEV_RTT_HW_STATS_TAG:\n");
5410
	len += scnprintf(buf + len, buf_len - len, "ista_ranging_ndpa_cnt = %u\n",
5411
			 le32_to_cpu(htt_stats_buf->ista_ranging_ndpa_cnt));
5412
	len += scnprintf(buf + len, buf_len - len, "ista_ranging_ndp_cnt = %u\n",
5413
			 le32_to_cpu(htt_stats_buf->ista_ranging_ndp_cnt));
5414
	len += scnprintf(buf + len, buf_len - len, "ista_ranging_i2r_lmr_cnt = %u\n",
5415
			 le32_to_cpu(htt_stats_buf->ista_ranging_i2r_lmr_cnt));
5416
	len += scnprintf(buf + len, buf_len - len, "rtsa_ranging_resp_cnt = %u\n",
5417
			 le32_to_cpu(htt_stats_buf->rtsa_ranging_resp_cnt));
5418
	len += scnprintf(buf + len, buf_len - len, "rtsa_ranging_ndp_cnt = %u\n",
5419
			 le32_to_cpu(htt_stats_buf->rtsa_ranging_ndp_cnt));
5420
	len += scnprintf(buf + len, buf_len - len, "rsta_ranging_lmr_cnt = %u\n",
5421
			 le32_to_cpu(htt_stats_buf->rsta_ranging_lmr_cnt));
5422
	len += scnprintf(buf + len, buf_len - len, "tb_ranging_cts2s_rcvd_cnt = %u\n",
5423
			 le32_to_cpu(htt_stats_buf->tb_ranging_cts2s_rcvd_cnt));
5424
	len += scnprintf(buf + len, buf_len - len, "tb_ranging_ndp_rcvd_cnt = %u\n",
5425
			 le32_to_cpu(htt_stats_buf->tb_ranging_ndp_rcvd_cnt));
5426
	len += scnprintf(buf + len, buf_len - len, "tb_ranging_lmr_rcvd_cnt = %u\n",
5427
			 le32_to_cpu(htt_stats_buf->tb_ranging_lmr_rcvd_cnt));
5428
	len += scnprintf(buf + len, buf_len - len,
5429
			 "tb_ranging_tf_poll_resp_sent_cnt = %u\n",
5430
			 le32_to_cpu(htt_stats_buf->tb_ranging_tf_poll_resp_sent_cnt));
5431
	len += scnprintf(buf + len, buf_len - len,
5432
			 "tb_ranging_tf_sound_resp_sent_cnt = %u\n",
5433
			 le32_to_cpu(htt_stats_buf->tb_ranging_tf_sound_resp_sent_cnt));
5434
	len += scnprintf(buf + len, buf_len - len,
5435
			 "tb_ranging_tf_report_resp_sent_cnt = %u\n\n",
5436
			 le32_to_cpu(htt_stats_buf->tb_ranging_tf_report_resp_sent_cnt));
5437

5438
	stats_req->buf_len = len;
5439
}
5440

5441
static void
5442
ath12k_htt_print_pdev_rtt_tbr_selfgen_queued_stats_tlv(const void *tag_buf, u16 tag_len,
5443
						       struct debug_htt_stats_req *req)
5444
{
5445
	const struct ath12k_htt_stats_pdev_rtt_tbr_tlv *sbuf = tag_buf;
5446
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5447
	u32 len = req->buf_len;
5448
	u8 *buf = req->buf;
5449

5450
	if (tag_len < sizeof(*sbuf))
5451
		return;
5452

5453
	len += scnprintf(buf + len, buf_len - len,
5454
			 "HTT_STATS_PDEV_RTT_TBR_SELFGEN_QUEUED_STATS_TAG:\n");
5455
	len += scnprintf(buf + len, buf_len - len, "SU poll = %u\n",
5456
			 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TF_POLL]));
5457
	len += scnprintf(buf + len, buf_len - len, "SU sound = %u\n",
5458
			 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TF_SOUND]));
5459
	len += scnprintf(buf + len, buf_len - len, "SU NDPA = %u\n",
5460
			 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TBR_NDPA]));
5461
	len += scnprintf(buf + len, buf_len - len, "SU NDP = %u\n",
5462
			 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TBR_NDP]));
5463
	len += scnprintf(buf + len, buf_len - len, "SU LMR = %u\n",
5464
			 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TBR_LMR]));
5465
	len += scnprintf(buf + len, buf_len - len, "SU TF_REPORT = %u\n",
5466
			 le32_to_cpu(sbuf->su_ftype[ATH12K_HTT_FTYPE_TF_RPRT]));
5467
	len += scnprintf(buf + len, buf_len - len, "MU poll = %u\n",
5468
			 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TF_POLL]));
5469
	len += scnprintf(buf + len, buf_len - len, "MU sound = %u\n",
5470
			 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TF_SOUND]));
5471
	len += scnprintf(buf + len, buf_len - len, "MU NDPA = %u\n",
5472
			 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TBR_NDPA]));
5473
	len += scnprintf(buf + len, buf_len - len, "MU NDP = %u\n",
5474
			 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TBR_NDP]));
5475
	len += scnprintf(buf + len, buf_len - len, "MU LMR = %u\n",
5476
			 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TBR_LMR]));
5477
	len += scnprintf(buf + len, buf_len - len, "MU TF_REPORT = %u\n\n",
5478
			 le32_to_cpu(sbuf->mu_ftype[ATH12K_HTT_FTYPE_TF_RPRT]));
5479

5480
	req->buf_len = len;
5481
}
5482

5483
static void
5484
ath12k_htt_print_pdev_rtt_tbr_cmd_res_stats_tlv(const void *tag_buf, u16 tag_len,
5485
						struct debug_htt_stats_req *stats_req)
5486
{
5487
	const struct ath12k_htt_stats_pdev_rtt_tbr_cmd_result_stats_tlv *sbuf = tag_buf;
5488
	u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE;
5489
	u32 len = stats_req->buf_len;
5490
	u8 *buf = stats_req->buf, i;
5491

5492
	if (tag_len < sizeof(*sbuf))
5493
		return;
5494

5495
	len += scnprintf(buf + len, buf_len - len,
5496
			 "HTT_STATS_PDEV_RTT_TBR_CMD_RESULT_STATS_TAG:\n");
5497
	for (i = 0; i < le32_to_cpu(sbuf->tbr_num_sch_cmd_result_buckets); i++) {
5498
		len += scnprintf(buf + len, buf_len - len, "num_sch_cmd_status_%u:\n", i);
5499
		len += scnprintf(buf + len, buf_len - len,
5500
				 "SU frame_SGEN_TF_POLL = %u\n",
5501
				 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TF_POLL][i]));
5502
		len += scnprintf(buf + len, buf_len - len,
5503
				 "SU frame_SGEN_TF_SOUND = %u\n",
5504
				 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TF_SOUND][i]));
5505
		len += scnprintf(buf + len, buf_len - len,
5506
				 "SU frame_SGEN_TBR_NDPA = %u\n",
5507
				 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TBR_NDPA][i]));
5508
		len += scnprintf(buf + len, buf_len - len,
5509
				 "SU frame_SGEN_TBR_NDP = %u\n",
5510
				 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TBR_NDP][i]));
5511
		len += scnprintf(buf + len, buf_len - len,
5512
				 "SU frame_SGEN_TBR_LMR = %u\n",
5513
				 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TBR_LMR][i]));
5514
		len += scnprintf(buf + len, buf_len - len,
5515
				 "SU frame_SGEN_TF_REPORT = %u\n",
5516
				 le32_to_cpu(sbuf->su_res[ATH12K_HTT_FTYPE_TF_RPRT][i]));
5517
		len += scnprintf(buf + len, buf_len - len,
5518
				 "MU frame_SGEN_TF_POLL = %u\n",
5519
				 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TF_POLL][i]));
5520
		len += scnprintf(buf + len, buf_len - len,
5521
				 "MU frame_SGEN_TF_SOUND = %u\n",
5522
				 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TF_SOUND][i]));
5523
		len += scnprintf(buf + len, buf_len - len,
5524
				 "MU frame_SGEN_TBR_NDPA = %u\n",
5525
				 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TBR_NDPA][i]));
5526
		len += scnprintf(buf + len, buf_len - len,
5527
				 "MU frame_SGEN_TBR_NDP = %u\n",
5528
				 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TBR_NDP][i]));
5529
		len += scnprintf(buf + len, buf_len - len,
5530
				 "MU frame_SGEN_TBR_LMR = %u\n",
5531
				 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TBR_LMR][i]));
5532
		len += scnprintf(buf + len, buf_len - len,
5533
				 "MU frame_SGEN_TF_REPORT = %u\n\n",
5534
				 le32_to_cpu(sbuf->mu_res[ATH12K_HTT_FTYPE_TF_RPRT][i]));
5535
	}
5536

5537
	stats_req->buf_len = len;
5538
}
5539

5540
static int ath12k_dbg_htt_ext_stats_parse(struct ath12k_base *ab,
5541
					  u16 tag, u16 len, const void *tag_buf,
5542
					  void *user_data)
5543
{
5544
	struct debug_htt_stats_req *stats_req = user_data;
5545

5546
	switch (tag) {
5547
	case HTT_STATS_TX_PDEV_CMN_TAG:
5548
		htt_print_tx_pdev_stats_cmn_tlv(tag_buf, len, stats_req);
5549
		break;
5550
	case HTT_STATS_TX_PDEV_UNDERRUN_TAG:
5551
		htt_print_tx_pdev_stats_urrn_tlv(tag_buf, len, stats_req);
5552
		break;
5553
	case HTT_STATS_TX_PDEV_SIFS_TAG:
5554
		htt_print_tx_pdev_stats_sifs_tlv(tag_buf, len, stats_req);
5555
		break;
5556
	case HTT_STATS_TX_PDEV_FLUSH_TAG:
5557
		htt_print_tx_pdev_stats_flush_tlv(tag_buf, len, stats_req);
5558
		break;
5559
	case HTT_STATS_TX_PDEV_SIFS_HIST_TAG:
5560
		htt_print_tx_pdev_stats_sifs_hist_tlv(tag_buf, len, stats_req);
5561
		break;
5562
	case HTT_STATS_PDEV_CTRL_PATH_TX_STATS_TAG:
5563
		htt_print_pdev_ctrl_path_tx_stats_tlv(tag_buf, len, stats_req);
5564
		break;
5565
	case HTT_STATS_MU_PPDU_DIST_TAG:
5566
		htt_print_tx_pdev_mu_ppdu_dist_stats_tlv(tag_buf, len, stats_req);
5567
		break;
5568
	case HTT_STATS_TX_SCHED_CMN_TAG:
5569
		ath12k_htt_print_stats_tx_sched_cmn_tlv(tag_buf, len, stats_req);
5570
		break;
5571
	case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG:
5572
		ath12k_htt_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf, len, stats_req);
5573
		break;
5574
	case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG:
5575
		ath12k_htt_print_sched_txq_cmd_posted_tlv(tag_buf, len, stats_req);
5576
		break;
5577
	case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG:
5578
		ath12k_htt_print_sched_txq_cmd_reaped_tlv(tag_buf, len, stats_req);
5579
		break;
5580
	case HTT_STATS_SCHED_TXQ_SCHED_ORDER_SU_TAG:
5581
		ath12k_htt_print_sched_txq_sched_order_su_tlv(tag_buf, len, stats_req);
5582
		break;
5583
	case HTT_STATS_SCHED_TXQ_SCHED_INELIGIBILITY_TAG:
5584
		ath12k_htt_print_sched_txq_sched_ineligibility_tlv(tag_buf, len,
5585
								   stats_req);
5586
		break;
5587
	case HTT_STATS_SCHED_TXQ_SUPERCYCLE_TRIGGER_TAG:
5588
		ath12k_htt_print_sched_txq_supercycle_trigger_tlv(tag_buf, len,
5589
								  stats_req);
5590
		break;
5591
	case HTT_STATS_HW_PDEV_ERRS_TAG:
5592
		ath12k_htt_print_hw_stats_pdev_errs_tlv(tag_buf, len, stats_req);
5593
		break;
5594
	case HTT_STATS_HW_INTR_MISC_TAG:
5595
		ath12k_htt_print_hw_stats_intr_misc_tlv(tag_buf, len, stats_req);
5596
		break;
5597
	case HTT_STATS_WHAL_TX_TAG:
5598
		ath12k_htt_print_hw_stats_whal_tx_tlv(tag_buf, len, stats_req);
5599
		break;
5600
	case HTT_STATS_HW_WAR_TAG:
5601
		ath12k_htt_print_hw_war_tlv(tag_buf, len, stats_req);
5602
		break;
5603
	case HTT_STATS_TX_TQM_CMN_TAG:
5604
		ath12k_htt_print_tx_tqm_cmn_stats_tlv(tag_buf, len, stats_req);
5605
		break;
5606
	case HTT_STATS_TX_TQM_ERROR_STATS_TAG:
5607
		ath12k_htt_print_tx_tqm_error_stats_tlv(tag_buf, len, stats_req);
5608
		break;
5609
	case HTT_STATS_TX_TQM_GEN_MPDU_TAG:
5610
		ath12k_htt_print_tx_tqm_gen_mpdu_stats_tlv(tag_buf, len, stats_req);
5611
		break;
5612
	case HTT_STATS_TX_TQM_LIST_MPDU_TAG:
5613
		ath12k_htt_print_tx_tqm_list_mpdu_stats_tlv(tag_buf, len, stats_req);
5614
		break;
5615
	case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG:
5616
		ath12k_htt_print_tx_tqm_list_mpdu_cnt_tlv(tag_buf, len, stats_req);
5617
		break;
5618
	case HTT_STATS_TX_TQM_PDEV_TAG:
5619
		ath12k_htt_print_tx_tqm_pdev_stats_tlv(tag_buf, len, stats_req);
5620
		break;
5621
	case HTT_STATS_TX_DE_CMN_TAG:
5622
		ath12k_htt_print_tx_de_cmn_stats_tlv(tag_buf, len, stats_req);
5623
		break;
5624
	case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG:
5625
		ath12k_htt_print_tx_de_eapol_packets_stats_tlv(tag_buf, len, stats_req);
5626
		break;
5627
	case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG:
5628
		ath12k_htt_print_tx_de_classify_stats_tlv(tag_buf, len, stats_req);
5629
		break;
5630
	case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG:
5631
		ath12k_htt_print_tx_de_classify_failed_stats_tlv(tag_buf, len, stats_req);
5632
		break;
5633
	case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG:
5634
		ath12k_htt_print_tx_de_classify_status_stats_tlv(tag_buf, len, stats_req);
5635
		break;
5636
	case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG:
5637
		ath12k_htt_print_tx_de_enqueue_packets_stats_tlv(tag_buf, len, stats_req);
5638
		break;
5639
	case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG:
5640
		ath12k_htt_print_tx_de_enqueue_discard_stats_tlv(tag_buf, len, stats_req);
5641
		break;
5642
	case HTT_STATS_TX_DE_COMPL_STATS_TAG:
5643
		ath12k_htt_print_tx_de_compl_stats_tlv(tag_buf, len, stats_req);
5644
		break;
5645
	case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG:
5646
		ath12k_htt_print_tx_selfgen_cmn_stats_tlv(tag_buf, len, stats_req);
5647
		break;
5648
	case HTT_STATS_TX_SELFGEN_AC_STATS_TAG:
5649
		ath12k_htt_print_tx_selfgen_ac_stats_tlv(tag_buf, len, stats_req);
5650
		break;
5651
	case HTT_STATS_TX_SELFGEN_AX_STATS_TAG:
5652
		ath12k_htt_print_tx_selfgen_ax_stats_tlv(tag_buf, len, stats_req);
5653
		break;
5654
	case HTT_STATS_TX_SELFGEN_BE_STATS_TAG:
5655
		ath12k_htt_print_tx_selfgen_be_stats_tlv(tag_buf, len, stats_req);
5656
		break;
5657
	case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG:
5658
		ath12k_htt_print_tx_selfgen_ac_err_stats_tlv(tag_buf, len, stats_req);
5659
		break;
5660
	case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG:
5661
		ath12k_htt_print_tx_selfgen_ax_err_stats_tlv(tag_buf, len, stats_req);
5662
		break;
5663
	case HTT_STATS_TX_SELFGEN_BE_ERR_STATS_TAG:
5664
		ath12k_htt_print_tx_selfgen_be_err_stats_tlv(tag_buf, len, stats_req);
5665
		break;
5666
	case HTT_STATS_TX_SELFGEN_AC_SCHED_STATUS_STATS_TAG:
5667
		ath12k_htt_print_tx_selfgen_ac_sched_status_stats_tlv(tag_buf, len,
5668
								      stats_req);
5669
		break;
5670
	case HTT_STATS_TX_SELFGEN_AX_SCHED_STATUS_STATS_TAG:
5671
		ath12k_htt_print_tx_selfgen_ax_sched_status_stats_tlv(tag_buf, len,
5672
								      stats_req);
5673
		break;
5674
	case HTT_STATS_TX_SELFGEN_BE_SCHED_STATUS_STATS_TAG:
5675
		ath12k_htt_print_tx_selfgen_be_sched_status_stats_tlv(tag_buf, len,
5676
								      stats_req);
5677
		break;
5678
	case HTT_STATS_STRING_TAG:
5679
		ath12k_htt_print_stats_string_tlv(tag_buf, len, stats_req);
5680
		break;
5681
	case HTT_STATS_SRING_STATS_TAG:
5682
		ath12k_htt_print_sring_stats_tlv(tag_buf, len, stats_req);
5683
		break;
5684
	case HTT_STATS_SFM_CMN_TAG:
5685
		ath12k_htt_print_sfm_cmn_tlv(tag_buf, len, stats_req);
5686
		break;
5687
	case HTT_STATS_SFM_CLIENT_TAG:
5688
		ath12k_htt_print_sfm_client_tlv(tag_buf, len, stats_req);
5689
		break;
5690
	case HTT_STATS_SFM_CLIENT_USER_TAG:
5691
		ath12k_htt_print_sfm_client_user_tlv(tag_buf, len, stats_req);
5692
		break;
5693
	case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG:
5694
		ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, len, stats_req);
5695
		break;
5696
	case HTT_STATS_TX_PDEV_MUMIMO_GRP_STATS_TAG:
5697
		ath12k_htt_print_tx_pdev_mumimo_grp_stats_tlv(tag_buf, len, stats_req);
5698
		break;
5699
	case HTT_STATS_TX_PDEV_MPDU_STATS_TAG:
5700
		ath12k_htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf, len, stats_req);
5701
		break;
5702
	case HTT_STATS_PDEV_CCA_1SEC_HIST_TAG:
5703
	case HTT_STATS_PDEV_CCA_100MSEC_HIST_TAG:
5704
	case HTT_STATS_PDEV_CCA_STAT_CUMULATIVE_TAG:
5705
		ath12k_htt_print_pdev_cca_stats_hist_tlv(tag_buf, len, stats_req);
5706
		break;
5707
	case HTT_STATS_PDEV_CCA_COUNTERS_TAG:
5708
		ath12k_htt_print_pdev_stats_cca_counters_tlv(tag_buf, len, stats_req);
5709
		break;
5710
	case HTT_STATS_TX_SOUNDING_STATS_TAG:
5711
		ath12k_htt_print_tx_sounding_stats_tlv(tag_buf, len, stats_req);
5712
		break;
5713
	case HTT_STATS_PDEV_OBSS_PD_TAG:
5714
		ath12k_htt_print_pdev_obss_pd_stats_tlv(tag_buf, len, stats_req);
5715
		break;
5716
	case HTT_STATS_LATENCY_CTX_TAG:
5717
		ath12k_htt_print_latency_prof_ctx_tlv(tag_buf, len, stats_req);
5718
		break;
5719
	case HTT_STATS_LATENCY_CNT_TAG:
5720
		ath12k_htt_print_latency_prof_cnt(tag_buf, len, stats_req);
5721
		break;
5722
	case HTT_STATS_LATENCY_PROF_STATS_TAG:
5723
		ath12k_htt_print_latency_prof_stats_tlv(tag_buf, len, stats_req);
5724
		break;
5725
	case HTT_STATS_RX_PDEV_UL_TRIG_STATS_TAG:
5726
		ath12k_htt_print_ul_ofdma_trigger_stats(tag_buf, len, stats_req);
5727
		break;
5728
	case HTT_STATS_RX_PDEV_UL_OFDMA_USER_STATS_TAG:
5729
		ath12k_htt_print_ul_ofdma_user_stats(tag_buf, len, stats_req);
5730
		break;
5731
	case HTT_STATS_RX_PDEV_UL_MUMIMO_TRIG_STATS_TAG:
5732
		ath12k_htt_print_ul_mumimo_trig_stats(tag_buf, len, stats_req);
5733
		break;
5734
	case HTT_STATS_RX_FSE_STATS_TAG:
5735
		ath12k_htt_print_rx_fse_stats_tlv(tag_buf, len, stats_req);
5736
		break;
5737
	case HTT_STATS_PDEV_TX_RATE_TXBF_STATS_TAG:
5738
		ath12k_htt_print_pdev_tx_rate_txbf_stats_tlv(tag_buf, len, stats_req);
5739
		break;
5740
	case HTT_STATS_TXBF_OFDMA_AX_NDPA_STATS_TAG:
5741
		ath12k_htt_print_txbf_ofdma_ax_ndpa_stats_tlv(tag_buf, len, stats_req);
5742
		break;
5743
	case HTT_STATS_TXBF_OFDMA_AX_NDP_STATS_TAG:
5744
		ath12k_htt_print_txbf_ofdma_ax_ndp_stats_tlv(tag_buf, len, stats_req);
5745
		break;
5746
	case HTT_STATS_TXBF_OFDMA_AX_BRP_STATS_TAG:
5747
		ath12k_htt_print_txbf_ofdma_ax_brp_stats_tlv(tag_buf, len, stats_req);
5748
		break;
5749
	case HTT_STATS_TXBF_OFDMA_AX_STEER_STATS_TAG:
5750
		ath12k_htt_print_txbf_ofdma_ax_steer_stats_tlv(tag_buf, len, stats_req);
5751
		break;
5752
	case HTT_STATS_TXBF_OFDMA_AX_STEER_MPDU_STATS_TAG:
5753
		ath12k_htt_print_txbf_ofdma_ax_steer_mpdu_stats_tlv(tag_buf, len,
5754
								    stats_req);
5755
		break;
5756
	case HTT_STATS_DLPAGER_STATS_TAG:
5757
		ath12k_htt_print_dlpager_stats_tlv(tag_buf, len, stats_req);
5758
		break;
5759
	case HTT_STATS_PHY_STATS_TAG:
5760
		ath12k_htt_print_phy_stats_tlv(tag_buf, len, stats_req);
5761
		break;
5762
	case HTT_STATS_PHY_COUNTERS_TAG:
5763
		ath12k_htt_print_phy_counters_tlv(tag_buf, len, stats_req);
5764
		break;
5765
	case HTT_STATS_PHY_RESET_STATS_TAG:
5766
		ath12k_htt_print_phy_reset_stats_tlv(tag_buf, len, stats_req);
5767
		break;
5768
	case HTT_STATS_PHY_RESET_COUNTERS_TAG:
5769
		ath12k_htt_print_phy_reset_counters_tlv(tag_buf, len, stats_req);
5770
		break;
5771
	case HTT_STATS_PHY_TPC_STATS_TAG:
5772
		ath12k_htt_print_phy_tpc_stats_tlv(tag_buf, len, stats_req);
5773
		break;
5774
	case HTT_STATS_SOC_TXRX_STATS_COMMON_TAG:
5775
		ath12k_htt_print_soc_txrx_stats_common_tlv(tag_buf, len, stats_req);
5776
		break;
5777
	case HTT_STATS_PER_RATE_STATS_TAG:
5778
		ath12k_htt_print_tx_per_rate_stats_tlv(tag_buf, len, stats_req);
5779
		break;
5780
	case HTT_STATS_AST_ENTRY_TAG:
5781
		ath12k_htt_print_ast_entry_tlv(tag_buf, len, stats_req);
5782
		break;
5783
	case HTT_STATS_PDEV_PUNCTURE_STATS_TAG:
5784
		ath12k_htt_print_puncture_stats_tlv(tag_buf, len, stats_req);
5785
		break;
5786
	case HTT_STATS_DMAC_RESET_STATS_TAG:
5787
		ath12k_htt_print_dmac_reset_stats_tlv(tag_buf, len, stats_req);
5788
		break;
5789
	case HTT_STATS_PDEV_SCHED_ALGO_OFDMA_STATS_TAG:
5790
		ath12k_htt_print_pdev_sched_algo_ofdma_stats_tlv(tag_buf, len, stats_req);
5791
		break;
5792
	case HTT_STATS_TX_PDEV_RATE_STATS_BE_OFDMA_TAG:
5793
		ath12k_htt_print_tx_pdev_rate_stats_be_ofdma_tlv(tag_buf, len, stats_req);
5794
		break;
5795
	case HTT_STATS_PDEV_MBSSID_CTRL_FRAME_STATS_TAG:
5796
		ath12k_htt_print_pdev_mbssid_ctrl_frame_stats_tlv(tag_buf, len,
5797
								  stats_req);
5798
		break;
5799
	case HTT_STATS_TX_PDEV_RATE_STATS_TAG:
5800
		ath12k_htt_print_tx_pdev_rate_stats_tlv(tag_buf, len, stats_req);
5801
		break;
5802
	case HTT_STATS_TX_PDEV_HISTOGRAM_STATS_TAG:
5803
		ath12k_htt_print_histogram_stats_tlv(tag_buf, len, stats_req);
5804
		break;
5805
	case HTT_STATS_RX_PDEV_RATE_STATS_TAG:
5806
		ath12k_htt_print_rx_pdev_rate_stats_tlv(tag_buf, len, stats_req);
5807
		break;
5808
	case HTT_STATS_RX_PDEV_RATE_EXT_STATS_TAG:
5809
		ath12k_htt_print_rx_pdev_rate_ext_stats_tlv(tag_buf, len, stats_req);
5810
		break;
5811
	case HTT_STATS_PDEV_TDMA_TAG:
5812
		ath12k_htt_print_pdev_tdma_stats_tlv(tag_buf, len, stats_req);
5813
		break;
5814
	case HTT_STATS_MLO_SCHED_STATS_TAG:
5815
		ath12k_htt_print_mlo_sched_stats_tlv(tag_buf, len, stats_req);
5816
		break;
5817
	case HTT_STATS_PDEV_MLO_IPC_STATS_TAG:
5818
		ath12k_htt_print_mlo_ipc_stats_tlv(tag_buf, len, stats_req);
5819
		break;
5820
	case HTT_STATS_PDEV_RTT_RESP_STATS_TAG:
5821
		ath12k_htt_print_pdev_rtt_resp_stats_tlv(tag_buf, len, stats_req);
5822
		break;
5823
	case HTT_STATS_PDEV_RTT_INIT_STATS_TAG:
5824
		ath12k_htt_print_pdev_rtt_init_stats_tlv(tag_buf, len, stats_req);
5825
		break;
5826
	case HTT_STATS_PDEV_RTT_HW_STATS_TAG:
5827
		ath12k_htt_print_pdev_rtt_hw_stats_tlv(tag_buf, len, stats_req);
5828
		break;
5829
	case HTT_STATS_PDEV_RTT_TBR_SELFGEN_QUEUED_STATS_TAG:
5830
		ath12k_htt_print_pdev_rtt_tbr_selfgen_queued_stats_tlv(tag_buf, len,
5831
								       stats_req);
5832
		break;
5833
	case HTT_STATS_PDEV_RTT_TBR_CMD_RESULT_STATS_TAG:
5834
		ath12k_htt_print_pdev_rtt_tbr_cmd_res_stats_tlv(tag_buf, len, stats_req);
5835
		break;
5836
	default:
5837
		break;
5838
	}
5839

5840
	return 0;
5841
}
5842

5843
void ath12k_debugfs_htt_ext_stats_handler(struct ath12k_base *ab,
5844
					  struct sk_buff *skb)
5845
{
5846
	struct ath12k_htt_extd_stats_msg *msg;
5847
	struct debug_htt_stats_req *stats_req;
5848
	struct ath12k *ar;
5849
	u32 len, pdev_id, stats_info;
5850
	u64 cookie;
5851
	int ret;
5852
	bool send_completion = false;
5853

5854
	msg = (struct ath12k_htt_extd_stats_msg *)skb->data;
5855
	cookie = le64_to_cpu(msg->cookie);
5856

5857
	if (u64_get_bits(cookie, ATH12K_HTT_STATS_COOKIE_MSB) !=
5858
			 ATH12K_HTT_STATS_MAGIC_VALUE) {
5859
		ath12k_warn(ab, "received invalid htt ext stats event\n");
5860
		return;
5861
	}
5862

5863
	pdev_id = u64_get_bits(cookie, ATH12K_HTT_STATS_COOKIE_LSB);
5864
	rcu_read_lock();
5865
	ar = ath12k_mac_get_ar_by_pdev_id(ab, pdev_id);
5866
	if (!ar) {
5867
		ath12k_warn(ab, "failed to get ar for pdev_id %d\n", pdev_id);
5868
		goto exit;
5869
	}
5870

5871
	stats_req = ar->debug.htt_stats.stats_req;
5872
	if (!stats_req)
5873
		goto exit;
5874

5875
	spin_lock_bh(&ar->data_lock);
5876

5877
	stats_info = le32_to_cpu(msg->info1);
5878
	stats_req->done = u32_get_bits(stats_info, ATH12K_HTT_T2H_EXT_STATS_INFO1_DONE);
5879
	if (stats_req->done)
5880
		send_completion = true;
5881

5882
	spin_unlock_bh(&ar->data_lock);
5883

5884
	len = u32_get_bits(stats_info, ATH12K_HTT_T2H_EXT_STATS_INFO1_LENGTH);
5885
	if (len > skb->len) {
5886
		ath12k_warn(ab, "invalid length %d for HTT stats", len);
5887
		goto exit;
5888
	}
5889

5890
	ret = ath12k_dp_htt_tlv_iter(ab, msg->data, len,
5891
				     ath12k_dbg_htt_ext_stats_parse,
5892
				     stats_req);
5893
	if (ret)
5894
		ath12k_warn(ab, "Failed to parse tlv %d\n", ret);
5895

5896
	if (send_completion)
5897
		complete(&stats_req->htt_stats_rcvd);
5898
exit:
5899
	rcu_read_unlock();
5900
}
5901

5902
static ssize_t ath12k_read_htt_stats_type(struct file *file,
5903
					  char __user *user_buf,
5904
					  size_t count, loff_t *ppos)
5905
{
5906
	struct ath12k *ar = file->private_data;
5907
	enum ath12k_dbg_htt_ext_stats_type type;
5908
	char buf[32];
5909
	size_t len;
5910

5911
	wiphy_lock(ath12k_ar_to_hw(ar)->wiphy);
5912
	type = ar->debug.htt_stats.type;
5913
	wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
5914

5915
	len = scnprintf(buf, sizeof(buf), "%u\n", type);
5916

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

5920
static ssize_t ath12k_write_htt_stats_type(struct file *file,
5921
					   const char __user *user_buf,
5922
					   size_t count, loff_t *ppos)
5923
{
5924
	struct ath12k *ar = file->private_data;
5925
	enum ath12k_dbg_htt_ext_stats_type type;
5926
	unsigned int cfg_param[4] = {};
5927
	const int size = 32;
5928
	int num_args;
5929

5930
	if (count > size)
5931
		return -EINVAL;
5932

5933
	char *buf __free(kfree) = kzalloc(size, GFP_KERNEL);
5934
	if (!buf)
5935
		return -ENOMEM;
5936

5937
	if (copy_from_user(buf, user_buf, count))
5938
		return -EFAULT;
5939

5940
	num_args = sscanf(buf, "%u %u %u %u %u\n", &type, &cfg_param[0],
5941
			  &cfg_param[1], &cfg_param[2], &cfg_param[3]);
5942
	if (!num_args || num_args > 5)
5943
		return -EINVAL;
5944

5945
	if (type == ATH12K_DBG_HTT_EXT_STATS_RESET ||
5946
	    type >= ATH12K_DBG_HTT_NUM_EXT_STATS)
5947
		return -EINVAL;
5948

5949
	wiphy_lock(ath12k_ar_to_hw(ar)->wiphy);
5950

5951
	ar->debug.htt_stats.type = type;
5952
	ar->debug.htt_stats.cfg_param[0] = cfg_param[0];
5953
	ar->debug.htt_stats.cfg_param[1] = cfg_param[1];
5954
	ar->debug.htt_stats.cfg_param[2] = cfg_param[2];
5955
	ar->debug.htt_stats.cfg_param[3] = cfg_param[3];
5956

5957
	wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
5958

5959
	return count;
5960
}
5961

5962
static const struct file_operations fops_htt_stats_type = {
5963
	.read = ath12k_read_htt_stats_type,
5964
	.write = ath12k_write_htt_stats_type,
5965
	.open = simple_open,
5966
	.owner = THIS_MODULE,
5967
	.llseek = default_llseek,
5968
};
5969

5970
static int ath12k_debugfs_htt_stats_req(struct ath12k *ar)
5971
{
5972
	struct debug_htt_stats_req *stats_req = ar->debug.htt_stats.stats_req;
5973
	enum ath12k_dbg_htt_ext_stats_type type = stats_req->type;
5974
	u64 cookie;
5975
	int ret, pdev_id;
5976
	struct htt_ext_stats_cfg_params cfg_params = {};
5977

5978
	lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy);
5979

5980
	init_completion(&stats_req->htt_stats_rcvd);
5981

5982
	pdev_id = ath12k_mac_get_target_pdev_id(ar);
5983
	stats_req->done = false;
5984
	stats_req->pdev_id = pdev_id;
5985

5986
	cookie = u64_encode_bits(ATH12K_HTT_STATS_MAGIC_VALUE,
5987
				 ATH12K_HTT_STATS_COOKIE_MSB);
5988
	cookie |= u64_encode_bits(pdev_id, ATH12K_HTT_STATS_COOKIE_LSB);
5989

5990
	if (stats_req->override_cfg_param) {
5991
		cfg_params.cfg0 = stats_req->cfg_param[0];
5992
		cfg_params.cfg1 = stats_req->cfg_param[1];
5993
		cfg_params.cfg2 = stats_req->cfg_param[2];
5994
		cfg_params.cfg3 = stats_req->cfg_param[3];
5995
	}
5996

5997
	ret = ath12k_dp_tx_htt_h2t_ext_stats_req(ar, type, &cfg_params, cookie);
5998
	if (ret) {
5999
		ath12k_warn(ar->ab, "failed to send htt stats request: %d\n", ret);
6000
		return ret;
6001
	}
6002
	if (!wait_for_completion_timeout(&stats_req->htt_stats_rcvd, 3 * HZ)) {
6003
		spin_lock_bh(&ar->data_lock);
6004
		if (!stats_req->done) {
6005
			stats_req->done = true;
6006
			spin_unlock_bh(&ar->data_lock);
6007
			ath12k_warn(ar->ab, "stats request timed out\n");
6008
			return -ETIMEDOUT;
6009
		}
6010
		spin_unlock_bh(&ar->data_lock);
6011
	}
6012

6013
	return 0;
6014
}
6015

6016
static int ath12k_open_htt_stats(struct inode *inode,
6017
				 struct file *file)
6018
{
6019
	struct ath12k *ar = inode->i_private;
6020
	struct debug_htt_stats_req *stats_req;
6021
	enum ath12k_dbg_htt_ext_stats_type type = ar->debug.htt_stats.type;
6022
	struct ath12k_hw *ah = ath12k_ar_to_ah(ar);
6023
	int ret;
6024

6025
	if (type == ATH12K_DBG_HTT_EXT_STATS_RESET)
6026
		return -EPERM;
6027

6028
	wiphy_lock(ath12k_ar_to_hw(ar)->wiphy);
6029

6030
	if (ah->state != ATH12K_HW_STATE_ON) {
6031
		ret = -ENETDOWN;
6032
		goto err_unlock;
6033
	}
6034

6035
	if (ar->debug.htt_stats.stats_req) {
6036
		ret = -EAGAIN;
6037
		goto err_unlock;
6038
	}
6039

6040
	stats_req = kzalloc(sizeof(*stats_req) + ATH12K_HTT_STATS_BUF_SIZE, GFP_KERNEL);
6041
	if (!stats_req) {
6042
		ret = -ENOMEM;
6043
		goto err_unlock;
6044
	}
6045

6046
	ar->debug.htt_stats.stats_req = stats_req;
6047
	stats_req->type = type;
6048
	stats_req->cfg_param[0] = ar->debug.htt_stats.cfg_param[0];
6049
	stats_req->cfg_param[1] = ar->debug.htt_stats.cfg_param[1];
6050
	stats_req->cfg_param[2] = ar->debug.htt_stats.cfg_param[2];
6051
	stats_req->cfg_param[3] = ar->debug.htt_stats.cfg_param[3];
6052
	stats_req->override_cfg_param = !!stats_req->cfg_param[0] ||
6053
					!!stats_req->cfg_param[1] ||
6054
					!!stats_req->cfg_param[2] ||
6055
					!!stats_req->cfg_param[3];
6056

6057
	ret = ath12k_debugfs_htt_stats_req(ar);
6058
	if (ret < 0)
6059
		goto out;
6060

6061
	file->private_data = stats_req;
6062

6063
	wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
6064

6065
	return 0;
6066
out:
6067
	kfree(stats_req);
6068
	ar->debug.htt_stats.stats_req = NULL;
6069
err_unlock:
6070
	wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
6071

6072
	return ret;
6073
}
6074

6075
static int ath12k_release_htt_stats(struct inode *inode,
6076
				    struct file *file)
6077
{
6078
	struct ath12k *ar = inode->i_private;
6079

6080
	wiphy_lock(ath12k_ar_to_hw(ar)->wiphy);
6081
	kfree(file->private_data);
6082
	ar->debug.htt_stats.stats_req = NULL;
6083
	wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
6084

6085
	return 0;
6086
}
6087

6088
static ssize_t ath12k_read_htt_stats(struct file *file,
6089
				     char __user *user_buf,
6090
				     size_t count, loff_t *ppos)
6091
{
6092
	struct debug_htt_stats_req *stats_req = file->private_data;
6093
	char *buf;
6094
	u32 length;
6095

6096
	buf = stats_req->buf;
6097
	length = min_t(u32, stats_req->buf_len, ATH12K_HTT_STATS_BUF_SIZE);
6098
	return simple_read_from_buffer(user_buf, count, ppos, buf, length);
6099
}
6100

6101
static const struct file_operations fops_dump_htt_stats = {
6102
	.open = ath12k_open_htt_stats,
6103
	.release = ath12k_release_htt_stats,
6104
	.read = ath12k_read_htt_stats,
6105
	.owner = THIS_MODULE,
6106
	.llseek = default_llseek,
6107
};
6108

6109
static ssize_t ath12k_write_htt_stats_reset(struct file *file,
6110
					    const char __user *user_buf,
6111
					    size_t count, loff_t *ppos)
6112
{
6113
	struct ath12k *ar = file->private_data;
6114
	enum ath12k_dbg_htt_ext_stats_type type;
6115
	struct htt_ext_stats_cfg_params cfg_params = {};
6116
	u8 param_pos;
6117
	int ret;
6118

6119
	ret = kstrtou32_from_user(user_buf, count, 0, &type);
6120
	if (ret)
6121
		return ret;
6122

6123
	if (type >= ATH12K_DBG_HTT_NUM_EXT_STATS ||
6124
	    type == ATH12K_DBG_HTT_EXT_STATS_RESET)
6125
		return -E2BIG;
6126

6127
	wiphy_lock(ath12k_ar_to_hw(ar)->wiphy);
6128
	cfg_params.cfg0 = HTT_STAT_DEFAULT_RESET_START_OFFSET;
6129
	param_pos = (type >> 5) + 1;
6130

6131
	switch (param_pos) {
6132
	case ATH12K_HTT_STATS_RESET_PARAM_CFG_32_BYTES:
6133
		cfg_params.cfg1 = 1 << (cfg_params.cfg0 + type);
6134
		break;
6135
	case ATH12K_HTT_STATS_RESET_PARAM_CFG_64_BYTES:
6136
		cfg_params.cfg2 = ATH12K_HTT_STATS_RESET_BITMAP32_BIT(cfg_params.cfg0 +
6137
								      type);
6138
		break;
6139
	case ATH12K_HTT_STATS_RESET_PARAM_CFG_128_BYTES:
6140
		cfg_params.cfg3 = ATH12K_HTT_STATS_RESET_BITMAP64_BIT(cfg_params.cfg0 +
6141
								      type);
6142
		break;
6143
	default:
6144
		break;
6145
	}
6146

6147
	ret = ath12k_dp_tx_htt_h2t_ext_stats_req(ar,
6148
						 ATH12K_DBG_HTT_EXT_STATS_RESET,
6149
						 &cfg_params,
6150
						 0ULL);
6151
	if (ret) {
6152
		ath12k_warn(ar->ab, "failed to send htt stats request: %d\n", ret);
6153
		wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
6154
		return ret;
6155
	}
6156

6157
	ar->debug.htt_stats.reset = type;
6158
	wiphy_unlock(ath12k_ar_to_hw(ar)->wiphy);
6159

6160
	return count;
6161
}
6162

6163
static const struct file_operations fops_htt_stats_reset = {
6164
	.write = ath12k_write_htt_stats_reset,
6165
	.open = simple_open,
6166
	.owner = THIS_MODULE,
6167
	.llseek = default_llseek,
6168
};
6169

6170
void ath12k_debugfs_htt_stats_register(struct ath12k *ar)
6171
{
6172
	debugfs_create_file("htt_stats_type", 0600, ar->debug.debugfs_pdev,
6173
			    ar, &fops_htt_stats_type);
6174
	debugfs_create_file("htt_stats", 0400, ar->debug.debugfs_pdev,
6175
			    ar, &fops_dump_htt_stats);
6176
	debugfs_create_file("htt_stats_reset", 0200, ar->debug.debugfs_pdev,
6177
			    ar, &fops_htt_stats_reset);
6178
}
6179

6180
Product

Resources

Company
