CoCalc -- debugfs_htt

GitHub Repository: freebsd/freebsd-src
Path: blob/main/sys/contrib/dev/athk/ath11k/debugfs_htt_stats.c
¹⁰⁴⁸⁷⁴ views
1
// SPDX-License-Identifier: BSD-3-Clause-Clear
2
/*
3
 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
4
 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
5
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
6
 */
7

8
#include <linux/vmalloc.h>
9
#include "core.h"
10
#include "dp_tx.h"
11
#include "dp_rx.h"
12
#include "debug.h"
13
#include "debugfs_htt_stats.h"
14

15
#define HTT_MAX_PRINT_CHAR_PER_ELEM 15
16

17
#define HTT_TLV_HDR_LEN 4
18

19
#define PRINT_ARRAY_TO_BUF(out, buflen, arr, str, len, newline)				\
20
	do {										\
21
		int index = 0; u8 i; const char *str_val = str;				\
22
		const char *new_line = newline;						\
23
		if (str_val) {								\
24
			index += scnprintf((out + buflen),				\
25
				 (ATH11K_HTT_STATS_BUF_SIZE - buflen),			\
26
				 "%s = ", str_val);					\
27
		}									\
28
		for (i = 0; i < len; i++) {						\
29
			index += scnprintf((out + buflen) + index,			\
30
				 (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,		\
31
				 " %u:%u,", i, arr[i]);					\
32
		}									\
33
		index += scnprintf((out + buflen) + index,				\
34
			 (ATH11K_HTT_STATS_BUF_SIZE - buflen) - index,			\
35
			  "%s", new_line);						\
36
		buflen += index;							\
37
	} while (0)
38

39
static inline void htt_print_stats_string_tlv(const void *tag_buf,
40
					      u16 tag_len,
41
					      struct debug_htt_stats_req *stats_req)
42
{
43
	const struct htt_stats_string_tlv *htt_stats_buf = tag_buf;
44
	u8 *buf = stats_req->buf;
45
	u32 len = stats_req->buf_len;
46
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
47
	u8  i;
48

49
	tag_len = tag_len >> 2;
50

51
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_STRING_TLV:\n");
52

53
	len += scnprintf(buf + len, buf_len - len,
54
			 "data = ");
55
	for (i = 0; i < tag_len; i++) {
56
		len += scnprintf(buf + len,
57
				 buf_len - len,
58
				 "%.*s", 4, (char *)&(htt_stats_buf->data[i]));
59
	}
60
	/* New lines are added for better display */
61
	len += scnprintf(buf + len, buf_len - len, "\n\n");
62

63
	if (len >= buf_len)
64
		buf[buf_len - 1] = 0;
65
	else
66
		buf[len] = 0;
67

68
	stats_req->buf_len = len;
69
}
70

71
static inline void htt_print_tx_pdev_stats_cmn_tlv(const void *tag_buf,
72
						   struct debug_htt_stats_req *stats_req)
73
{
74
	const struct htt_tx_pdev_stats_cmn_tlv *htt_stats_buf = tag_buf;
75
	u8 *buf = stats_req->buf;
76
	u32 len = stats_req->buf_len;
77
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
78

79
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_CMN_TLV:\n");
80
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
81
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
82
	len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n",
83
			 htt_stats_buf->hw_queued);
84
	len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n",
85
			 htt_stats_buf->hw_reaped);
86
	len += scnprintf(buf + len, buf_len - len, "underrun = %u\n",
87
			 htt_stats_buf->underrun);
88
	len += scnprintf(buf + len, buf_len - len, "hw_paused = %u\n",
89
			 htt_stats_buf->hw_paused);
90
	len += scnprintf(buf + len, buf_len - len, "hw_flush = %u\n",
91
			 htt_stats_buf->hw_flush);
92
	len += scnprintf(buf + len, buf_len - len, "hw_filt = %u\n",
93
			 htt_stats_buf->hw_filt);
94
	len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n",
95
			 htt_stats_buf->tx_abort);
96
	len += scnprintf(buf + len, buf_len - len, "mpdu_requeued = %u\n",
97
			 htt_stats_buf->mpdu_requeued);
98
	len += scnprintf(buf + len, buf_len - len, "tx_xretry = %u\n",
99
			 htt_stats_buf->tx_xretry);
100
	len += scnprintf(buf + len, buf_len - len, "data_rc = %u\n",
101
			 htt_stats_buf->data_rc);
102
	len += scnprintf(buf + len, buf_len - len, "mpdu_dropped_xretry = %u\n",
103
			 htt_stats_buf->mpdu_dropped_xretry);
104
	len += scnprintf(buf + len, buf_len - len, "illegal_rate_phy_err = %u\n",
105
			 htt_stats_buf->illgl_rate_phy_err);
106
	len += scnprintf(buf + len, buf_len - len, "cont_xretry = %u\n",
107
			 htt_stats_buf->cont_xretry);
108
	len += scnprintf(buf + len, buf_len - len, "tx_timeout = %u\n",
109
			 htt_stats_buf->tx_timeout);
110
	len += scnprintf(buf + len, buf_len - len, "pdev_resets = %u\n",
111
			 htt_stats_buf->pdev_resets);
112
	len += scnprintf(buf + len, buf_len - len, "phy_underrun = %u\n",
113
			 htt_stats_buf->phy_underrun);
114
	len += scnprintf(buf + len, buf_len - len, "txop_ovf = %u\n",
115
			 htt_stats_buf->txop_ovf);
116
	len += scnprintf(buf + len, buf_len - len, "seq_posted = %u\n",
117
			 htt_stats_buf->seq_posted);
118
	len += scnprintf(buf + len, buf_len - len, "seq_failed_queueing = %u\n",
119
			 htt_stats_buf->seq_failed_queueing);
120
	len += scnprintf(buf + len, buf_len - len, "seq_completed = %u\n",
121
			 htt_stats_buf->seq_completed);
122
	len += scnprintf(buf + len, buf_len - len, "seq_restarted = %u\n",
123
			 htt_stats_buf->seq_restarted);
124
	len += scnprintf(buf + len, buf_len - len, "mu_seq_posted = %u\n",
125
			 htt_stats_buf->mu_seq_posted);
126
	len += scnprintf(buf + len, buf_len - len, "seq_switch_hw_paused = %u\n",
127
			 htt_stats_buf->seq_switch_hw_paused);
128
	len += scnprintf(buf + len, buf_len - len, "next_seq_posted_dsr = %u\n",
129
			 htt_stats_buf->next_seq_posted_dsr);
130
	len += scnprintf(buf + len, buf_len - len, "seq_posted_isr = %u\n",
131
			 htt_stats_buf->seq_posted_isr);
132
	len += scnprintf(buf + len, buf_len - len, "seq_ctrl_cached = %u\n",
133
			 htt_stats_buf->seq_ctrl_cached);
134
	len += scnprintf(buf + len, buf_len - len, "mpdu_count_tqm = %u\n",
135
			 htt_stats_buf->mpdu_count_tqm);
136
	len += scnprintf(buf + len, buf_len - len, "msdu_count_tqm = %u\n",
137
			 htt_stats_buf->msdu_count_tqm);
138
	len += scnprintf(buf + len, buf_len - len, "mpdu_removed_tqm = %u\n",
139
			 htt_stats_buf->mpdu_removed_tqm);
140
	len += scnprintf(buf + len, buf_len - len, "msdu_removed_tqm = %u\n",
141
			 htt_stats_buf->msdu_removed_tqm);
142
	len += scnprintf(buf + len, buf_len - len, "mpdus_sw_flush = %u\n",
143
			 htt_stats_buf->mpdus_sw_flush);
144
	len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
145
			 htt_stats_buf->mpdus_hw_filter);
146
	len += scnprintf(buf + len, buf_len - len, "mpdus_truncated = %u\n",
147
			 htt_stats_buf->mpdus_truncated);
148
	len += scnprintf(buf + len, buf_len - len, "mpdus_ack_failed = %u\n",
149
			 htt_stats_buf->mpdus_ack_failed);
150
	len += scnprintf(buf + len, buf_len - len, "mpdus_expired = %u\n",
151
			 htt_stats_buf->mpdus_expired);
152
	len += scnprintf(buf + len, buf_len - len, "mpdus_seq_hw_retry = %u\n",
153
			 htt_stats_buf->mpdus_seq_hw_retry);
154
	len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
155
			 htt_stats_buf->ack_tlv_proc);
156
	len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt_valid = %u\n",
157
			 htt_stats_buf->coex_abort_mpdu_cnt_valid);
158
	len += scnprintf(buf + len, buf_len - len, "coex_abort_mpdu_cnt = %u\n",
159
			 htt_stats_buf->coex_abort_mpdu_cnt);
160
	len += scnprintf(buf + len, buf_len - len, "num_total_ppdus_tried_ota = %u\n",
161
			 htt_stats_buf->num_total_ppdus_tried_ota);
162
	len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_tried_ota = %u\n",
163
			 htt_stats_buf->num_data_ppdus_tried_ota);
164
	len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_enqued = %u\n",
165
			 htt_stats_buf->local_ctrl_mgmt_enqued);
166
	len += scnprintf(buf + len, buf_len - len, "local_ctrl_mgmt_freed = %u\n",
167
			 htt_stats_buf->local_ctrl_mgmt_freed);
168
	len += scnprintf(buf + len, buf_len - len, "local_data_enqued = %u\n",
169
			 htt_stats_buf->local_data_enqued);
170
	len += scnprintf(buf + len, buf_len - len, "local_data_freed = %u\n",
171
			 htt_stats_buf->local_data_freed);
172
	len += scnprintf(buf + len, buf_len - len, "mpdu_tried = %u\n",
173
			 htt_stats_buf->mpdu_tried);
174
	len += scnprintf(buf + len, buf_len - len, "isr_wait_seq_posted = %u\n",
175
			 htt_stats_buf->isr_wait_seq_posted);
176
	len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_low = %u\n",
177
			 htt_stats_buf->tx_active_dur_us_low);
178
	len += scnprintf(buf + len, buf_len - len, "tx_active_dur_us_high = %u\n\n",
179
			 htt_stats_buf->tx_active_dur_us_high);
180

181
	if (len >= buf_len)
182
		buf[buf_len - 1] = 0;
183
	else
184
		buf[len] = 0;
185

186
	stats_req->buf_len = len;
187
}
188

189
static inline void
190
htt_print_tx_pdev_stats_urrn_tlv_v(const void *tag_buf,
191
				   u16 tag_len,
192
				   struct debug_htt_stats_req *stats_req)
193
{
194
	const struct htt_tx_pdev_stats_urrn_tlv_v *htt_stats_buf = tag_buf;
195
	u8 *buf = stats_req->buf;
196
	u32 len = stats_req->buf_len;
197
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
198
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_URRN_STATS);
199

200
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_URRN_TLV_V:\n");
201

202
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->urrn_stats, "urrn_stats",
203
			   num_elems, "\n\n");
204

205
	if (len >= buf_len)
206
		buf[buf_len - 1] = 0;
207
	else
208
		buf[len] = 0;
209

210
	stats_req->buf_len = len;
211
}
212

213
static inline void
214
htt_print_tx_pdev_stats_flush_tlv_v(const void *tag_buf,
215
				    u16 tag_len,
216
				    struct debug_htt_stats_req *stats_req)
217
{
218
	const struct htt_tx_pdev_stats_flush_tlv_v *htt_stats_buf = tag_buf;
219
	u8 *buf = stats_req->buf;
220
	u32 len = stats_req->buf_len;
221
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
222
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_FLUSH_REASON_STATS);
223

224
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_FLUSH_TLV_V:\n");
225

226
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->flush_errs, "flush_errs",
227
			   num_elems, "\n\n");
228

229
	if (len >= buf_len)
230
		buf[buf_len - 1] = 0;
231
	else
232
		buf[len] = 0;
233

234
	stats_req->buf_len = len;
235
}
236

237
static inline void
238
htt_print_tx_pdev_stats_sifs_tlv_v(const void *tag_buf,
239
				   u16 tag_len,
240
				   struct debug_htt_stats_req *stats_req)
241
{
242
	const struct htt_tx_pdev_stats_sifs_tlv_v *htt_stats_buf = tag_buf;
243
	u8 *buf = stats_req->buf;
244
	u32 len = stats_req->buf_len;
245
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
246
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_SIFS_BURST_STATS);
247

248
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_SIFS_TLV_V:\n");
249

250
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_status, "sifs_status",
251
			   num_elems, "\n\n");
252

253
	if (len >= buf_len)
254
		buf[buf_len - 1] = 0;
255
	else
256
		buf[len] = 0;
257

258
	stats_req->buf_len = len;
259
}
260

261
static inline void
262
htt_print_tx_pdev_stats_phy_err_tlv_v(const void *tag_buf,
263
				      u16 tag_len,
264
				      struct debug_htt_stats_req *stats_req)
265
{
266
	const struct htt_tx_pdev_stats_phy_err_tlv_v *htt_stats_buf = tag_buf;
267
	u8 *buf = stats_req->buf;
268
	u32 len = stats_req->buf_len;
269
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
270
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_PHY_ERR_STATS);
271

272
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_STATS_PHY_ERR_TLV_V:\n");
273

274
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_errs, "phy_errs",
275
			   num_elems, "\n\n");
276

277
	if (len >= buf_len)
278
		buf[buf_len - 1] = 0;
279
	else
280
		buf[len] = 0;
281

282
	stats_req->buf_len = len;
283
}
284

285
static inline void
286
htt_print_tx_pdev_stats_sifs_hist_tlv_v(const void *tag_buf,
287
					u16 tag_len,
288
					struct debug_htt_stats_req *stats_req)
289
{
290
	const struct htt_tx_pdev_stats_sifs_hist_tlv_v *htt_stats_buf = tag_buf;
291
	u8 *buf = stats_req->buf;
292
	u32 len = stats_req->buf_len;
293
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
294
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_MAX_SIFS_BURST_HIST_STATS);
295

296
	len += scnprintf(buf + len, buf_len - len,
297
			 "HTT_TX_PDEV_STATS_SIFS_HIST_TLV_V:\n");
298

299
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sifs_hist_status,
300
			   "sifs_hist_status", num_elems, "\n\n");
301

302
	if (len >= buf_len)
303
		buf[buf_len - 1] = 0;
304
	else
305
		buf[len] = 0;
306

307
	stats_req->buf_len = len;
308
}
309

310
static inline void
311
htt_print_tx_pdev_stats_tx_ppdu_stats_tlv_v(const void *tag_buf,
312
					    struct debug_htt_stats_req *stats_req)
313
{
314
	const struct htt_tx_pdev_stats_tx_ppdu_stats_tlv_v *htt_stats_buf = tag_buf;
315
	u8 *buf = stats_req->buf;
316
	u32 len = stats_req->buf_len;
317
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
318

319
	len += scnprintf(buf + len, buf_len - len,
320
			 "HTT_TX_PDEV_STATS_TX_PPDU_STATS_TLV_V:\n");
321

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

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

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

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

334
	len += scnprintf(buf + len, buf_len - len, "num_data_ppdus_ax_su_txbf = %u\n\n",
335
			 htt_stats_buf->num_data_ppdus_ax_su_txbf);
336

337
	if (len >= buf_len)
338
		buf[buf_len - 1] = 0;
339
	else
340
		buf[len] = 0;
341

342
	stats_req->buf_len = len;
343
}
344

345
static inline void
346
htt_print_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v(const void *tag_buf,
347
						  u16 tag_len,
348
						  struct debug_htt_stats_req *stats_req)
349
{
350
	const struct htt_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v *htt_stats_buf = tag_buf;
351
	u8 *buf = stats_req->buf;
352
	u32 len = stats_req->buf_len;
353
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
354
	u32  num_elements = ((tag_len - sizeof(htt_stats_buf->hist_bin_size)) >> 2);
355

356
	len += scnprintf(buf + len, buf_len - len,
357
			 "HTT_TX_PDEV_STATS_TRIED_MPDU_CNT_HIST_TLV_V:\n");
358
	len += scnprintf(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n",
359
			 htt_stats_buf->hist_bin_size);
360

361
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist,
362
			   "tried_mpdu_cnt_hist", num_elements, "\n\n");
363

364
	if (len >= buf_len)
365
		buf[buf_len - 1] = 0;
366
	else
367
		buf[len] = 0;
368

369
	stats_req->buf_len = len;
370
}
371

372
static inline void htt_print_hw_stats_intr_misc_tlv(const void *tag_buf,
373
						    struct debug_htt_stats_req *stats_req)
374
{
375
	const struct htt_hw_stats_intr_misc_tlv *htt_stats_buf = tag_buf;
376
	u8 *buf = stats_req->buf;
377
	u32 len = stats_req->buf_len;
378
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
379
	char hw_intr_name[HTT_STATS_MAX_HW_INTR_NAME_LEN + 1] = {};
380

381
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_INTR_MISC_TLV:\n");
382
	memcpy(hw_intr_name, &(htt_stats_buf->hw_intr_name[0]),
383
	       HTT_STATS_MAX_HW_INTR_NAME_LEN);
384
	len += scnprintf(buf + len, buf_len - len, "hw_intr_name = %s\n", hw_intr_name);
385
	len += scnprintf(buf + len, buf_len - len, "mask = %u\n",
386
			 htt_stats_buf->mask);
387
	len += scnprintf(buf + len, buf_len - len, "count = %u\n\n",
388
			 htt_stats_buf->count);
389

390
	if (len >= buf_len)
391
		buf[buf_len - 1] = 0;
392
	else
393
		buf[len] = 0;
394

395
	stats_req->buf_len = len;
396
}
397

398
static inline void
399
htt_print_hw_stats_wd_timeout_tlv(const void *tag_buf,
400
				  struct debug_htt_stats_req *stats_req)
401
{
402
	const struct htt_hw_stats_wd_timeout_tlv *htt_stats_buf = tag_buf;
403
	u8 *buf = stats_req->buf;
404
	u32 len = stats_req->buf_len;
405
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
406
	char hw_module_name[HTT_STATS_MAX_HW_MODULE_NAME_LEN + 1] = {};
407

408
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WD_TIMEOUT_TLV:\n");
409
	memcpy(hw_module_name, &(htt_stats_buf->hw_module_name[0]),
410
	       HTT_STATS_MAX_HW_MODULE_NAME_LEN);
411
	len += scnprintf(buf + len, buf_len - len, "hw_module_name = %s\n",
412
			 hw_module_name);
413
	len += scnprintf(buf + len, buf_len - len, "count = %u\n",
414
			 htt_stats_buf->count);
415

416
	if (len >= buf_len)
417
		buf[buf_len - 1] = 0;
418
	else
419
		buf[len] = 0;
420

421
	stats_req->buf_len = len;
422
}
423

424
static inline void htt_print_hw_stats_pdev_errs_tlv(const void *tag_buf,
425
						    struct debug_htt_stats_req *stats_req)
426
{
427
	const struct htt_hw_stats_pdev_errs_tlv *htt_stats_buf = tag_buf;
428
	u8 *buf = stats_req->buf;
429
	u32 len = stats_req->buf_len;
430
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
431

432
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_PDEV_ERRS_TLV:\n");
433
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
434
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
435
	len += scnprintf(buf + len, buf_len - len, "tx_abort = %u\n",
436
			 htt_stats_buf->tx_abort);
437
	len += scnprintf(buf + len, buf_len - len, "tx_abort_fail_count = %u\n",
438
			 htt_stats_buf->tx_abort_fail_count);
439
	len += scnprintf(buf + len, buf_len - len, "rx_abort = %u\n",
440
			 htt_stats_buf->rx_abort);
441
	len += scnprintf(buf + len, buf_len - len, "rx_abort_fail_count = %u\n",
442
			 htt_stats_buf->rx_abort_fail_count);
443
	len += scnprintf(buf + len, buf_len - len, "warm_reset = %u\n",
444
			 htt_stats_buf->warm_reset);
445
	len += scnprintf(buf + len, buf_len - len, "cold_reset = %u\n",
446
			 htt_stats_buf->cold_reset);
447
	len += scnprintf(buf + len, buf_len - len, "tx_flush = %u\n",
448
			 htt_stats_buf->tx_flush);
449
	len += scnprintf(buf + len, buf_len - len, "tx_glb_reset = %u\n",
450
			 htt_stats_buf->tx_glb_reset);
451
	len += scnprintf(buf + len, buf_len - len, "tx_txq_reset = %u\n",
452
			 htt_stats_buf->tx_txq_reset);
453
	len += scnprintf(buf + len, buf_len - len, "rx_timeout_reset = %u\n\n",
454
			 htt_stats_buf->rx_timeout_reset);
455

456
	if (len >= buf_len)
457
		buf[buf_len - 1] = 0;
458
	else
459
		buf[len] = 0;
460

461
	stats_req->buf_len = len;
462
}
463

464
static inline void htt_print_msdu_flow_stats_tlv(const void *tag_buf,
465
						 struct debug_htt_stats_req *stats_req)
466
{
467
	const struct htt_msdu_flow_stats_tlv *htt_stats_buf = tag_buf;
468
	u8 *buf = stats_req->buf;
469
	u32 len = stats_req->buf_len;
470
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
471

472
	len += scnprintf(buf + len, buf_len - len, "HTT_MSDU_FLOW_STATS_TLV:\n");
473
	len += scnprintf(buf + len, buf_len - len, "last_update_timestamp = %u\n",
474
			 htt_stats_buf->last_update_timestamp);
475
	len += scnprintf(buf + len, buf_len - len, "last_add_timestamp = %u\n",
476
			 htt_stats_buf->last_add_timestamp);
477
	len += scnprintf(buf + len, buf_len - len, "last_remove_timestamp = %u\n",
478
			 htt_stats_buf->last_remove_timestamp);
479
	len += scnprintf(buf + len, buf_len - len, "total_processed_msdu_count = %u\n",
480
			 htt_stats_buf->total_processed_msdu_count);
481
	len += scnprintf(buf + len, buf_len - len, "cur_msdu_count_in_flowq = %u\n",
482
			 htt_stats_buf->cur_msdu_count_in_flowq);
483
	len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n",
484
			 htt_stats_buf->sw_peer_id);
485
	len += scnprintf(buf + len, buf_len - len, "tx_flow_no = %lu\n",
486
			 FIELD_GET(HTT_MSDU_FLOW_STATS_TX_FLOW_NO,
487
				   htt_stats_buf->tx_flow_no__tid_num__drop_rule));
488
	len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
489
			 FIELD_GET(HTT_MSDU_FLOW_STATS_TID_NUM,
490
				   htt_stats_buf->tx_flow_no__tid_num__drop_rule));
491
	len += scnprintf(buf + len, buf_len - len, "drop_rule = %lu\n",
492
			 FIELD_GET(HTT_MSDU_FLOW_STATS_DROP_RULE,
493
				   htt_stats_buf->tx_flow_no__tid_num__drop_rule));
494
	len += scnprintf(buf + len, buf_len - len, "last_cycle_enqueue_count = %u\n",
495
			 htt_stats_buf->last_cycle_enqueue_count);
496
	len += scnprintf(buf + len, buf_len - len, "last_cycle_dequeue_count = %u\n",
497
			 htt_stats_buf->last_cycle_dequeue_count);
498
	len += scnprintf(buf + len, buf_len - len, "last_cycle_drop_count = %u\n",
499
			 htt_stats_buf->last_cycle_drop_count);
500
	len += scnprintf(buf + len, buf_len - len, "current_drop_th = %u\n\n",
501
			 htt_stats_buf->current_drop_th);
502

503
	if (len >= buf_len)
504
		buf[buf_len - 1] = 0;
505
	else
506
		buf[len] = 0;
507

508
	stats_req->buf_len = len;
509
}
510

511
static inline void htt_print_tx_tid_stats_tlv(const void *tag_buf,
512
					      struct debug_htt_stats_req *stats_req)
513
{
514
	const struct htt_tx_tid_stats_tlv *htt_stats_buf = tag_buf;
515
	u8 *buf = stats_req->buf;
516
	u32 len = stats_req->buf_len;
517
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
518
	char tid_name[MAX_HTT_TID_NAME + 1] = {};
519

520
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TID_STATS_TLV:\n");
521
	memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
522
	len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name);
523
	len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n",
524
			 FIELD_GET(HTT_TX_TID_STATS_SW_PEER_ID,
525
				   htt_stats_buf->sw_peer_id__tid_num));
526
	len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
527
			 FIELD_GET(HTT_TX_TID_STATS_TID_NUM,
528
				   htt_stats_buf->sw_peer_id__tid_num));
529
	len += scnprintf(buf + len, buf_len - len, "num_sched_pending = %lu\n",
530
			 FIELD_GET(HTT_TX_TID_STATS_NUM_SCHED_PENDING,
531
				   htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
532
	len += scnprintf(buf + len, buf_len - len, "num_ppdu_in_hwq = %lu\n",
533
			 FIELD_GET(HTT_TX_TID_STATS_NUM_PPDU_IN_HWQ,
534
				   htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
535
	len += scnprintf(buf + len, buf_len - len, "tid_flags = 0x%x\n",
536
			 htt_stats_buf->tid_flags);
537
	len += scnprintf(buf + len, buf_len - len, "hw_queued = %u\n",
538
			 htt_stats_buf->hw_queued);
539
	len += scnprintf(buf + len, buf_len - len, "hw_reaped = %u\n",
540
			 htt_stats_buf->hw_reaped);
541
	len += scnprintf(buf + len, buf_len - len, "mpdus_hw_filter = %u\n",
542
			 htt_stats_buf->mpdus_hw_filter);
543
	len += scnprintf(buf + len, buf_len - len, "qdepth_bytes = %u\n",
544
			 htt_stats_buf->qdepth_bytes);
545
	len += scnprintf(buf + len, buf_len - len, "qdepth_num_msdu = %u\n",
546
			 htt_stats_buf->qdepth_num_msdu);
547
	len += scnprintf(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n",
548
			 htt_stats_buf->qdepth_num_mpdu);
549
	len += scnprintf(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n",
550
			 htt_stats_buf->last_scheduled_tsmp);
551
	len += scnprintf(buf + len, buf_len - len, "pause_module_id = %u\n",
552
			 htt_stats_buf->pause_module_id);
553
	len += scnprintf(buf + len, buf_len - len, "block_module_id = %u\n\n",
554
			 htt_stats_buf->block_module_id);
555

556
	if (len >= buf_len)
557
		buf[buf_len - 1] = 0;
558
	else
559
		buf[len] = 0;
560

561
	stats_req->buf_len = len;
562
}
563

564
static inline void htt_print_tx_tid_stats_v1_tlv(const void *tag_buf,
565
						 struct debug_htt_stats_req *stats_req)
566
{
567
	const struct htt_tx_tid_stats_v1_tlv *htt_stats_buf = tag_buf;
568
	u8 *buf = stats_req->buf;
569
	u32 len = stats_req->buf_len;
570
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
571
	char tid_name[MAX_HTT_TID_NAME + 1] = {};
572

573
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TID_STATS_V1_TLV:\n");
574
	memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
575
	len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name);
576
	len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n",
577
			 FIELD_GET(HTT_TX_TID_STATS_V1_SW_PEER_ID,
578
				   htt_stats_buf->sw_peer_id__tid_num));
579
	len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
580
			 FIELD_GET(HTT_TX_TID_STATS_V1_TID_NUM,
581
				   htt_stats_buf->sw_peer_id__tid_num));
582
	len += scnprintf(buf + len, buf_len - len, "num_sched_pending = %lu\n",
583
			 FIELD_GET(HTT_TX_TID_STATS_V1_NUM_SCHED_PENDING,
584
				   htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
585
	len += scnprintf(buf + len, buf_len - len, "num_ppdu_in_hwq = %lu\n",
586
			 FIELD_GET(HTT_TX_TID_STATS_V1_NUM_PPDU_IN_HWQ,
587
				   htt_stats_buf->num_sched_pending__num_ppdu_in_hwq));
588
	len += scnprintf(buf + len, buf_len - len, "tid_flags = 0x%x\n",
589
			 htt_stats_buf->tid_flags);
590
	len += scnprintf(buf + len, buf_len - len, "max_qdepth_bytes = %u\n",
591
			 htt_stats_buf->max_qdepth_bytes);
592
	len += scnprintf(buf + len, buf_len - len, "max_qdepth_n_msdus = %u\n",
593
			 htt_stats_buf->max_qdepth_n_msdus);
594
	len += scnprintf(buf + len, buf_len - len, "rsvd = %u\n",
595
			 htt_stats_buf->rsvd);
596
	len += scnprintf(buf + len, buf_len - len, "qdepth_bytes = %u\n",
597
			 htt_stats_buf->qdepth_bytes);
598
	len += scnprintf(buf + len, buf_len - len, "qdepth_num_msdu = %u\n",
599
			 htt_stats_buf->qdepth_num_msdu);
600
	len += scnprintf(buf + len, buf_len - len, "qdepth_num_mpdu = %u\n",
601
			 htt_stats_buf->qdepth_num_mpdu);
602
	len += scnprintf(buf + len, buf_len - len, "last_scheduled_tsmp = %u\n",
603
			 htt_stats_buf->last_scheduled_tsmp);
604
	len += scnprintf(buf + len, buf_len - len, "pause_module_id = %u\n",
605
			 htt_stats_buf->pause_module_id);
606
	len += scnprintf(buf + len, buf_len - len, "block_module_id = %u\n",
607
			 htt_stats_buf->block_module_id);
608
	len += scnprintf(buf + len, buf_len - len, "allow_n_flags = 0x%x\n",
609
			 htt_stats_buf->allow_n_flags);
610
	len += scnprintf(buf + len, buf_len - len, "sendn_frms_allowed = %u\n\n",
611
			 htt_stats_buf->sendn_frms_allowed);
612

613
	if (len >= buf_len)
614
		buf[buf_len - 1] = 0;
615
	else
616
		buf[len] = 0;
617

618
	stats_req->buf_len = len;
619
}
620

621
static inline void htt_print_rx_tid_stats_tlv(const void *tag_buf,
622
					      struct debug_htt_stats_req *stats_req)
623
{
624
	const struct htt_rx_tid_stats_tlv *htt_stats_buf = tag_buf;
625
	u8 *buf = stats_req->buf;
626
	u32 len = stats_req->buf_len;
627
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
628
	char tid_name[MAX_HTT_TID_NAME + 1] = {};
629

630
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_TID_STATS_TLV:\n");
631
	len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %lu\n",
632
			 FIELD_GET(HTT_RX_TID_STATS_SW_PEER_ID,
633
				   htt_stats_buf->sw_peer_id__tid_num));
634
	len += scnprintf(buf + len, buf_len - len, "tid_num = %lu\n",
635
			 FIELD_GET(HTT_RX_TID_STATS_TID_NUM,
636
				   htt_stats_buf->sw_peer_id__tid_num));
637
	memcpy(tid_name, &(htt_stats_buf->tid_name[0]), MAX_HTT_TID_NAME);
638
	len += scnprintf(buf + len, buf_len - len, "tid_name = %s\n", tid_name);
639
	len += scnprintf(buf + len, buf_len - len, "dup_in_reorder = %u\n",
640
			 htt_stats_buf->dup_in_reorder);
641
	len += scnprintf(buf + len, buf_len - len, "dup_past_outside_window = %u\n",
642
			 htt_stats_buf->dup_past_outside_window);
643
	len += scnprintf(buf + len, buf_len - len, "dup_past_within_window = %u\n",
644
			 htt_stats_buf->dup_past_within_window);
645
	len += scnprintf(buf + len, buf_len - len, "rxdesc_err_decrypt = %u\n\n",
646
			 htt_stats_buf->rxdesc_err_decrypt);
647

648
	if (len >= buf_len)
649
		buf[buf_len - 1] = 0;
650
	else
651
		buf[len] = 0;
652

653
	stats_req->buf_len = len;
654
}
655

656
static inline void htt_print_counter_tlv(const void *tag_buf,
657
					 struct debug_htt_stats_req *stats_req)
658
{
659
	const struct htt_counter_tlv *htt_stats_buf = tag_buf;
660
	u8 *buf = stats_req->buf;
661
	u32 len = stats_req->buf_len;
662
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
663

664
	len += scnprintf(buf + len, buf_len - len, "HTT_COUNTER_TLV:\n");
665

666
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->counter_name,
667
			   "counter_name",
668
			   HTT_MAX_COUNTER_NAME, "\n");
669
	len += scnprintf(buf + len, buf_len - len, "count = %u\n\n",
670
			 htt_stats_buf->count);
671

672
	if (len >= buf_len)
673
		buf[buf_len - 1] = 0;
674
	else
675
		buf[len] = 0;
676

677
	stats_req->buf_len = len;
678
}
679

680
static inline void htt_print_peer_stats_cmn_tlv(const void *tag_buf,
681
						struct debug_htt_stats_req *stats_req)
682
{
683
	const struct htt_peer_stats_cmn_tlv *htt_stats_buf = tag_buf;
684
	u8 *buf = stats_req->buf;
685
	u32 len = stats_req->buf_len;
686
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
687

688
	len += scnprintf(buf + len, buf_len - len, "HTT_PEER_STATS_CMN_TLV:\n");
689
	len += scnprintf(buf + len, buf_len - len, "ppdu_cnt = %u\n",
690
			 htt_stats_buf->ppdu_cnt);
691
	len += scnprintf(buf + len, buf_len - len, "mpdu_cnt = %u\n",
692
			 htt_stats_buf->mpdu_cnt);
693
	len += scnprintf(buf + len, buf_len - len, "msdu_cnt = %u\n",
694
			 htt_stats_buf->msdu_cnt);
695
	len += scnprintf(buf + len, buf_len - len, "pause_bitmap = %u\n",
696
			 htt_stats_buf->pause_bitmap);
697
	len += scnprintf(buf + len, buf_len - len, "block_bitmap = %u\n",
698
			 htt_stats_buf->block_bitmap);
699
	len += scnprintf(buf + len, buf_len - len, "last_rssi = %d\n",
700
			 htt_stats_buf->rssi);
701
	len += scnprintf(buf + len, buf_len - len, "enqueued_count = %llu\n",
702
			 htt_stats_buf->peer_enqueued_count_low |
703
			 ((u64)htt_stats_buf->peer_enqueued_count_high << 32));
704
	len += scnprintf(buf + len, buf_len - len, "dequeued_count = %llu\n",
705
			 htt_stats_buf->peer_dequeued_count_low |
706
			 ((u64)htt_stats_buf->peer_dequeued_count_high << 32));
707
	len += scnprintf(buf + len, buf_len - len, "dropped_count = %llu\n",
708
			 htt_stats_buf->peer_dropped_count_low |
709
			 ((u64)htt_stats_buf->peer_dropped_count_high << 32));
710
	len += scnprintf(buf + len, buf_len - len, "transmitted_ppdu_bytes = %llu\n",
711
			 htt_stats_buf->ppdu_transmitted_bytes_low |
712
			 ((u64)htt_stats_buf->ppdu_transmitted_bytes_high << 32));
713
	len += scnprintf(buf + len, buf_len - len, "ttl_removed_count = %u\n",
714
			 htt_stats_buf->peer_ttl_removed_count);
715
	len += scnprintf(buf + len, buf_len - len, "inactive_time = %u\n\n",
716
			 htt_stats_buf->inactive_time);
717

718
	if (len >= buf_len)
719
		buf[buf_len - 1] = 0;
720
	else
721
		buf[len] = 0;
722

723
	stats_req->buf_len = len;
724
}
725

726
static inline void htt_print_peer_details_tlv(const void *tag_buf,
727
					      struct debug_htt_stats_req *stats_req)
728
{
729
	const struct htt_peer_details_tlv *htt_stats_buf = tag_buf;
730
	u8 *buf = stats_req->buf;
731
	u32 len = stats_req->buf_len;
732
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
733

734
	len += scnprintf(buf + len, buf_len - len, "HTT_PEER_DETAILS_TLV:\n");
735
	len += scnprintf(buf + len, buf_len - len, "peer_type = %u\n",
736
			 htt_stats_buf->peer_type);
737
	len += scnprintf(buf + len, buf_len - len, "sw_peer_id = %u\n",
738
			 htt_stats_buf->sw_peer_id);
739
	len += scnprintf(buf + len, buf_len - len, "vdev_id = %lu\n",
740
			 FIELD_GET(HTT_PEER_DETAILS_VDEV_ID,
741
				   htt_stats_buf->vdev_pdev_ast_idx));
742
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %lu\n",
743
			 FIELD_GET(HTT_PEER_DETAILS_PDEV_ID,
744
				   htt_stats_buf->vdev_pdev_ast_idx));
745
	len += scnprintf(buf + len, buf_len - len, "ast_idx = %lu\n",
746
			 FIELD_GET(HTT_PEER_DETAILS_AST_IDX,
747
				   htt_stats_buf->vdev_pdev_ast_idx));
748
	len += scnprintf(buf + len, buf_len - len,
749
			 "mac_addr = %02lx:%02lx:%02lx:%02lx:%02lx:%02lx\n",
750
			 FIELD_GET(HTT_MAC_ADDR_L32_0,
751
				   htt_stats_buf->mac_addr.mac_addr_l32),
752
			 FIELD_GET(HTT_MAC_ADDR_L32_1,
753
				   htt_stats_buf->mac_addr.mac_addr_l32),
754
			 FIELD_GET(HTT_MAC_ADDR_L32_2,
755
				   htt_stats_buf->mac_addr.mac_addr_l32),
756
			 FIELD_GET(HTT_MAC_ADDR_L32_3,
757
				   htt_stats_buf->mac_addr.mac_addr_l32),
758
			 FIELD_GET(HTT_MAC_ADDR_H16_0,
759
				   htt_stats_buf->mac_addr.mac_addr_h16),
760
			 FIELD_GET(HTT_MAC_ADDR_H16_1,
761
				   htt_stats_buf->mac_addr.mac_addr_h16));
762
	len += scnprintf(buf + len, buf_len - len, "peer_flags = 0x%x\n",
763
			 htt_stats_buf->peer_flags);
764
	len += scnprintf(buf + len, buf_len - len, "qpeer_flags = 0x%x\n\n",
765
			 htt_stats_buf->qpeer_flags);
766

767
	if (len >= buf_len)
768
		buf[buf_len - 1] = 0;
769
	else
770
		buf[len] = 0;
771

772
	stats_req->buf_len = len;
773
}
774

775
static inline void htt_print_tx_peer_rate_stats_tlv(const void *tag_buf,
776
						    struct debug_htt_stats_req *stats_req)
777
{
778
	const struct htt_tx_peer_rate_stats_tlv *htt_stats_buf = tag_buf;
779
	u8 *buf = stats_req->buf;
780
	u32 len = stats_req->buf_len;
781
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
782
	u8 j;
783

784
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PEER_RATE_STATS_TLV:\n");
785
	len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n",
786
			 htt_stats_buf->tx_ldpc);
787
	len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
788
			 htt_stats_buf->rts_cnt);
789
	len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n",
790
			 htt_stats_buf->ack_rssi);
791

792
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs, "tx_mcs",
793
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
794
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_su_mcs, "tx_su_mcs",
795
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
796
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mu_mcs, "tx_mu_mcs",
797
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
798
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss, "tx_nss",
799
			   HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
800
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw, "tx_bw",
801
			   HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
802
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc, "tx_stbc",
803
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
804
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream, "tx_pream",
805
			   HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");
806

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

814
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm, "tx_dcm",
815
			   HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\n");
816

817
	if (len >= buf_len)
818
		buf[buf_len - 1] = 0;
819
	else
820
		buf[len] = 0;
821

822
	stats_req->buf_len = len;
823
}
824

825
static inline void htt_print_rx_peer_rate_stats_tlv(const void *tag_buf,
826
						    struct debug_htt_stats_req *stats_req)
827
{
828
	const struct htt_rx_peer_rate_stats_tlv *htt_stats_buf = tag_buf;
829
	u8 *buf = stats_req->buf;
830
	u32 len = stats_req->buf_len;
831
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
832
	u8 j;
833

834
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PEER_RATE_STATS_TLV:\n");
835
	len += scnprintf(buf + len, buf_len - len, "nsts = %u\n",
836
			 htt_stats_buf->nsts);
837
	len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n",
838
			 htt_stats_buf->rx_ldpc);
839
	len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
840
			 htt_stats_buf->rts_cnt);
841
	len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n",
842
			 htt_stats_buf->rssi_mgmt);
843
	len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n",
844
			 htt_stats_buf->rssi_data);
845
	len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n",
846
			 htt_stats_buf->rssi_comb);
847

848
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs, "rx_mcs",
849
			   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
850
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss, "rx_nss",
851
			   HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
852
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm, "rx_dcm",
853
			   HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n");
854
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc, "rx_stbc",
855
			   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
856
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw, "rx_bw",
857
			   HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
858

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

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

873
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream, "rx_pream",
874
			   HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");
875

876
	if (len >= buf_len)
877
		buf[buf_len - 1] = 0;
878
	else
879
		buf[len] = 0;
880

881
	stats_req->buf_len = len;
882
}
883

884
static inline void
885
htt_print_tx_hwq_mu_mimo_sch_stats_tlv(const void *tag_buf,
886
				       struct debug_htt_stats_req *stats_req)
887
{
888
	const struct htt_tx_hwq_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf;
889
	u8 *buf = stats_req->buf;
890
	u32 len = stats_req->buf_len;
891
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
892

893
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_SCH_STATS_TLV:\n");
894
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
895
			 htt_stats_buf->mu_mimo_sch_posted);
896
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
897
			 htt_stats_buf->mu_mimo_sch_failed);
898
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n\n",
899
			 htt_stats_buf->mu_mimo_ppdu_posted);
900

901
	if (len >= buf_len)
902
		buf[buf_len - 1] = 0;
903
	else
904
		buf[len] = 0;
905

906
	stats_req->buf_len = len;
907
}
908

909
static inline void
910
htt_print_tx_hwq_mu_mimo_mpdu_stats_tlv(const void *tag_buf,
911
					struct debug_htt_stats_req *stats_req)
912
{
913
	const struct htt_tx_hwq_mu_mimo_mpdu_stats_tlv *htt_stats_buf = tag_buf;
914
	u8 *buf = stats_req->buf;
915
	u32 len = stats_req->buf_len;
916
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
917

918
	len += scnprintf(buf + len, buf_len - len,
919
			 "HTT_TX_HWQ_MU_MIMO_MPDU_STATS_TLV:\n");
920
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_queued_usr = %u\n",
921
			 htt_stats_buf->mu_mimo_mpdus_queued_usr);
922
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_tried_usr = %u\n",
923
			 htt_stats_buf->mu_mimo_mpdus_tried_usr);
924
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_failed_usr = %u\n",
925
			 htt_stats_buf->mu_mimo_mpdus_failed_usr);
926
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdus_requeued_usr = %u\n",
927
			 htt_stats_buf->mu_mimo_mpdus_requeued_usr);
928
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_err_no_ba_usr = %u\n",
929
			 htt_stats_buf->mu_mimo_err_no_ba_usr);
930
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_mpdu_underrun_usr = %u\n",
931
			 htt_stats_buf->mu_mimo_mpdu_underrun_usr);
932
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_ampdu_underrun_usr = %u\n\n",
933
			 htt_stats_buf->mu_mimo_ampdu_underrun_usr);
934

935
	if (len >= buf_len)
936
		buf[buf_len - 1] = 0;
937
	else
938
		buf[len] = 0;
939

940
	stats_req->buf_len = len;
941
}
942

943
static inline void
944
htt_print_tx_hwq_mu_mimo_cmn_stats_tlv(const void *tag_buf,
945
				       struct debug_htt_stats_req *stats_req)
946
{
947
	const struct htt_tx_hwq_mu_mimo_cmn_stats_tlv *htt_stats_buf = tag_buf;
948
	u8 *buf = stats_req->buf;
949
	u32 len = stats_req->buf_len;
950
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
951

952
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_MU_MIMO_CMN_STATS_TLV:\n");
953
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
954
			 FIELD_GET(HTT_TX_HWQ_STATS_MAC_ID,
955
				   htt_stats_buf->mac_id__hwq_id__word));
956
	len += scnprintf(buf + len, buf_len - len, "hwq_id = %lu\n\n",
957
			 FIELD_GET(HTT_TX_HWQ_STATS_HWQ_ID,
958
				   htt_stats_buf->mac_id__hwq_id__word));
959

960
	if (len >= buf_len)
961
		buf[buf_len - 1] = 0;
962
	else
963
		buf[len] = 0;
964

965
	stats_req->buf_len = len;
966
}
967

968
static inline void
969
htt_print_tx_hwq_stats_cmn_tlv(const void *tag_buf, struct debug_htt_stats_req *stats_req)
970
{
971
	const struct htt_tx_hwq_stats_cmn_tlv *htt_stats_buf = tag_buf;
972
	u8 *buf = stats_req->buf;
973
	u32 len = stats_req->buf_len;
974
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
975

976
	/* TODO: HKDBG */
977
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_STATS_CMN_TLV:\n");
978
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
979
			 FIELD_GET(HTT_TX_HWQ_STATS_MAC_ID,
980
				   htt_stats_buf->mac_id__hwq_id__word));
981
	len += scnprintf(buf + len, buf_len - len, "hwq_id = %lu\n",
982
			 FIELD_GET(HTT_TX_HWQ_STATS_HWQ_ID,
983
				   htt_stats_buf->mac_id__hwq_id__word));
984
	len += scnprintf(buf + len, buf_len - len, "xretry = %u\n",
985
			 htt_stats_buf->xretry);
986
	len += scnprintf(buf + len, buf_len - len, "underrun_cnt = %u\n",
987
			 htt_stats_buf->underrun_cnt);
988
	len += scnprintf(buf + len, buf_len - len, "flush_cnt = %u\n",
989
			 htt_stats_buf->flush_cnt);
990
	len += scnprintf(buf + len, buf_len - len, "filt_cnt = %u\n",
991
			 htt_stats_buf->filt_cnt);
992
	len += scnprintf(buf + len, buf_len - len, "null_mpdu_bmap = %u\n",
993
			 htt_stats_buf->null_mpdu_bmap);
994
	len += scnprintf(buf + len, buf_len - len, "user_ack_failure = %u\n",
995
			 htt_stats_buf->user_ack_failure);
996
	len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
997
			 htt_stats_buf->ack_tlv_proc);
998
	len += scnprintf(buf + len, buf_len - len, "sched_id_proc = %u\n",
999
			 htt_stats_buf->sched_id_proc);
1000
	len += scnprintf(buf + len, buf_len - len, "null_mpdu_tx_count = %u\n",
1001
			 htt_stats_buf->null_mpdu_tx_count);
1002
	len += scnprintf(buf + len, buf_len - len, "mpdu_bmap_not_recvd = %u\n",
1003
			 htt_stats_buf->mpdu_bmap_not_recvd);
1004
	len += scnprintf(buf + len, buf_len - len, "num_bar = %u\n",
1005
			 htt_stats_buf->num_bar);
1006
	len += scnprintf(buf + len, buf_len - len, "rts = %u\n",
1007
			 htt_stats_buf->rts);
1008
	len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n",
1009
			 htt_stats_buf->cts2self);
1010
	len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n",
1011
			 htt_stats_buf->qos_null);
1012
	len += scnprintf(buf + len, buf_len - len, "mpdu_tried_cnt = %u\n",
1013
			 htt_stats_buf->mpdu_tried_cnt);
1014
	len += scnprintf(buf + len, buf_len - len, "mpdu_queued_cnt = %u\n",
1015
			 htt_stats_buf->mpdu_queued_cnt);
1016
	len += scnprintf(buf + len, buf_len - len, "mpdu_ack_fail_cnt = %u\n",
1017
			 htt_stats_buf->mpdu_ack_fail_cnt);
1018
	len += scnprintf(buf + len, buf_len - len, "mpdu_filt_cnt = %u\n",
1019
			 htt_stats_buf->mpdu_filt_cnt);
1020
	len += scnprintf(buf + len, buf_len - len, "false_mpdu_ack_count = %u\n",
1021
			 htt_stats_buf->false_mpdu_ack_count);
1022
	len += scnprintf(buf + len, buf_len - len, "txq_timeout = %u\n\n",
1023
			 htt_stats_buf->txq_timeout);
1024

1025
	if (len >= buf_len)
1026
		buf[buf_len - 1] = 0;
1027
	else
1028
		buf[len] = 0;
1029

1030
	stats_req->buf_len = len;
1031
}
1032

1033
static inline void
1034
htt_print_tx_hwq_difs_latency_stats_tlv_v(const void *tag_buf,
1035
					  u16 tag_len,
1036
					  struct debug_htt_stats_req *stats_req)
1037
{
1038
	const struct htt_tx_hwq_difs_latency_stats_tlv_v *htt_stats_buf = tag_buf;
1039
	u8 *buf = stats_req->buf;
1040
	u32 len = stats_req->buf_len;
1041
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1042
	u16 data_len = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_DIFS_LATENCY_BINS);
1043

1044
	len += scnprintf(buf + len, buf_len - len,
1045
			 "HTT_TX_HWQ_DIFS_LATENCY_STATS_TLV_V:\n");
1046
	len += scnprintf(buf + len, buf_len - len, "hist_intvl = %u\n",
1047
			 htt_stats_buf->hist_intvl);
1048

1049
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->difs_latency_hist,
1050
			   "difs_latency_hist", data_len, "\n\n");
1051

1052
	if (len >= buf_len)
1053
		buf[buf_len - 1] = 0;
1054
	else
1055
		buf[len] = 0;
1056

1057
	stats_req->buf_len = len;
1058
}
1059

1060
static inline void
1061
htt_print_tx_hwq_cmd_result_stats_tlv_v(const void *tag_buf,
1062
					u16 tag_len,
1063
					struct debug_htt_stats_req *stats_req)
1064
{
1065
	const struct htt_tx_hwq_cmd_result_stats_tlv_v *htt_stats_buf = tag_buf;
1066
	u8 *buf = stats_req->buf;
1067
	u32 len = stats_req->buf_len;
1068
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1069
	u16 data_len;
1070

1071
	data_len = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_CMD_RESULT_STATS);
1072

1073
	len += scnprintf(buf + len, buf_len - len,
1074
			 "HTT_TX_HWQ_CMD_RESULT_STATS_TLV_V:\n");
1075

1076
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_result, "cmd_result",
1077
			   data_len, "\n\n");
1078

1079
	if (len >= buf_len)
1080
		buf[buf_len - 1] = 0;
1081
	else
1082
		buf[len] = 0;
1083

1084
	stats_req->buf_len = len;
1085
}
1086

1087
static inline void
1088
htt_print_tx_hwq_cmd_stall_stats_tlv_v(const void *tag_buf,
1089
				       u16 tag_len,
1090
				       struct debug_htt_stats_req *stats_req)
1091
{
1092
	const struct htt_tx_hwq_cmd_stall_stats_tlv_v *htt_stats_buf = tag_buf;
1093
	u8 *buf = stats_req->buf;
1094
	u32 len = stats_req->buf_len;
1095
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1096
	u16 num_elems;
1097

1098
	num_elems = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_CMD_STALL_STATS);
1099

1100
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_CMD_STALL_STATS_TLV_V:\n");
1101

1102
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->cmd_stall_status,
1103
			   "cmd_stall_status", num_elems, "\n\n");
1104

1105
	if (len >= buf_len)
1106
		buf[buf_len - 1] = 0;
1107
	else
1108
		buf[len] = 0;
1109

1110
	stats_req->buf_len = len;
1111
}
1112

1113
static inline void
1114
htt_print_tx_hwq_fes_result_stats_tlv_v(const void *tag_buf,
1115
					u16 tag_len,
1116
					struct debug_htt_stats_req *stats_req)
1117
{
1118
	const struct htt_tx_hwq_fes_result_stats_tlv_v *htt_stats_buf = tag_buf;
1119
	u8 *buf = stats_req->buf;
1120
	u32 len = stats_req->buf_len;
1121
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1122
	u16 num_elems;
1123

1124
	num_elems = min_t(u16, (tag_len >> 2), HTT_TX_HWQ_MAX_FES_RESULT_STATS);
1125

1126
	len += scnprintf(buf + len, buf_len - len,
1127
			 "HTT_TX_HWQ_FES_RESULT_STATS_TLV_V:\n");
1128

1129
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fes_result, "fes_result",
1130
			   num_elems, "\n\n");
1131

1132
	if (len >= buf_len)
1133
		buf[buf_len - 1] = 0;
1134
	else
1135
		buf[len] = 0;
1136

1137
	stats_req->buf_len = len;
1138
}
1139

1140
static inline void
1141
htt_print_tx_hwq_tried_mpdu_cnt_hist_tlv_v(const void *tag_buf,
1142
					   u16 tag_len,
1143
					   struct debug_htt_stats_req *stats_req)
1144
{
1145
	const struct htt_tx_hwq_tried_mpdu_cnt_hist_tlv_v *htt_stats_buf = tag_buf;
1146
	u8 *buf = stats_req->buf;
1147
	u32 len = stats_req->buf_len;
1148
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1149
	u32  num_elements = ((tag_len -
1150
			    sizeof(htt_stats_buf->hist_bin_size)) >> 2);
1151

1152
	len += scnprintf(buf + len, buf_len - len,
1153
			 "HTT_TX_HWQ_TRIED_MPDU_CNT_HIST_TLV_V:\n");
1154
	len += scnprintf(buf + len, buf_len - len, "TRIED_MPDU_CNT_HIST_BIN_SIZE : %u\n",
1155
			 htt_stats_buf->hist_bin_size);
1156

1157
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tried_mpdu_cnt_hist,
1158
			   "tried_mpdu_cnt_hist", num_elements, "\n\n");
1159

1160
	if (len >= buf_len)
1161
		buf[buf_len - 1] = 0;
1162
	else
1163
		buf[len] = 0;
1164

1165
	stats_req->buf_len = len;
1166
}
1167

1168
static inline void
1169
htt_print_tx_hwq_txop_used_cnt_hist_tlv_v(const void *tag_buf,
1170
					  u16 tag_len,
1171
					  struct debug_htt_stats_req *stats_req)
1172
{
1173
	const struct htt_tx_hwq_txop_used_cnt_hist_tlv_v *htt_stats_buf = tag_buf;
1174
	u8 *buf = stats_req->buf;
1175
	u32 len = stats_req->buf_len;
1176
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1177
	u32 num_elements = tag_len >> 2;
1178

1179
	len += scnprintf(buf + len, buf_len - len,
1180
			 "HTT_TX_HWQ_TXOP_USED_CNT_HIST_TLV_V:\n");
1181

1182
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->txop_used_cnt_hist,
1183
			   "txop_used_cnt_hist", num_elements, "\n\n");
1184

1185
	if (len >= buf_len)
1186
		buf[buf_len - 1] = 0;
1187
	else
1188
		buf[len] = 0;
1189

1190
	stats_req->buf_len = len;
1191
}
1192

1193
static inline void htt_print_tx_sounding_stats_tlv(const void *tag_buf,
1194
						   struct debug_htt_stats_req *stats_req)
1195
{
1196
	s32 i;
1197
	const struct htt_tx_sounding_stats_tlv *htt_stats_buf = tag_buf;
1198
	u8 *buf = stats_req->buf;
1199
	u32 len = stats_req->buf_len;
1200
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1201
	const u32 *cbf_20 = htt_stats_buf->cbf_20;
1202
	const u32 *cbf_40 = htt_stats_buf->cbf_40;
1203
	const u32 *cbf_80 = htt_stats_buf->cbf_80;
1204
	const u32 *cbf_160 = htt_stats_buf->cbf_160;
1205

1206
	if (htt_stats_buf->tx_sounding_mode == HTT_TX_AC_SOUNDING_MODE) {
1207
		len += scnprintf(buf + len, buf_len - len,
1208
				 "\nHTT_TX_AC_SOUNDING_STATS_TLV:\n\n");
1209
		len += scnprintf(buf + len, buf_len - len,
1210
				 "ac_cbf_20 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1211
				 cbf_20[HTT_IMPLICIT_TXBF_STEER_STATS],
1212
				 cbf_20[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1213
				 cbf_20[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1214
				 cbf_20[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1215
				 cbf_20[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1216
		len += scnprintf(buf + len, buf_len - len,
1217
				 "ac_cbf_40 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1218
				 cbf_40[HTT_IMPLICIT_TXBF_STEER_STATS],
1219
				 cbf_40[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1220
				 cbf_40[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1221
				 cbf_40[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1222
				 cbf_40[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1223
		len += scnprintf(buf + len, buf_len - len,
1224
				 "ac_cbf_80 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1225
				 cbf_80[HTT_IMPLICIT_TXBF_STEER_STATS],
1226
				 cbf_80[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1227
				 cbf_80[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1228
				 cbf_80[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1229
				 cbf_80[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1230
		len += scnprintf(buf + len, buf_len - len,
1231
				 "ac_cbf_160 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1232
				 cbf_160[HTT_IMPLICIT_TXBF_STEER_STATS],
1233
				 cbf_160[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1234
				 cbf_160[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1235
				 cbf_160[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1236
				 cbf_160[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1237

1238
		for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++) {
1239
			len += scnprintf(buf + len, buf_len - len,
1240
					 "Sounding User %u = 20MHz: %u, 40MHz : %u, 80MHz: %u, 160MHz: %u\n",
1241
					 i,
1242
					 htt_stats_buf->sounding[0],
1243
					 htt_stats_buf->sounding[1],
1244
					 htt_stats_buf->sounding[2],
1245
					 htt_stats_buf->sounding[3]);
1246
		}
1247
	} else if (htt_stats_buf->tx_sounding_mode == HTT_TX_AX_SOUNDING_MODE) {
1248
		len += scnprintf(buf + len, buf_len - len,
1249
				 "\nHTT_TX_AX_SOUNDING_STATS_TLV:\n");
1250
		len += scnprintf(buf + len, buf_len - len,
1251
				 "ax_cbf_20 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1252
				 cbf_20[HTT_IMPLICIT_TXBF_STEER_STATS],
1253
				 cbf_20[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1254
				 cbf_20[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1255
				 cbf_20[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1256
				 cbf_20[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1257
		len += scnprintf(buf + len, buf_len - len,
1258
				 "ax_cbf_40 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1259
				 cbf_40[HTT_IMPLICIT_TXBF_STEER_STATS],
1260
				 cbf_40[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1261
				 cbf_40[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1262
				 cbf_40[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1263
				 cbf_40[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1264
		len += scnprintf(buf + len, buf_len - len,
1265
				 "ax_cbf_80 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1266
				 cbf_80[HTT_IMPLICIT_TXBF_STEER_STATS],
1267
				 cbf_80[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1268
				 cbf_80[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1269
				 cbf_80[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1270
				 cbf_80[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1271
		len += scnprintf(buf + len, buf_len - len,
1272
				 "ax_cbf_160 = IBF : %u, SU_SIFS : %u, SU_RBO : %u, MU_SIFS : %u, MU_RBO : %u\n",
1273
				 cbf_160[HTT_IMPLICIT_TXBF_STEER_STATS],
1274
				 cbf_160[HTT_EXPLICIT_TXBF_SU_SIFS_STEER_STATS],
1275
				 cbf_160[HTT_EXPLICIT_TXBF_SU_RBO_STEER_STATS],
1276
				 cbf_160[HTT_EXPLICIT_TXBF_MU_SIFS_STEER_STATS],
1277
				 cbf_160[HTT_EXPLICIT_TXBF_MU_RBO_STEER_STATS]);
1278

1279
		for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++) {
1280
			len += scnprintf(buf + len, buf_len - len,
1281
					 "Sounding User %u = 20MHz: %u, 40MHz : %u, 80MHz: %u, 160MHz: %u\n",
1282
					 i,
1283
					 htt_stats_buf->sounding[0],
1284
					 htt_stats_buf->sounding[1],
1285
					 htt_stats_buf->sounding[2],
1286
					 htt_stats_buf->sounding[3]);
1287
		}
1288
	}
1289

1290
	if (len >= buf_len)
1291
		buf[buf_len - 1] = 0;
1292
	else
1293
		buf[len] = 0;
1294

1295
	stats_req->buf_len = len;
1296
}
1297

1298
static inline void
1299
htt_print_tx_selfgen_cmn_stats_tlv(const void *tag_buf,
1300
				   struct debug_htt_stats_req *stats_req)
1301
{
1302
	const struct htt_tx_selfgen_cmn_stats_tlv *htt_stats_buf = tag_buf;
1303
	u8 *buf = stats_req->buf;
1304
	u32 len = stats_req->buf_len;
1305
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1306

1307
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_CMN_STATS_TLV:\n");
1308
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
1309
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
1310
	len += scnprintf(buf + len, buf_len - len, "su_bar = %u\n",
1311
			 htt_stats_buf->su_bar);
1312
	len += scnprintf(buf + len, buf_len - len, "rts = %u\n",
1313
			 htt_stats_buf->rts);
1314
	len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n",
1315
			 htt_stats_buf->cts2self);
1316
	len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n",
1317
			 htt_stats_buf->qos_null);
1318
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_1 = %u\n",
1319
			 htt_stats_buf->delayed_bar_1);
1320
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_2 = %u\n",
1321
			 htt_stats_buf->delayed_bar_2);
1322
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_3 = %u\n",
1323
			 htt_stats_buf->delayed_bar_3);
1324
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_4 = %u\n",
1325
			 htt_stats_buf->delayed_bar_4);
1326
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_5 = %u\n",
1327
			 htt_stats_buf->delayed_bar_5);
1328
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_6 = %u\n",
1329
			 htt_stats_buf->delayed_bar_6);
1330
	len += scnprintf(buf + len, buf_len - len, "delayed_bar_7 = %u\n\n",
1331
			 htt_stats_buf->delayed_bar_7);
1332

1333
	if (len >= buf_len)
1334
		buf[buf_len - 1] = 0;
1335
	else
1336
		buf[len] = 0;
1337

1338
	stats_req->buf_len = len;
1339
}
1340

1341
static inline void
1342
htt_print_tx_selfgen_ac_stats_tlv(const void *tag_buf,
1343
				  struct debug_htt_stats_req *stats_req)
1344
{
1345
	const struct htt_tx_selfgen_ac_stats_tlv *htt_stats_buf = tag_buf;
1346
	u8 *buf = stats_req->buf;
1347
	u32 len = stats_req->buf_len;
1348
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1349

1350
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_STATS_TLV:\n");
1351
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa = %u\n",
1352
			 htt_stats_buf->ac_su_ndpa);
1353
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndp = %u\n",
1354
			 htt_stats_buf->ac_su_ndp);
1355
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa = %u\n",
1356
			 htt_stats_buf->ac_mu_mimo_ndpa);
1357
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp = %u\n",
1358
			 htt_stats_buf->ac_mu_mimo_ndp);
1359
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_1 = %u\n",
1360
			 htt_stats_buf->ac_mu_mimo_brpoll_1);
1361
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_2 = %u\n",
1362
			 htt_stats_buf->ac_mu_mimo_brpoll_2);
1363
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brpoll_3 = %u\n\n",
1364
			 htt_stats_buf->ac_mu_mimo_brpoll_3);
1365

1366
	if (len >= buf_len)
1367
		buf[buf_len - 1] = 0;
1368
	else
1369
		buf[len] = 0;
1370

1371
	stats_req->buf_len = len;
1372
}
1373

1374
static inline void
1375
htt_print_tx_selfgen_ax_stats_tlv(const void *tag_buf,
1376
				  struct debug_htt_stats_req *stats_req)
1377
{
1378
	const struct htt_tx_selfgen_ax_stats_tlv *htt_stats_buf = tag_buf;
1379
	u8 *buf = stats_req->buf;
1380
	u32 len = stats_req->buf_len;
1381
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1382

1383
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_STATS_TLV:\n");
1384
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa = %u\n",
1385
			 htt_stats_buf->ax_su_ndpa);
1386
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndp = %u\n",
1387
			 htt_stats_buf->ax_su_ndp);
1388
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa = %u\n",
1389
			 htt_stats_buf->ax_mu_mimo_ndpa);
1390
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp = %u\n",
1391
			 htt_stats_buf->ax_mu_mimo_ndp);
1392
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_1 = %u\n",
1393
			 htt_stats_buf->ax_mu_mimo_brpoll_1);
1394
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_2 = %u\n",
1395
			 htt_stats_buf->ax_mu_mimo_brpoll_2);
1396
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_3 = %u\n",
1397
			 htt_stats_buf->ax_mu_mimo_brpoll_3);
1398
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_4 = %u\n",
1399
			 htt_stats_buf->ax_mu_mimo_brpoll_4);
1400
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_5 = %u\n",
1401
			 htt_stats_buf->ax_mu_mimo_brpoll_5);
1402
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_6 = %u\n",
1403
			 htt_stats_buf->ax_mu_mimo_brpoll_6);
1404
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brpoll_7 = %u\n",
1405
			 htt_stats_buf->ax_mu_mimo_brpoll_7);
1406
	len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger = %u\n",
1407
			 htt_stats_buf->ax_basic_trigger);
1408
	len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_trigger = %u\n",
1409
			 htt_stats_buf->ax_ulmumimo_trigger);
1410
	len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger = %u\n",
1411
			 htt_stats_buf->ax_bsr_trigger);
1412
	len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger = %u\n",
1413
			 htt_stats_buf->ax_mu_bar_trigger);
1414
	len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger = %u\n\n",
1415
			 htt_stats_buf->ax_mu_rts_trigger);
1416

1417
	if (len >= buf_len)
1418
		buf[buf_len - 1] = 0;
1419
	else
1420
		buf[len] = 0;
1421

1422
	stats_req->buf_len = len;
1423
}
1424

1425
static inline void
1426
htt_print_tx_selfgen_ac_err_stats_tlv(const void *tag_buf,
1427
				      struct debug_htt_stats_req *stats_req)
1428
{
1429
	const struct htt_tx_selfgen_ac_err_stats_tlv *htt_stats_buf = tag_buf;
1430
	u8 *buf = stats_req->buf;
1431
	u32 len = stats_req->buf_len;
1432
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1433

1434
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AC_ERR_STATS_TLV:\n");
1435
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndp_err = %u\n",
1436
			 htt_stats_buf->ac_su_ndp_err);
1437
	len += scnprintf(buf + len, buf_len - len, "ac_su_ndpa_err = %u\n",
1438
			 htt_stats_buf->ac_su_ndpa_err);
1439
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndpa_err = %u\n",
1440
			 htt_stats_buf->ac_mu_mimo_ndpa_err);
1441
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_ndp_err = %u\n",
1442
			 htt_stats_buf->ac_mu_mimo_ndp_err);
1443
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp1_err = %u\n",
1444
			 htt_stats_buf->ac_mu_mimo_brp1_err);
1445
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp2_err = %u\n",
1446
			 htt_stats_buf->ac_mu_mimo_brp2_err);
1447
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_brp3_err = %u\n\n",
1448
			 htt_stats_buf->ac_mu_mimo_brp3_err);
1449

1450
	if (len >= buf_len)
1451
		buf[buf_len - 1] = 0;
1452
	else
1453
		buf[len] = 0;
1454

1455
	stats_req->buf_len = len;
1456
}
1457

1458
static inline void
1459
htt_print_tx_selfgen_ax_err_stats_tlv(const void *tag_buf,
1460
				      struct debug_htt_stats_req *stats_req)
1461
{
1462
	const struct htt_tx_selfgen_ax_err_stats_tlv *htt_stats_buf = tag_buf;
1463
	u8 *buf = stats_req->buf;
1464
	u32 len = stats_req->buf_len;
1465
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1466

1467
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_SELFGEN_AX_ERR_STATS_TLV:\n");
1468
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndp_err = %u\n",
1469
			 htt_stats_buf->ax_su_ndp_err);
1470
	len += scnprintf(buf + len, buf_len - len, "ax_su_ndpa_err = %u\n",
1471
			 htt_stats_buf->ax_su_ndpa_err);
1472
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndpa_err = %u\n",
1473
			 htt_stats_buf->ax_mu_mimo_ndpa_err);
1474
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_ndp_err = %u\n",
1475
			 htt_stats_buf->ax_mu_mimo_ndp_err);
1476
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp1_err = %u\n",
1477
			 htt_stats_buf->ax_mu_mimo_brp1_err);
1478
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp2_err = %u\n",
1479
			 htt_stats_buf->ax_mu_mimo_brp2_err);
1480
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp3_err = %u\n",
1481
			 htt_stats_buf->ax_mu_mimo_brp3_err);
1482
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp4_err = %u\n",
1483
			 htt_stats_buf->ax_mu_mimo_brp4_err);
1484
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp5_err = %u\n",
1485
			 htt_stats_buf->ax_mu_mimo_brp5_err);
1486
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp6_err = %u\n",
1487
			 htt_stats_buf->ax_mu_mimo_brp6_err);
1488
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_brp7_err = %u\n",
1489
			 htt_stats_buf->ax_mu_mimo_brp7_err);
1490
	len += scnprintf(buf + len, buf_len - len, "ax_basic_trigger_err = %u\n",
1491
			 htt_stats_buf->ax_basic_trigger_err);
1492
	len += scnprintf(buf + len, buf_len - len, "ax_ulmumimo_trigger_err = %u\n",
1493
			 htt_stats_buf->ax_ulmumimo_trigger_err);
1494
	len += scnprintf(buf + len, buf_len - len, "ax_bsr_trigger_err = %u\n",
1495
			 htt_stats_buf->ax_bsr_trigger_err);
1496
	len += scnprintf(buf + len, buf_len - len, "ax_mu_bar_trigger_err = %u\n",
1497
			 htt_stats_buf->ax_mu_bar_trigger_err);
1498
	len += scnprintf(buf + len, buf_len - len, "ax_mu_rts_trigger_err = %u\n\n",
1499
			 htt_stats_buf->ax_mu_rts_trigger_err);
1500

1501
	if (len >= buf_len)
1502
		buf[buf_len - 1] = 0;
1503
	else
1504
		buf[len] = 0;
1505

1506
	stats_req->buf_len = len;
1507
}
1508

1509
static inline void
1510
htt_print_tx_pdev_mu_mimo_sch_stats_tlv(const void *tag_buf,
1511
					struct debug_htt_stats_req *stats_req)
1512
{
1513
	const struct htt_tx_pdev_mu_mimo_sch_stats_tlv *htt_stats_buf = tag_buf;
1514
	u8 *buf = stats_req->buf;
1515
	u32 len = stats_req->buf_len;
1516
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1517
	u8 i;
1518

1519
	len += scnprintf(buf + len, buf_len - len,
1520
			 "HTT_TX_PDEV_MU_MIMO_SCH_STATS_TLV:\n");
1521
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_posted = %u\n",
1522
			 htt_stats_buf->mu_mimo_sch_posted);
1523
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_sch_failed = %u\n",
1524
			 htt_stats_buf->mu_mimo_sch_failed);
1525
	len += scnprintf(buf + len, buf_len - len, "mu_mimo_ppdu_posted = %u\n\n",
1526
			 htt_stats_buf->mu_mimo_ppdu_posted);
1527

1528
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++)
1529
		len += scnprintf(buf + len, buf_len - len,
1530
				 "ac_mu_mimo_sch_posted_per_group_index %u = %u\n",
1531
				 i, htt_stats_buf->ac_mu_mimo_sch_posted_per_grp_sz[i]);
1532

1533
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++)
1534
		len += scnprintf(buf + len, buf_len - len,
1535
				 "ax_mu_mimo_sch_posted_per_group_index %u = %u\n",
1536
				 i, htt_stats_buf->ax_mu_mimo_sch_posted_per_grp_sz[i]);
1537

1538
	len += scnprintf(buf + len, buf_len - len, "11ac MU_MIMO SCH STATS:\n");
1539

1540
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS; i++)
1541
		len += scnprintf(buf + len, buf_len - len,
1542
				 "ac_mu_mimo_sch_nusers_%u = %u\n",
1543
				 i, htt_stats_buf->ac_mu_mimo_sch_nusers[i]);
1544

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

1547
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS; i++)
1548
		len += scnprintf(buf + len, buf_len - len,
1549
				 "ax_mu_mimo_sch_nusers_%u = %u\n",
1550
				 i, htt_stats_buf->ax_mu_mimo_sch_nusers[i]);
1551

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

1554
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
1555
		len += scnprintf(buf + len, buf_len - len,
1556
				 "ax_ofdma_sch_nusers_%u = %u\n",
1557
				 i, htt_stats_buf->ax_ofdma_sch_nusers[i]);
1558
		len += scnprintf(buf + len, buf_len - len,
1559
				 "ax_ul_ofdma_basic_sch_nusers_%u = %u\n",
1560
				 i, htt_stats_buf->ax_ul_ofdma_basic_sch_nusers[i]);
1561
		len += scnprintf(buf + len, buf_len - len,
1562
				 "ax_ul_ofdma_bsr_sch_nusers_%u = %u\n",
1563
				 i, htt_stats_buf->ax_ul_ofdma_bsr_sch_nusers[i]);
1564
		len += scnprintf(buf + len, buf_len - len,
1565
				 "ax_ul_ofdma_sch_bar_nusers_%u = %u\n",
1566
				 i, htt_stats_buf->ax_ul_ofdma_bar_sch_nusers[i]);
1567
		len += scnprintf(buf + len, buf_len - len,
1568
				 "ax_ul_ofdma_brp_sch_nusers_%u = %u\n",
1569
				 i, htt_stats_buf->ax_ul_ofdma_brp_sch_nusers[i]);
1570
	}
1571

1572
	len += scnprintf(buf + len, buf_len - len, "\n11ax UL MUMIO SCH STATS:\n");
1573

1574
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_UL_MUMIMO_USER_STATS; i++) {
1575
		len += scnprintf(buf + len, buf_len - len,
1576
				 "ax_ul_mumimo_basic_sch_nusers_%u = %u\n",
1577
				 i, htt_stats_buf->ax_ul_mumimo_basic_sch_nusers[i]);
1578
		len += scnprintf(buf + len, buf_len - len,
1579
				 "ax_ul_mumimo_brp_sch_nusers_%u = %u\n",
1580
				 i, htt_stats_buf->ax_ul_mumimo_brp_sch_nusers[i]);
1581
	}
1582

1583
	if (len >= buf_len)
1584
		buf[buf_len - 1] = 0;
1585
	else
1586
		buf[len] = 0;
1587

1588
	stats_req->buf_len = len;
1589
}
1590

1591
static inline void
1592
htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(const void *tag_buf,
1593
					 struct debug_htt_stats_req *stats_req)
1594
{
1595
	const struct htt_tx_pdev_mpdu_stats_tlv *htt_stats_buf = tag_buf;
1596
	u8 *buf = stats_req->buf;
1597
	u32 len = stats_req->buf_len;
1598
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1599

1600
	if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_MIMO_AC) {
1601
		if (!htt_stats_buf->user_index)
1602
			len += scnprintf(buf + len, buf_len - len,
1603
					 "HTT_TX_PDEV_MU_MIMO_AC_MPDU_STATS:\n");
1604

1605
		if (htt_stats_buf->user_index <
1606
		    HTT_TX_PDEV_STATS_NUM_AC_MUMIMO_USER_STATS) {
1607
			len += scnprintf(buf + len, buf_len - len,
1608
					 "ac_mu_mimo_mpdus_queued_usr_%u = %u\n",
1609
					 htt_stats_buf->user_index,
1610
					 htt_stats_buf->mpdus_queued_usr);
1611
			len += scnprintf(buf + len, buf_len - len,
1612
					 "ac_mu_mimo_mpdus_tried_usr_%u = %u\n",
1613
					 htt_stats_buf->user_index,
1614
					 htt_stats_buf->mpdus_tried_usr);
1615
			len += scnprintf(buf + len, buf_len - len,
1616
					 "ac_mu_mimo_mpdus_failed_usr_%u = %u\n",
1617
					 htt_stats_buf->user_index,
1618
					 htt_stats_buf->mpdus_failed_usr);
1619
			len += scnprintf(buf + len, buf_len - len,
1620
					 "ac_mu_mimo_mpdus_requeued_usr_%u = %u\n",
1621
					 htt_stats_buf->user_index,
1622
					 htt_stats_buf->mpdus_requeued_usr);
1623
			len += scnprintf(buf + len, buf_len - len,
1624
					 "ac_mu_mimo_err_no_ba_usr_%u = %u\n",
1625
					 htt_stats_buf->user_index,
1626
					 htt_stats_buf->err_no_ba_usr);
1627
			len += scnprintf(buf + len, buf_len - len,
1628
					 "ac_mu_mimo_mpdu_underrun_usr_%u = %u\n",
1629
					 htt_stats_buf->user_index,
1630
					 htt_stats_buf->mpdu_underrun_usr);
1631
			len += scnprintf(buf + len, buf_len - len,
1632
					 "ac_mu_mimo_ampdu_underrun_usr_%u = %u\n\n",
1633
					 htt_stats_buf->user_index,
1634
					 htt_stats_buf->ampdu_underrun_usr);
1635
		}
1636
	}
1637

1638
	if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_MIMO_AX) {
1639
		if (!htt_stats_buf->user_index)
1640
			len += scnprintf(buf + len, buf_len - len,
1641
					 "HTT_TX_PDEV_MU_MIMO_AX_MPDU_STATS:\n");
1642

1643
		if (htt_stats_buf->user_index <
1644
		    HTT_TX_PDEV_STATS_NUM_AX_MUMIMO_USER_STATS) {
1645
			len += scnprintf(buf + len, buf_len - len,
1646
					 "ax_mu_mimo_mpdus_queued_usr_%u = %u\n",
1647
					 htt_stats_buf->user_index,
1648
					 htt_stats_buf->mpdus_queued_usr);
1649
			len += scnprintf(buf + len, buf_len - len,
1650
					 "ax_mu_mimo_mpdus_tried_usr_%u = %u\n",
1651
					 htt_stats_buf->user_index,
1652
					 htt_stats_buf->mpdus_tried_usr);
1653
			len += scnprintf(buf + len, buf_len - len,
1654
					 "ax_mu_mimo_mpdus_failed_usr_%u = %u\n",
1655
					 htt_stats_buf->user_index,
1656
					 htt_stats_buf->mpdus_failed_usr);
1657
			len += scnprintf(buf + len, buf_len - len,
1658
					 "ax_mu_mimo_mpdus_requeued_usr_%u = %u\n",
1659
					 htt_stats_buf->user_index,
1660
					 htt_stats_buf->mpdus_requeued_usr);
1661
			len += scnprintf(buf + len, buf_len - len,
1662
					 "ax_mu_mimo_err_no_ba_usr_%u = %u\n",
1663
					 htt_stats_buf->user_index,
1664
					 htt_stats_buf->err_no_ba_usr);
1665
			len += scnprintf(buf + len, buf_len - len,
1666
					 "ax_mu_mimo_mpdu_underrun_usr_%u = %u\n",
1667
					 htt_stats_buf->user_index,
1668
					 htt_stats_buf->mpdu_underrun_usr);
1669
			len += scnprintf(buf + len, buf_len - len,
1670
					 "ax_mu_mimo_ampdu_underrun_usr_%u = %u\n\n",
1671
					 htt_stats_buf->user_index,
1672
					 htt_stats_buf->ampdu_underrun_usr);
1673
		}
1674
	}
1675

1676
	if (htt_stats_buf->tx_sched_mode == HTT_STATS_TX_SCHED_MODE_MU_OFDMA_AX) {
1677
		if (!htt_stats_buf->user_index)
1678
			len += scnprintf(buf + len, buf_len - len,
1679
					 "HTT_TX_PDEV_AX_MU_OFDMA_MPDU_STATS:\n");
1680

1681
		if (htt_stats_buf->user_index < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS) {
1682
			len += scnprintf(buf + len, buf_len - len,
1683
					 "ax_mu_ofdma_mpdus_queued_usr_%u = %u\n",
1684
					 htt_stats_buf->user_index,
1685
					 htt_stats_buf->mpdus_queued_usr);
1686
			len += scnprintf(buf + len, buf_len - len,
1687
					 "ax_mu_ofdma_mpdus_tried_usr_%u = %u\n",
1688
					 htt_stats_buf->user_index,
1689
					 htt_stats_buf->mpdus_tried_usr);
1690
			len += scnprintf(buf + len, buf_len - len,
1691
					 "ax_mu_ofdma_mpdus_failed_usr_%u = %u\n",
1692
					 htt_stats_buf->user_index,
1693
					 htt_stats_buf->mpdus_failed_usr);
1694
			len += scnprintf(buf + len, buf_len - len,
1695
					 "ax_mu_ofdma_mpdus_requeued_usr_%u = %u\n",
1696
					 htt_stats_buf->user_index,
1697
					 htt_stats_buf->mpdus_requeued_usr);
1698
			len += scnprintf(buf + len, buf_len - len,
1699
					 "ax_mu_ofdma_err_no_ba_usr_%u = %u\n",
1700
					 htt_stats_buf->user_index,
1701
					 htt_stats_buf->err_no_ba_usr);
1702
			len += scnprintf(buf + len, buf_len - len,
1703
					 "ax_mu_ofdma_mpdu_underrun_usr_%u = %u\n",
1704
					 htt_stats_buf->user_index,
1705
					 htt_stats_buf->mpdu_underrun_usr);
1706
			len += scnprintf(buf + len, buf_len - len,
1707
					 "ax_mu_ofdma_ampdu_underrun_usr_%u = %u\n\n",
1708
					 htt_stats_buf->user_index,
1709
					 htt_stats_buf->ampdu_underrun_usr);
1710
		}
1711
	}
1712

1713
	if (len >= buf_len)
1714
		buf[buf_len - 1] = 0;
1715
	else
1716
		buf[len] = 0;
1717

1718
	stats_req->buf_len = len;
1719
}
1720

1721
static inline void
1722
htt_print_sched_txq_cmd_posted_tlv_v(const void *tag_buf,
1723
				     u16 tag_len,
1724
				     struct debug_htt_stats_req *stats_req)
1725
{
1726
	const struct htt_sched_txq_cmd_posted_tlv_v *htt_stats_buf = tag_buf;
1727
	u8 *buf = stats_req->buf;
1728
	u32 len = stats_req->buf_len;
1729
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1730
	u16 num_elements = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_SCHED_TX_MODE_MAX);
1731

1732
	len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_POSTED_TLV_V:\n");
1733

1734
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_cmd_posted,
1735
			   "sched_cmd_posted", num_elements, "\n\n");
1736

1737
	if (len >= buf_len)
1738
		buf[buf_len - 1] = 0;
1739
	else
1740
		buf[len] = 0;
1741

1742
	stats_req->buf_len = len;
1743
}
1744

1745
static inline void
1746
htt_print_sched_txq_cmd_reaped_tlv_v(const void *tag_buf,
1747
				     u16 tag_len,
1748
				     struct debug_htt_stats_req *stats_req)
1749
{
1750
	const struct htt_sched_txq_cmd_reaped_tlv_v *htt_stats_buf = tag_buf;
1751
	u8 *buf = stats_req->buf;
1752
	u32 len = stats_req->buf_len;
1753
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1754
	u16 num_elements = min_t(u16, (tag_len >> 2), HTT_TX_PDEV_SCHED_TX_MODE_MAX);
1755

1756
	len += scnprintf(buf + len, buf_len - len, "HTT_SCHED_TXQ_CMD_REAPED_TLV_V:\n");
1757

1758
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_cmd_reaped,
1759
			   "sched_cmd_reaped", num_elements, "\n\n");
1760

1761
	if (len >= buf_len)
1762
		buf[buf_len - 1] = 0;
1763
	else
1764
		buf[len] = 0;
1765

1766
	stats_req->buf_len = len;
1767
}
1768

1769
static inline void
1770
htt_print_sched_txq_sched_order_su_tlv_v(const void *tag_buf,
1771
					 u16 tag_len,
1772
					 struct debug_htt_stats_req *stats_req)
1773
{
1774
	const struct htt_sched_txq_sched_order_su_tlv_v *htt_stats_buf = tag_buf;
1775
	u8 *buf = stats_req->buf;
1776
	u32 len = stats_req->buf_len;
1777
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1778
	/* each entry is u32, i.e. 4 bytes */
1779
	u32 sched_order_su_num_entries =
1780
		min_t(u32, (tag_len >> 2), HTT_TX_PDEV_NUM_SCHED_ORDER_LOG);
1781

1782
	len += scnprintf(buf + len, buf_len - len,
1783
			 "HTT_SCHED_TXQ_SCHED_ORDER_SU_TLV_V:\n");
1784

1785
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_order_su, "sched_order_su",
1786
			   sched_order_su_num_entries, "\n\n");
1787

1788
	if (len >= buf_len)
1789
		buf[buf_len - 1] = 0;
1790
	else
1791
		buf[len] = 0;
1792

1793
	stats_req->buf_len = len;
1794
}
1795

1796
static inline void
1797
htt_print_sched_txq_sched_ineligibility_tlv_v(const void *tag_buf,
1798
					      u16 tag_len,
1799
					      struct debug_htt_stats_req *stats_req)
1800
{
1801
	const struct htt_sched_txq_sched_ineligibility_tlv_v *htt_stats_buf = tag_buf;
1802
	u8 *buf = stats_req->buf;
1803
	u32 len = stats_req->buf_len;
1804
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1805
	/* each entry is u32, i.e. 4 bytes */
1806
	u32 sched_ineligibility_num_entries = tag_len >> 2;
1807

1808
	len += scnprintf(buf + len, buf_len - len,
1809
			 "HTT_SCHED_TXQ_SCHED_INELIGIBILITY_V:\n");
1810

1811
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->sched_ineligibility,
1812
			   "sched_ineligibility", sched_ineligibility_num_entries,
1813
			   "\n\n");
1814

1815
	if (len >= buf_len)
1816
		buf[buf_len - 1] = 0;
1817
	else
1818
		buf[len] = 0;
1819

1820
	stats_req->buf_len = len;
1821
}
1822

1823
static inline void
1824
htt_print_tx_pdev_stats_sched_per_txq_tlv(const void *tag_buf,
1825
					  struct debug_htt_stats_req *stats_req)
1826
{
1827
	const struct htt_tx_pdev_stats_sched_per_txq_tlv *htt_stats_buf = tag_buf;
1828
	u8 *buf = stats_req->buf;
1829
	u32 len = stats_req->buf_len;
1830
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1831

1832
	len += scnprintf(buf + len, buf_len - len,
1833
			 "HTT_TX_PDEV_STATS_SCHED_PER_TXQ_TLV:\n");
1834
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
1835
			 FIELD_GET(HTT_TX_PDEV_STATS_SCHED_PER_TXQ_MAC_ID,
1836
				   htt_stats_buf->mac_id__txq_id__word));
1837
	len += scnprintf(buf + len, buf_len - len, "txq_id = %lu\n",
1838
			 FIELD_GET(HTT_TX_PDEV_STATS_SCHED_PER_TXQ_ID,
1839
				   htt_stats_buf->mac_id__txq_id__word));
1840
	len += scnprintf(buf + len, buf_len - len, "sched_policy = %u\n",
1841
			 htt_stats_buf->sched_policy);
1842
	len += scnprintf(buf + len, buf_len - len,
1843
			 "last_sched_cmd_posted_timestamp = %u\n",
1844
			 htt_stats_buf->last_sched_cmd_posted_timestamp);
1845
	len += scnprintf(buf + len, buf_len - len,
1846
			 "last_sched_cmd_compl_timestamp = %u\n",
1847
			 htt_stats_buf->last_sched_cmd_compl_timestamp);
1848
	len += scnprintf(buf + len, buf_len - len, "sched_2_tac_lwm_count = %u\n",
1849
			 htt_stats_buf->sched_2_tac_lwm_count);
1850
	len += scnprintf(buf + len, buf_len - len, "sched_2_tac_ring_full = %u\n",
1851
			 htt_stats_buf->sched_2_tac_ring_full);
1852
	len += scnprintf(buf + len, buf_len - len, "sched_cmd_post_failure = %u\n",
1853
			 htt_stats_buf->sched_cmd_post_failure);
1854
	len += scnprintf(buf + len, buf_len - len, "num_active_tids = %u\n",
1855
			 htt_stats_buf->num_active_tids);
1856
	len += scnprintf(buf + len, buf_len - len, "num_ps_schedules = %u\n",
1857
			 htt_stats_buf->num_ps_schedules);
1858
	len += scnprintf(buf + len, buf_len - len, "sched_cmds_pending = %u\n",
1859
			 htt_stats_buf->sched_cmds_pending);
1860
	len += scnprintf(buf + len, buf_len - len, "num_tid_register = %u\n",
1861
			 htt_stats_buf->num_tid_register);
1862
	len += scnprintf(buf + len, buf_len - len, "num_tid_unregister = %u\n",
1863
			 htt_stats_buf->num_tid_unregister);
1864
	len += scnprintf(buf + len, buf_len - len, "num_qstats_queried = %u\n",
1865
			 htt_stats_buf->num_qstats_queried);
1866
	len += scnprintf(buf + len, buf_len - len, "qstats_update_pending = %u\n",
1867
			 htt_stats_buf->qstats_update_pending);
1868
	len += scnprintf(buf + len, buf_len - len, "last_qstats_query_timestamp = %u\n",
1869
			 htt_stats_buf->last_qstats_query_timestamp);
1870
	len += scnprintf(buf + len, buf_len - len, "num_tqm_cmdq_full = %u\n",
1871
			 htt_stats_buf->num_tqm_cmdq_full);
1872
	len += scnprintf(buf + len, buf_len - len, "num_de_sched_algo_trigger = %u\n",
1873
			 htt_stats_buf->num_de_sched_algo_trigger);
1874
	len += scnprintf(buf + len, buf_len - len, "num_rt_sched_algo_trigger = %u\n",
1875
			 htt_stats_buf->num_rt_sched_algo_trigger);
1876
	len += scnprintf(buf + len, buf_len - len, "num_tqm_sched_algo_trigger = %u\n",
1877
			 htt_stats_buf->num_tqm_sched_algo_trigger);
1878
	len += scnprintf(buf + len, buf_len - len, "notify_sched = %u\n\n",
1879
			 htt_stats_buf->notify_sched);
1880
	len += scnprintf(buf + len, buf_len - len, "dur_based_sendn_term = %u\n\n",
1881
			 htt_stats_buf->dur_based_sendn_term);
1882

1883
	if (len >= buf_len)
1884
		buf[buf_len - 1] = 0;
1885
	else
1886
		buf[len] = 0;
1887

1888
	stats_req->buf_len = len;
1889
}
1890

1891
static inline void htt_print_stats_tx_sched_cmn_tlv(const void *tag_buf,
1892
						    struct debug_htt_stats_req *stats_req)
1893
{
1894
	const struct htt_stats_tx_sched_cmn_tlv *htt_stats_buf = tag_buf;
1895
	u8 *buf = stats_req->buf;
1896
	u32 len = stats_req->buf_len;
1897
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1898

1899
	len += scnprintf(buf + len, buf_len - len, "HTT_STATS_TX_SCHED_CMN_TLV:\n");
1900
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
1901
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
1902
	len += scnprintf(buf + len, buf_len - len, "current_timestamp = %u\n\n",
1903
			 htt_stats_buf->current_timestamp);
1904

1905
	if (len >= buf_len)
1906
		buf[buf_len - 1] = 0;
1907
	else
1908
		buf[len] = 0;
1909

1910
	stats_req->buf_len = len;
1911
}
1912

1913
static inline void
1914
htt_print_tx_tqm_gen_mpdu_stats_tlv_v(const void *tag_buf,
1915
				      u16 tag_len,
1916
				      struct debug_htt_stats_req *stats_req)
1917
{
1918
	const struct htt_tx_tqm_gen_mpdu_stats_tlv_v *htt_stats_buf = tag_buf;
1919
	u8 *buf = stats_req->buf;
1920
	u32 len = stats_req->buf_len;
1921
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1922
	u16 num_elements = min_t(u16, (tag_len >> 2),
1923
				 HTT_TX_TQM_MAX_LIST_MPDU_END_REASON);
1924

1925
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_GEN_MPDU_STATS_TLV_V:\n");
1926

1927
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->gen_mpdu_end_reason,
1928
			   "gen_mpdu_end_reason", num_elements, "\n\n");
1929

1930
	if (len >= buf_len)
1931
		buf[buf_len - 1] = 0;
1932
	else
1933
		buf[len] = 0;
1934

1935
	stats_req->buf_len = len;
1936
}
1937

1938
static inline void
1939
htt_print_tx_tqm_list_mpdu_stats_tlv_v(const void *tag_buf,
1940
				       u16 tag_len,
1941
				       struct debug_htt_stats_req *stats_req)
1942
{
1943
	const struct htt_tx_tqm_list_mpdu_stats_tlv_v *htt_stats_buf = tag_buf;
1944
	u8 *buf = stats_req->buf;
1945
	u32 len = stats_req->buf_len;
1946
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1947
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_TX_TQM_MAX_LIST_MPDU_END_REASON);
1948

1949
	len += scnprintf(buf + len, buf_len - len,
1950
			 "HTT_TX_TQM_LIST_MPDU_STATS_TLV_V:\n");
1951

1952
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->list_mpdu_end_reason,
1953
			   "list_mpdu_end_reason", num_elems, "\n\n");
1954

1955
	if (len >= buf_len)
1956
		buf[buf_len - 1] = 0;
1957
	else
1958
		buf[len] = 0;
1959

1960
	stats_req->buf_len = len;
1961
}
1962

1963
static inline void
1964
htt_print_tx_tqm_list_mpdu_cnt_tlv_v(const void *tag_buf,
1965
				     u16 tag_len,
1966
				     struct debug_htt_stats_req *stats_req)
1967
{
1968
	const struct htt_tx_tqm_list_mpdu_cnt_tlv_v *htt_stats_buf = tag_buf;
1969
	u8 *buf = stats_req->buf;
1970
	u32 len = stats_req->buf_len;
1971
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1972
	u16 num_elems = min_t(u16, (tag_len >> 2),
1973
			      HTT_TX_TQM_MAX_LIST_MPDU_CNT_HISTOGRAM_BINS);
1974

1975
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_LIST_MPDU_CNT_TLV_V:\n");
1976

1977
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->list_mpdu_cnt_hist,
1978
			   "list_mpdu_cnt_hist", num_elems, "\n\n");
1979

1980
	if (len >= buf_len)
1981
		buf[buf_len - 1] = 0;
1982
	else
1983
		buf[len] = 0;
1984

1985
	stats_req->buf_len = len;
1986
}
1987

1988
static inline void
1989
htt_print_tx_tqm_pdev_stats_tlv_v(const void *tag_buf,
1990
				  struct debug_htt_stats_req *stats_req)
1991
{
1992
	const struct htt_tx_tqm_pdev_stats_tlv_v *htt_stats_buf = tag_buf;
1993
	u8 *buf = stats_req->buf;
1994
	u32 len = stats_req->buf_len;
1995
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
1996

1997
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_PDEV_STATS_TLV_V:\n");
1998
	len += scnprintf(buf + len, buf_len - len, "msdu_count = %u\n",
1999
			 htt_stats_buf->msdu_count);
2000
	len += scnprintf(buf + len, buf_len - len, "mpdu_count = %u\n",
2001
			 htt_stats_buf->mpdu_count);
2002
	len += scnprintf(buf + len, buf_len - len, "remove_msdu = %u\n",
2003
			 htt_stats_buf->remove_msdu);
2004
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu = %u\n",
2005
			 htt_stats_buf->remove_mpdu);
2006
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl = %u\n",
2007
			 htt_stats_buf->remove_msdu_ttl);
2008
	len += scnprintf(buf + len, buf_len - len, "send_bar = %u\n",
2009
			 htt_stats_buf->send_bar);
2010
	len += scnprintf(buf + len, buf_len - len, "bar_sync = %u\n",
2011
			 htt_stats_buf->bar_sync);
2012
	len += scnprintf(buf + len, buf_len - len, "notify_mpdu = %u\n",
2013
			 htt_stats_buf->notify_mpdu);
2014
	len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n",
2015
			 htt_stats_buf->sync_cmd);
2016
	len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n",
2017
			 htt_stats_buf->write_cmd);
2018
	len += scnprintf(buf + len, buf_len - len, "hwsch_trigger = %u\n",
2019
			 htt_stats_buf->hwsch_trigger);
2020
	len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n",
2021
			 htt_stats_buf->ack_tlv_proc);
2022
	len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n",
2023
			 htt_stats_buf->gen_mpdu_cmd);
2024
	len += scnprintf(buf + len, buf_len - len, "gen_list_cmd = %u\n",
2025
			 htt_stats_buf->gen_list_cmd);
2026
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n",
2027
			 htt_stats_buf->remove_mpdu_cmd);
2028
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu_tried_cmd = %u\n",
2029
			 htt_stats_buf->remove_mpdu_tried_cmd);
2030
	len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n",
2031
			 htt_stats_buf->mpdu_queue_stats_cmd);
2032
	len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n",
2033
			 htt_stats_buf->mpdu_head_info_cmd);
2034
	len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n",
2035
			 htt_stats_buf->msdu_flow_stats_cmd);
2036
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n",
2037
			 htt_stats_buf->remove_msdu_cmd);
2038
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_ttl_cmd = %u\n",
2039
			 htt_stats_buf->remove_msdu_ttl_cmd);
2040
	len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n",
2041
			 htt_stats_buf->flush_cache_cmd);
2042
	len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n",
2043
			 htt_stats_buf->update_mpduq_cmd);
2044
	len += scnprintf(buf + len, buf_len - len, "enqueue = %u\n",
2045
			 htt_stats_buf->enqueue);
2046
	len += scnprintf(buf + len, buf_len - len, "enqueue_notify = %u\n",
2047
			 htt_stats_buf->enqueue_notify);
2048
	len += scnprintf(buf + len, buf_len - len, "notify_mpdu_at_head = %u\n",
2049
			 htt_stats_buf->notify_mpdu_at_head);
2050
	len += scnprintf(buf + len, buf_len - len, "notify_mpdu_state_valid = %u\n",
2051
			 htt_stats_buf->notify_mpdu_state_valid);
2052
	len += scnprintf(buf + len, buf_len - len, "sched_udp_notify1 = %u\n",
2053
			 htt_stats_buf->sched_udp_notify1);
2054
	len += scnprintf(buf + len, buf_len - len, "sched_udp_notify2 = %u\n",
2055
			 htt_stats_buf->sched_udp_notify2);
2056
	len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify1 = %u\n",
2057
			 htt_stats_buf->sched_nonudp_notify1);
2058
	len += scnprintf(buf + len, buf_len - len, "sched_nonudp_notify2 = %u\n\n",
2059
			 htt_stats_buf->sched_nonudp_notify2);
2060

2061
	if (len >= buf_len)
2062
		buf[buf_len - 1] = 0;
2063
	else
2064
		buf[len] = 0;
2065

2066
	stats_req->buf_len = len;
2067
}
2068

2069
static inline void htt_print_tx_tqm_cmn_stats_tlv(const void *tag_buf,
2070
						  struct debug_htt_stats_req *stats_req)
2071
{
2072
	const struct htt_tx_tqm_cmn_stats_tlv *htt_stats_buf = tag_buf;
2073
	u8 *buf = stats_req->buf;
2074
	u32 len = stats_req->buf_len;
2075
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2076

2077
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMN_STATS_TLV:\n");
2078
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2079
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
2080
	len += scnprintf(buf + len, buf_len - len, "max_cmdq_id = %u\n",
2081
			 htt_stats_buf->max_cmdq_id);
2082
	len += scnprintf(buf + len, buf_len - len, "list_mpdu_cnt_hist_intvl = %u\n",
2083
			 htt_stats_buf->list_mpdu_cnt_hist_intvl);
2084
	len += scnprintf(buf + len, buf_len - len, "add_msdu = %u\n",
2085
			 htt_stats_buf->add_msdu);
2086
	len += scnprintf(buf + len, buf_len - len, "q_empty = %u\n",
2087
			 htt_stats_buf->q_empty);
2088
	len += scnprintf(buf + len, buf_len - len, "q_not_empty = %u\n",
2089
			 htt_stats_buf->q_not_empty);
2090
	len += scnprintf(buf + len, buf_len - len, "drop_notification = %u\n",
2091
			 htt_stats_buf->drop_notification);
2092
	len += scnprintf(buf + len, buf_len - len, "desc_threshold = %u\n\n",
2093
			 htt_stats_buf->desc_threshold);
2094

2095
	if (len >= buf_len)
2096
		buf[buf_len - 1] = 0;
2097
	else
2098
		buf[len] = 0;
2099

2100
	stats_req->buf_len = len;
2101
}
2102

2103
static inline void htt_print_tx_tqm_error_stats_tlv(const void *tag_buf,
2104
						    struct debug_htt_stats_req *stats_req)
2105
{
2106
	const struct htt_tx_tqm_error_stats_tlv *htt_stats_buf = tag_buf;
2107
	u8 *buf = stats_req->buf;
2108
	u32 len = stats_req->buf_len;
2109
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2110

2111
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_ERROR_STATS_TLV:\n");
2112
	len += scnprintf(buf + len, buf_len - len, "q_empty_failure = %u\n",
2113
			 htt_stats_buf->q_empty_failure);
2114
	len += scnprintf(buf + len, buf_len - len, "q_not_empty_failure = %u\n",
2115
			 htt_stats_buf->q_not_empty_failure);
2116
	len += scnprintf(buf + len, buf_len - len, "add_msdu_failure = %u\n\n",
2117
			 htt_stats_buf->add_msdu_failure);
2118

2119
	if (len >= buf_len)
2120
		buf[buf_len - 1] = 0;
2121
	else
2122
		buf[len] = 0;
2123

2124
	stats_req->buf_len = len;
2125
}
2126

2127
static inline void htt_print_tx_tqm_cmdq_status_tlv(const void *tag_buf,
2128
						    struct debug_htt_stats_req *stats_req)
2129
{
2130
	const struct htt_tx_tqm_cmdq_status_tlv *htt_stats_buf = tag_buf;
2131
	u8 *buf = stats_req->buf;
2132
	u32 len = stats_req->buf_len;
2133
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2134

2135
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_TQM_CMDQ_STATUS_TLV:\n");
2136
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2137
			 FIELD_GET(HTT_TX_TQM_CMDQ_STATUS_MAC_ID,
2138
				   htt_stats_buf->mac_id__cmdq_id__word));
2139
	len += scnprintf(buf + len, buf_len - len, "cmdq_id = %lu\n\n",
2140
			 FIELD_GET(HTT_TX_TQM_CMDQ_STATUS_CMDQ_ID,
2141
				   htt_stats_buf->mac_id__cmdq_id__word));
2142
	len += scnprintf(buf + len, buf_len - len, "sync_cmd = %u\n",
2143
			 htt_stats_buf->sync_cmd);
2144
	len += scnprintf(buf + len, buf_len - len, "write_cmd = %u\n",
2145
			 htt_stats_buf->write_cmd);
2146
	len += scnprintf(buf + len, buf_len - len, "gen_mpdu_cmd = %u\n",
2147
			 htt_stats_buf->gen_mpdu_cmd);
2148
	len += scnprintf(buf + len, buf_len - len, "mpdu_queue_stats_cmd = %u\n",
2149
			 htt_stats_buf->mpdu_queue_stats_cmd);
2150
	len += scnprintf(buf + len, buf_len - len, "mpdu_head_info_cmd = %u\n",
2151
			 htt_stats_buf->mpdu_head_info_cmd);
2152
	len += scnprintf(buf + len, buf_len - len, "msdu_flow_stats_cmd = %u\n",
2153
			 htt_stats_buf->msdu_flow_stats_cmd);
2154
	len += scnprintf(buf + len, buf_len - len, "remove_mpdu_cmd = %u\n",
2155
			 htt_stats_buf->remove_mpdu_cmd);
2156
	len += scnprintf(buf + len, buf_len - len, "remove_msdu_cmd = %u\n",
2157
			 htt_stats_buf->remove_msdu_cmd);
2158
	len += scnprintf(buf + len, buf_len - len, "flush_cache_cmd = %u\n",
2159
			 htt_stats_buf->flush_cache_cmd);
2160
	len += scnprintf(buf + len, buf_len - len, "update_mpduq_cmd = %u\n",
2161
			 htt_stats_buf->update_mpduq_cmd);
2162
	len += scnprintf(buf + len, buf_len - len, "update_msduq_cmd = %u\n\n",
2163
			 htt_stats_buf->update_msduq_cmd);
2164

2165
	if (len >= buf_len)
2166
		buf[buf_len - 1] = 0;
2167
	else
2168
		buf[len] = 0;
2169

2170
	stats_req->buf_len = len;
2171
}
2172

2173
static inline void
2174
htt_print_tx_de_eapol_packets_stats_tlv(const void *tag_buf,
2175
					struct debug_htt_stats_req *stats_req)
2176
{
2177
	const struct htt_tx_de_eapol_packets_stats_tlv *htt_stats_buf = tag_buf;
2178
	u8 *buf = stats_req->buf;
2179
	u32 len = stats_req->buf_len;
2180
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2181

2182
	len += scnprintf(buf + len, buf_len - len,
2183
			   "HTT_TX_DE_EAPOL_PACKETS_STATS_TLV:\n");
2184
	len += scnprintf(buf + len, buf_len - len, "m1_packets = %u\n",
2185
			 htt_stats_buf->m1_packets);
2186
	len += scnprintf(buf + len, buf_len - len, "m2_packets = %u\n",
2187
			 htt_stats_buf->m2_packets);
2188
	len += scnprintf(buf + len, buf_len - len, "m3_packets = %u\n",
2189
			 htt_stats_buf->m3_packets);
2190
	len += scnprintf(buf + len, buf_len - len, "m4_packets = %u\n",
2191
			 htt_stats_buf->m4_packets);
2192
	len += scnprintf(buf + len, buf_len - len, "g1_packets = %u\n",
2193
			 htt_stats_buf->g1_packets);
2194
	len += scnprintf(buf + len, buf_len - len, "g2_packets = %u\n\n",
2195
			 htt_stats_buf->g2_packets);
2196

2197
	if (len >= buf_len)
2198
		buf[buf_len - 1] = 0;
2199
	else
2200
		buf[len] = 0;
2201

2202
	stats_req->buf_len = len;
2203
}
2204

2205
static inline void
2206
htt_print_tx_de_classify_failed_stats_tlv(const void *tag_buf,
2207
					  struct debug_htt_stats_req *stats_req)
2208
{
2209
	const struct htt_tx_de_classify_failed_stats_tlv *htt_stats_buf = tag_buf;
2210
	u8 *buf = stats_req->buf;
2211
	u32 len = stats_req->buf_len;
2212
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2213

2214
	len += scnprintf(buf + len, buf_len - len,
2215
			   "HTT_TX_DE_CLASSIFY_FAILED_STATS_TLV:\n");
2216
	len += scnprintf(buf + len, buf_len - len, "ap_bss_peer_not_found = %u\n",
2217
			 htt_stats_buf->ap_bss_peer_not_found);
2218
	len += scnprintf(buf + len, buf_len - len, "ap_bcast_mcast_no_peer = %u\n",
2219
			 htt_stats_buf->ap_bcast_mcast_no_peer);
2220
	len += scnprintf(buf + len, buf_len - len, "sta_delete_in_progress = %u\n",
2221
			 htt_stats_buf->sta_delete_in_progress);
2222
	len += scnprintf(buf + len, buf_len - len, "ibss_no_bss_peer = %u\n",
2223
			 htt_stats_buf->ibss_no_bss_peer);
2224
	len += scnprintf(buf + len, buf_len - len, "invalid_vdev_type = %u\n",
2225
			 htt_stats_buf->invalid_vdev_type);
2226
	len += scnprintf(buf + len, buf_len - len, "invalid_ast_peer_entry = %u\n",
2227
			 htt_stats_buf->invalid_ast_peer_entry);
2228
	len += scnprintf(buf + len, buf_len - len, "peer_entry_invalid = %u\n",
2229
			 htt_stats_buf->peer_entry_invalid);
2230
	len += scnprintf(buf + len, buf_len - len, "ethertype_not_ip = %u\n",
2231
			 htt_stats_buf->ethertype_not_ip);
2232
	len += scnprintf(buf + len, buf_len - len, "eapol_lookup_failed = %u\n",
2233
			 htt_stats_buf->eapol_lookup_failed);
2234
	len += scnprintf(buf + len, buf_len - len, "qpeer_not_allow_data = %u\n",
2235
			 htt_stats_buf->qpeer_not_allow_data);
2236
	len += scnprintf(buf + len, buf_len - len, "fse_tid_override = %u\n",
2237
			 htt_stats_buf->fse_tid_override);
2238
	len += scnprintf(buf + len, buf_len - len, "ipv6_jumbogram_zero_length = %u\n",
2239
			 htt_stats_buf->ipv6_jumbogram_zero_length);
2240
	len += scnprintf(buf + len, buf_len - len, "qos_to_non_qos_in_prog = %u\n\n",
2241
			 htt_stats_buf->qos_to_non_qos_in_prog);
2242

2243
	if (len >= buf_len)
2244
		buf[buf_len - 1] = 0;
2245
	else
2246
		buf[len] = 0;
2247

2248
	stats_req->buf_len = len;
2249
}
2250

2251
static inline void
2252
htt_print_tx_de_classify_stats_tlv(const void *tag_buf,
2253
				   struct debug_htt_stats_req *stats_req)
2254
{
2255
	const struct htt_tx_de_classify_stats_tlv *htt_stats_buf = tag_buf;
2256
	u8 *buf = stats_req->buf;
2257
	u32 len = stats_req->buf_len;
2258
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2259

2260
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CLASSIFY_STATS_TLV:\n");
2261
	len += scnprintf(buf + len, buf_len - len, "arp_packets = %u\n",
2262
			 htt_stats_buf->arp_packets);
2263
	len += scnprintf(buf + len, buf_len - len, "igmp_packets = %u\n",
2264
			 htt_stats_buf->igmp_packets);
2265
	len += scnprintf(buf + len, buf_len - len, "dhcp_packets = %u\n",
2266
			 htt_stats_buf->dhcp_packets);
2267
	len += scnprintf(buf + len, buf_len - len, "host_inspected = %u\n",
2268
			 htt_stats_buf->host_inspected);
2269
	len += scnprintf(buf + len, buf_len - len, "htt_included = %u\n",
2270
			 htt_stats_buf->htt_included);
2271
	len += scnprintf(buf + len, buf_len - len, "htt_valid_mcs = %u\n",
2272
			 htt_stats_buf->htt_valid_mcs);
2273
	len += scnprintf(buf + len, buf_len - len, "htt_valid_nss = %u\n",
2274
			 htt_stats_buf->htt_valid_nss);
2275
	len += scnprintf(buf + len, buf_len - len, "htt_valid_preamble_type = %u\n",
2276
			 htt_stats_buf->htt_valid_preamble_type);
2277
	len += scnprintf(buf + len, buf_len - len, "htt_valid_chainmask = %u\n",
2278
			 htt_stats_buf->htt_valid_chainmask);
2279
	len += scnprintf(buf + len, buf_len - len, "htt_valid_guard_interval = %u\n",
2280
			 htt_stats_buf->htt_valid_guard_interval);
2281
	len += scnprintf(buf + len, buf_len - len, "htt_valid_retries = %u\n",
2282
			 htt_stats_buf->htt_valid_retries);
2283
	len += scnprintf(buf + len, buf_len - len, "htt_valid_bw_info = %u\n",
2284
			 htt_stats_buf->htt_valid_bw_info);
2285
	len += scnprintf(buf + len, buf_len - len, "htt_valid_power = %u\n",
2286
			 htt_stats_buf->htt_valid_power);
2287
	len += scnprintf(buf + len, buf_len - len, "htt_valid_key_flags = 0x%x\n",
2288
			 htt_stats_buf->htt_valid_key_flags);
2289
	len += scnprintf(buf + len, buf_len - len, "htt_valid_no_encryption = %u\n",
2290
			 htt_stats_buf->htt_valid_no_encryption);
2291
	len += scnprintf(buf + len, buf_len - len, "fse_entry_count = %u\n",
2292
			 htt_stats_buf->fse_entry_count);
2293
	len += scnprintf(buf + len, buf_len - len, "fse_priority_be = %u\n",
2294
			 htt_stats_buf->fse_priority_be);
2295
	len += scnprintf(buf + len, buf_len - len, "fse_priority_high = %u\n",
2296
			 htt_stats_buf->fse_priority_high);
2297
	len += scnprintf(buf + len, buf_len - len, "fse_priority_low = %u\n",
2298
			 htt_stats_buf->fse_priority_low);
2299
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_be = %u\n",
2300
			 htt_stats_buf->fse_traffic_ptrn_be);
2301
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_over_sub = %u\n",
2302
			 htt_stats_buf->fse_traffic_ptrn_over_sub);
2303
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_bursty = %u\n",
2304
			 htt_stats_buf->fse_traffic_ptrn_bursty);
2305
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_interactive = %u\n",
2306
			 htt_stats_buf->fse_traffic_ptrn_interactive);
2307
	len += scnprintf(buf + len, buf_len - len, "fse_traffic_ptrn_periodic = %u\n",
2308
			 htt_stats_buf->fse_traffic_ptrn_periodic);
2309
	len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_alloc = %u\n",
2310
			 htt_stats_buf->fse_hwqueue_alloc);
2311
	len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_created = %u\n",
2312
			 htt_stats_buf->fse_hwqueue_created);
2313
	len += scnprintf(buf + len, buf_len - len, "fse_hwqueue_send_to_host = %u\n",
2314
			 htt_stats_buf->fse_hwqueue_send_to_host);
2315
	len += scnprintf(buf + len, buf_len - len, "mcast_entry = %u\n",
2316
			 htt_stats_buf->mcast_entry);
2317
	len += scnprintf(buf + len, buf_len - len, "bcast_entry = %u\n",
2318
			 htt_stats_buf->bcast_entry);
2319
	len += scnprintf(buf + len, buf_len - len, "htt_update_peer_cache = %u\n",
2320
			 htt_stats_buf->htt_update_peer_cache);
2321
	len += scnprintf(buf + len, buf_len - len, "htt_learning_frame = %u\n",
2322
			 htt_stats_buf->htt_learning_frame);
2323
	len += scnprintf(buf + len, buf_len - len, "fse_invalid_peer = %u\n",
2324
			 htt_stats_buf->fse_invalid_peer);
2325
	len += scnprintf(buf + len, buf_len - len, "mec_notify = %u\n\n",
2326
			 htt_stats_buf->mec_notify);
2327

2328
	if (len >= buf_len)
2329
		buf[buf_len - 1] = 0;
2330
	else
2331
		buf[len] = 0;
2332

2333
	stats_req->buf_len = len;
2334
}
2335

2336
static inline void
2337
htt_print_tx_de_classify_status_stats_tlv(const void *tag_buf,
2338
					  struct debug_htt_stats_req *stats_req)
2339
{
2340
	const struct htt_tx_de_classify_status_stats_tlv *htt_stats_buf = tag_buf;
2341
	u8 *buf = stats_req->buf;
2342
	u32 len = stats_req->buf_len;
2343
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2344

2345
	len += scnprintf(buf + len, buf_len - len,
2346
			   "HTT_TX_DE_CLASSIFY_STATUS_STATS_TLV:\n");
2347
	len += scnprintf(buf + len, buf_len - len, "eok = %u\n",
2348
			 htt_stats_buf->eok);
2349
	len += scnprintf(buf + len, buf_len - len, "classify_done = %u\n",
2350
			 htt_stats_buf->classify_done);
2351
	len += scnprintf(buf + len, buf_len - len, "lookup_failed = %u\n",
2352
			 htt_stats_buf->lookup_failed);
2353
	len += scnprintf(buf + len, buf_len - len, "send_host_dhcp = %u\n",
2354
			 htt_stats_buf->send_host_dhcp);
2355
	len += scnprintf(buf + len, buf_len - len, "send_host_mcast = %u\n",
2356
			 htt_stats_buf->send_host_mcast);
2357
	len += scnprintf(buf + len, buf_len - len, "send_host_unknown_dest = %u\n",
2358
			 htt_stats_buf->send_host_unknown_dest);
2359
	len += scnprintf(buf + len, buf_len - len, "send_host = %u\n",
2360
			 htt_stats_buf->send_host);
2361
	len += scnprintf(buf + len, buf_len - len, "status_invalid = %u\n\n",
2362
			 htt_stats_buf->status_invalid);
2363

2364
	if (len >= buf_len)
2365
		buf[buf_len - 1] = 0;
2366
	else
2367
		buf[len] = 0;
2368

2369
	stats_req->buf_len = len;
2370
}
2371

2372
static inline void
2373
htt_print_tx_de_enqueue_packets_stats_tlv(const void *tag_buf,
2374
					  struct debug_htt_stats_req *stats_req)
2375
{
2376
	const struct htt_tx_de_enqueue_packets_stats_tlv *htt_stats_buf = tag_buf;
2377
	u8 *buf = stats_req->buf;
2378
	u32 len = stats_req->buf_len;
2379
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2380

2381
	len += scnprintf(buf + len, buf_len - len,
2382
			 "HTT_TX_DE_ENQUEUE_PACKETS_STATS_TLV:\n");
2383
	len += scnprintf(buf + len, buf_len - len, "enqueued_pkts = %u\n",
2384
			 htt_stats_buf->enqueued_pkts);
2385
	len += scnprintf(buf + len, buf_len - len, "to_tqm = %u\n",
2386
			 htt_stats_buf->to_tqm);
2387
	len += scnprintf(buf + len, buf_len - len, "to_tqm_bypass = %u\n\n",
2388
			 htt_stats_buf->to_tqm_bypass);
2389

2390
	if (len >= buf_len)
2391
		buf[buf_len - 1] = 0;
2392
	else
2393
		buf[len] = 0;
2394

2395
	stats_req->buf_len = len;
2396
}
2397

2398
static inline void
2399
htt_print_tx_de_enqueue_discard_stats_tlv(const void *tag_buf,
2400
					  struct debug_htt_stats_req *stats_req)
2401
{
2402
	const struct htt_tx_de_enqueue_discard_stats_tlv *htt_stats_buf = tag_buf;
2403
	u8 *buf = stats_req->buf;
2404
	u32 len = stats_req->buf_len;
2405
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2406

2407
	len += scnprintf(buf + len, buf_len - len,
2408
			 "HTT_TX_DE_ENQUEUE_DISCARD_STATS_TLV:\n");
2409
	len += scnprintf(buf + len, buf_len - len, "discarded_pkts = %u\n",
2410
			 htt_stats_buf->discarded_pkts);
2411
	len += scnprintf(buf + len, buf_len - len, "local_frames = %u\n",
2412
			 htt_stats_buf->local_frames);
2413
	len += scnprintf(buf + len, buf_len - len, "is_ext_msdu = %u\n\n",
2414
			 htt_stats_buf->is_ext_msdu);
2415

2416
	if (len >= buf_len)
2417
		buf[buf_len - 1] = 0;
2418
	else
2419
		buf[len] = 0;
2420

2421
	stats_req->buf_len = len;
2422
}
2423

2424
static inline void htt_print_tx_de_compl_stats_tlv(const void *tag_buf,
2425
						   struct debug_htt_stats_req *stats_req)
2426
{
2427
	const struct htt_tx_de_compl_stats_tlv *htt_stats_buf = tag_buf;
2428
	u8 *buf = stats_req->buf;
2429
	u32 len = stats_req->buf_len;
2430
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2431

2432
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_COMPL_STATS_TLV:\n");
2433
	len += scnprintf(buf + len, buf_len - len, "tcl_dummy_frame = %u\n",
2434
			 htt_stats_buf->tcl_dummy_frame);
2435
	len += scnprintf(buf + len, buf_len - len, "tqm_dummy_frame = %u\n",
2436
			 htt_stats_buf->tqm_dummy_frame);
2437
	len += scnprintf(buf + len, buf_len - len, "tqm_notify_frame = %u\n",
2438
			 htt_stats_buf->tqm_notify_frame);
2439
	len += scnprintf(buf + len, buf_len - len, "fw2wbm_enq = %u\n",
2440
			 htt_stats_buf->fw2wbm_enq);
2441
	len += scnprintf(buf + len, buf_len - len, "tqm_bypass_frame = %u\n\n",
2442
			 htt_stats_buf->tqm_bypass_frame);
2443

2444
	if (len >= buf_len)
2445
		buf[buf_len - 1] = 0;
2446
	else
2447
		buf[len] = 0;
2448

2449
	stats_req->buf_len = len;
2450
}
2451

2452
static inline void
2453
htt_print_tx_de_fw2wbm_ring_full_hist_tlv(const void *tag_buf,
2454
					  u16 tag_len,
2455
					  struct debug_htt_stats_req *stats_req)
2456
{
2457
	const struct htt_tx_de_fw2wbm_ring_full_hist_tlv *htt_stats_buf = tag_buf;
2458
	u8 *buf = stats_req->buf;
2459
	u32 len = stats_req->buf_len;
2460
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2461
	u16  num_elements = tag_len >> 2;
2462

2463
	len += scnprintf(buf + len, buf_len - len,
2464
			 "HTT_TX_DE_FW2WBM_RING_FULL_HIST_TLV");
2465

2466
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw2wbm_ring_full_hist,
2467
			   "fw2wbm_ring_full_hist", num_elements, "\n\n");
2468

2469
	if (len >= buf_len)
2470
		buf[buf_len - 1] = 0;
2471
	else
2472
		buf[len] = 0;
2473

2474
	stats_req->buf_len = len;
2475
}
2476

2477
static inline void
2478
htt_print_tx_de_cmn_stats_tlv(const void *tag_buf, struct debug_htt_stats_req *stats_req)
2479
{
2480
	const struct htt_tx_de_cmn_stats_tlv *htt_stats_buf = tag_buf;
2481
	u8 *buf = stats_req->buf;
2482
	u32 len = stats_req->buf_len;
2483
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2484

2485
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_DE_CMN_STATS_TLV:\n");
2486
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2487
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
2488
	len += scnprintf(buf + len, buf_len - len, "tcl2fw_entry_count = %u\n",
2489
			 htt_stats_buf->tcl2fw_entry_count);
2490
	len += scnprintf(buf + len, buf_len - len, "not_to_fw = %u\n",
2491
			 htt_stats_buf->not_to_fw);
2492
	len += scnprintf(buf + len, buf_len - len, "invalid_pdev_vdev_peer = %u\n",
2493
			 htt_stats_buf->invalid_pdev_vdev_peer);
2494
	len += scnprintf(buf + len, buf_len - len, "tcl_res_invalid_addrx = %u\n",
2495
			 htt_stats_buf->tcl_res_invalid_addrx);
2496
	len += scnprintf(buf + len, buf_len - len, "wbm2fw_entry_count = %u\n",
2497
			 htt_stats_buf->wbm2fw_entry_count);
2498
	len += scnprintf(buf + len, buf_len - len, "invalid_pdev = %u\n\n",
2499
			 htt_stats_buf->invalid_pdev);
2500

2501
	if (len >= buf_len)
2502
		buf[buf_len - 1] = 0;
2503
	else
2504
		buf[len] = 0;
2505

2506
	stats_req->buf_len = len;
2507
}
2508

2509
static inline void htt_print_ring_if_stats_tlv(const void *tag_buf,
2510
					       struct debug_htt_stats_req *stats_req)
2511
{
2512
	const struct htt_ring_if_stats_tlv *htt_stats_buf = tag_buf;
2513
	u8 *buf = stats_req->buf;
2514
	u32 len = stats_req->buf_len;
2515
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2516

2517
	len += scnprintf(buf + len, buf_len - len, "HTT_RING_IF_STATS_TLV:\n");
2518
	len += scnprintf(buf + len, buf_len - len, "base_addr = %u\n",
2519
			 htt_stats_buf->base_addr);
2520
	len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n",
2521
			 htt_stats_buf->elem_size);
2522
	len += scnprintf(buf + len, buf_len - len, "num_elems = %lu\n",
2523
			 FIELD_GET(HTT_RING_IF_STATS_NUM_ELEMS,
2524
				   htt_stats_buf->num_elems__prefetch_tail_idx));
2525
	len += scnprintf(buf + len, buf_len - len, "prefetch_tail_idx = %lu\n",
2526
			 FIELD_GET(HTT_RING_IF_STATS_PREFETCH_TAIL_INDEX,
2527
				   htt_stats_buf->num_elems__prefetch_tail_idx));
2528
	len += scnprintf(buf + len, buf_len - len, "head_idx = %lu\n",
2529
			 FIELD_GET(HTT_RING_IF_STATS_HEAD_IDX,
2530
				   htt_stats_buf->head_idx__tail_idx));
2531
	len += scnprintf(buf + len, buf_len - len, "tail_idx = %lu\n",
2532
			 FIELD_GET(HTT_RING_IF_STATS_TAIL_IDX,
2533
				   htt_stats_buf->head_idx__tail_idx));
2534
	len += scnprintf(buf + len, buf_len - len, "shadow_head_idx = %lu\n",
2535
			 FIELD_GET(HTT_RING_IF_STATS_SHADOW_HEAD_IDX,
2536
				   htt_stats_buf->shadow_head_idx__shadow_tail_idx));
2537
	len += scnprintf(buf + len, buf_len - len, "shadow_tail_idx = %lu\n",
2538
			 FIELD_GET(HTT_RING_IF_STATS_SHADOW_TAIL_IDX,
2539
				   htt_stats_buf->shadow_head_idx__shadow_tail_idx));
2540
	len += scnprintf(buf + len, buf_len - len, "num_tail_incr = %u\n",
2541
			 htt_stats_buf->num_tail_incr);
2542
	len += scnprintf(buf + len, buf_len - len, "lwm_thresh = %lu\n",
2543
			 FIELD_GET(HTT_RING_IF_STATS_LWM_THRESH,
2544
				   htt_stats_buf->lwm_thresh__hwm_thresh));
2545
	len += scnprintf(buf + len, buf_len - len, "hwm_thresh = %lu\n",
2546
			 FIELD_GET(HTT_RING_IF_STATS_HWM_THRESH,
2547
				   htt_stats_buf->lwm_thresh__hwm_thresh));
2548
	len += scnprintf(buf + len, buf_len - len, "overrun_hit_count = %u\n",
2549
			 htt_stats_buf->overrun_hit_count);
2550
	len += scnprintf(buf + len, buf_len - len, "underrun_hit_count = %u\n",
2551
			 htt_stats_buf->underrun_hit_count);
2552
	len += scnprintf(buf + len, buf_len - len, "prod_blockwait_count = %u\n",
2553
			 htt_stats_buf->prod_blockwait_count);
2554
	len += scnprintf(buf + len, buf_len - len, "cons_blockwait_count = %u\n",
2555
			 htt_stats_buf->cons_blockwait_count);
2556

2557
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->low_wm_hit_count,
2558
			   "low_wm_hit_count", HTT_STATS_LOW_WM_BINS, "\n");
2559
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->high_wm_hit_count,
2560
			   "high_wm_hit_count", HTT_STATS_HIGH_WM_BINS, "\n\n");
2561

2562
	if (len >= buf_len)
2563
		buf[buf_len - 1] = 0;
2564
	else
2565
		buf[len] = 0;
2566

2567
	stats_req->buf_len = len;
2568
}
2569

2570
static inline void htt_print_ring_if_cmn_tlv(const void *tag_buf,
2571
					     struct debug_htt_stats_req *stats_req)
2572
{
2573
	const struct htt_ring_if_cmn_tlv *htt_stats_buf = tag_buf;
2574
	u8 *buf = stats_req->buf;
2575
	u32 len = stats_req->buf_len;
2576
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2577

2578
	len += scnprintf(buf + len, buf_len - len, "HTT_RING_IF_CMN_TLV:\n");
2579
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2580
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
2581
	len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n",
2582
			 htt_stats_buf->num_records);
2583

2584
	if (len >= buf_len)
2585
		buf[buf_len - 1] = 0;
2586
	else
2587
		buf[len] = 0;
2588

2589
	stats_req->buf_len = len;
2590
}
2591

2592
static inline void htt_print_sfm_client_user_tlv_v(const void *tag_buf,
2593
						   u16 tag_len,
2594
						   struct debug_htt_stats_req *stats_req)
2595
{
2596
	const struct htt_sfm_client_user_tlv_v *htt_stats_buf = tag_buf;
2597
	u8 *buf = stats_req->buf;
2598
	u32 len = stats_req->buf_len;
2599
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2600
	u16 num_elems = tag_len >> 2;
2601

2602
	len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_USER_TLV_V:\n");
2603

2604
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->dwords_used_by_user_n,
2605
			   "dwords_used_by_user_n", num_elems, "\n\n");
2606

2607
	if (len >= buf_len)
2608
		buf[buf_len - 1] = 0;
2609
	else
2610
		buf[len] = 0;
2611

2612
	stats_req->buf_len = len;
2613
}
2614

2615
static inline void htt_print_sfm_client_tlv(const void *tag_buf,
2616
					    struct debug_htt_stats_req *stats_req)
2617
{
2618
	const struct htt_sfm_client_tlv *htt_stats_buf = tag_buf;
2619
	u8 *buf = stats_req->buf;
2620
	u32 len = stats_req->buf_len;
2621
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2622

2623
	len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CLIENT_TLV:\n");
2624
	len += scnprintf(buf + len, buf_len - len, "client_id = %u\n",
2625
			 htt_stats_buf->client_id);
2626
	len += scnprintf(buf + len, buf_len - len, "buf_min = %u\n",
2627
			 htt_stats_buf->buf_min);
2628
	len += scnprintf(buf + len, buf_len - len, "buf_max = %u\n",
2629
			 htt_stats_buf->buf_max);
2630
	len += scnprintf(buf + len, buf_len - len, "buf_busy = %u\n",
2631
			 htt_stats_buf->buf_busy);
2632
	len += scnprintf(buf + len, buf_len - len, "buf_alloc = %u\n",
2633
			 htt_stats_buf->buf_alloc);
2634
	len += scnprintf(buf + len, buf_len - len, "buf_avail = %u\n",
2635
			 htt_stats_buf->buf_avail);
2636
	len += scnprintf(buf + len, buf_len - len, "num_users = %u\n\n",
2637
			 htt_stats_buf->num_users);
2638

2639
	if (len >= buf_len)
2640
		buf[buf_len - 1] = 0;
2641
	else
2642
		buf[len] = 0;
2643

2644
	stats_req->buf_len = len;
2645
}
2646

2647
static inline void htt_print_sfm_cmn_tlv(const void *tag_buf,
2648
					 struct debug_htt_stats_req *stats_req)
2649
{
2650
	const struct htt_sfm_cmn_tlv *htt_stats_buf = tag_buf;
2651
	u8 *buf = stats_req->buf;
2652
	u32 len = stats_req->buf_len;
2653
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2654

2655
	len += scnprintf(buf + len, buf_len - len, "HTT_SFM_CMN_TLV:\n");
2656
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2657
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
2658
	len += scnprintf(buf + len, buf_len - len, "buf_total = %u\n",
2659
			 htt_stats_buf->buf_total);
2660
	len += scnprintf(buf + len, buf_len - len, "mem_empty = %u\n",
2661
			 htt_stats_buf->mem_empty);
2662
	len += scnprintf(buf + len, buf_len - len, "deallocate_bufs = %u\n",
2663
			 htt_stats_buf->deallocate_bufs);
2664
	len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n",
2665
			 htt_stats_buf->num_records);
2666

2667
	if (len >= buf_len)
2668
		buf[buf_len - 1] = 0;
2669
	else
2670
		buf[len] = 0;
2671

2672
	stats_req->buf_len = len;
2673
}
2674

2675
static inline void htt_print_sring_stats_tlv(const void *tag_buf,
2676
					     struct debug_htt_stats_req *stats_req)
2677
{
2678
	const struct htt_sring_stats_tlv *htt_stats_buf = tag_buf;
2679
	u8 *buf = stats_req->buf;
2680
	u32 len = stats_req->buf_len;
2681
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2682

2683
	len += scnprintf(buf + len, buf_len - len, "HTT_SRING_STATS_TLV:\n");
2684
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2685
			 FIELD_GET(HTT_SRING_STATS_MAC_ID,
2686
				   htt_stats_buf->mac_id__ring_id__arena__ep));
2687
	len += scnprintf(buf + len, buf_len - len, "ring_id = %lu\n",
2688
			 FIELD_GET(HTT_SRING_STATS_RING_ID,
2689
				   htt_stats_buf->mac_id__ring_id__arena__ep));
2690
	len += scnprintf(buf + len, buf_len - len, "arena = %lu\n",
2691
			 FIELD_GET(HTT_SRING_STATS_ARENA,
2692
				   htt_stats_buf->mac_id__ring_id__arena__ep));
2693
	len += scnprintf(buf + len, buf_len - len, "ep = %lu\n",
2694
			 FIELD_GET(HTT_SRING_STATS_EP,
2695
				   htt_stats_buf->mac_id__ring_id__arena__ep));
2696
	len += scnprintf(buf + len, buf_len - len, "base_addr_lsb = 0x%x\n",
2697
			 htt_stats_buf->base_addr_lsb);
2698
	len += scnprintf(buf + len, buf_len - len, "base_addr_msb = 0x%x\n",
2699
			 htt_stats_buf->base_addr_msb);
2700
	len += scnprintf(buf + len, buf_len - len, "ring_size = %u\n",
2701
			 htt_stats_buf->ring_size);
2702
	len += scnprintf(buf + len, buf_len - len, "elem_size = %u\n",
2703
			 htt_stats_buf->elem_size);
2704
	len += scnprintf(buf + len, buf_len - len, "num_avail_words = %lu\n",
2705
			 FIELD_GET(HTT_SRING_STATS_NUM_AVAIL_WORDS,
2706
				   htt_stats_buf->num_avail_words__num_valid_words));
2707
	len += scnprintf(buf + len, buf_len - len, "num_valid_words = %lu\n",
2708
			 FIELD_GET(HTT_SRING_STATS_NUM_VALID_WORDS,
2709
				   htt_stats_buf->num_avail_words__num_valid_words));
2710
	len += scnprintf(buf + len, buf_len - len, "head_ptr = %lu\n",
2711
			 FIELD_GET(HTT_SRING_STATS_HEAD_PTR,
2712
				   htt_stats_buf->head_ptr__tail_ptr));
2713
	len += scnprintf(buf + len, buf_len - len, "tail_ptr = %lu\n",
2714
			 FIELD_GET(HTT_SRING_STATS_TAIL_PTR,
2715
				   htt_stats_buf->head_ptr__tail_ptr));
2716
	len += scnprintf(buf + len, buf_len - len, "consumer_empty = %lu\n",
2717
			 FIELD_GET(HTT_SRING_STATS_CONSUMER_EMPTY,
2718
				   htt_stats_buf->consumer_empty__producer_full));
2719
	len += scnprintf(buf + len, buf_len - len, "producer_full = %lu\n",
2720
			 FIELD_GET(HTT_SRING_STATS_PRODUCER_FULL,
2721
				   htt_stats_buf->consumer_empty__producer_full));
2722
	len += scnprintf(buf + len, buf_len - len, "prefetch_count = %lu\n",
2723
			 FIELD_GET(HTT_SRING_STATS_PREFETCH_COUNT,
2724
				   htt_stats_buf->prefetch_count__internal_tail_ptr));
2725
	len += scnprintf(buf + len, buf_len - len, "internal_tail_ptr = %lu\n\n",
2726
			 FIELD_GET(HTT_SRING_STATS_INTERNAL_TAIL_PTR,
2727
				   htt_stats_buf->prefetch_count__internal_tail_ptr));
2728

2729
	if (len >= buf_len)
2730
		buf[buf_len - 1] = 0;
2731
	else
2732
		buf[len] = 0;
2733

2734
	stats_req->buf_len = len;
2735
}
2736

2737
static inline void htt_print_sring_cmn_tlv(const void *tag_buf,
2738
					   struct debug_htt_stats_req *stats_req)
2739
{
2740
	const struct htt_sring_cmn_tlv *htt_stats_buf = tag_buf;
2741
	u8 *buf = stats_req->buf;
2742
	u32 len = stats_req->buf_len;
2743
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2744

2745
	len += scnprintf(buf + len, buf_len - len, "HTT_SRING_CMN_TLV:\n");
2746
	len += scnprintf(buf + len, buf_len - len, "num_records = %u\n\n",
2747
			 htt_stats_buf->num_records);
2748

2749
	if (len >= buf_len)
2750
		buf[buf_len - 1] = 0;
2751
	else
2752
		buf[len] = 0;
2753

2754
	stats_req->buf_len = len;
2755
}
2756

2757
static inline void htt_print_tx_pdev_rate_stats_tlv(const void *tag_buf,
2758
						    struct debug_htt_stats_req *stats_req)
2759
{
2760
	const struct htt_tx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf;
2761
	u8 *buf = stats_req->buf;
2762
	u32 len = stats_req->buf_len;
2763
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2764
	u8 j;
2765

2766
	len += scnprintf(buf + len, buf_len - len, "HTT_TX_PDEV_RATE_STATS_TLV:\n");
2767
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2768
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
2769
	len += scnprintf(buf + len, buf_len - len, "tx_ldpc = %u\n",
2770
			 htt_stats_buf->tx_ldpc);
2771
	len += scnprintf(buf + len, buf_len - len, "ac_mu_mimo_tx_ldpc = %u\n",
2772
			 htt_stats_buf->ac_mu_mimo_tx_ldpc);
2773
	len += scnprintf(buf + len, buf_len - len, "ax_mu_mimo_tx_ldpc = %u\n",
2774
			 htt_stats_buf->ax_mu_mimo_tx_ldpc);
2775
	len += scnprintf(buf + len, buf_len - len, "ofdma_tx_ldpc = %u\n",
2776
			 htt_stats_buf->ofdma_tx_ldpc);
2777
	len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
2778
			 htt_stats_buf->rts_cnt);
2779
	len += scnprintf(buf + len, buf_len - len, "rts_success = %u\n",
2780
			 htt_stats_buf->rts_success);
2781
	len += scnprintf(buf + len, buf_len - len, "ack_rssi = %u\n",
2782
			 htt_stats_buf->ack_rssi);
2783

2784
	len += scnprintf(buf + len, buf_len - len,
2785
			 "Legacy CCK Rates: 1 Mbps: %u, 2 Mbps: %u, 5.5 Mbps: %u, 11 Mbps: %u\n",
2786
			 htt_stats_buf->tx_legacy_cck_rate[0],
2787
			 htt_stats_buf->tx_legacy_cck_rate[1],
2788
			 htt_stats_buf->tx_legacy_cck_rate[2],
2789
			 htt_stats_buf->tx_legacy_cck_rate[3]);
2790

2791
	len += scnprintf(buf + len, buf_len - len,
2792
			 "Legacy OFDM Rates: 6 Mbps: %u, 9 Mbps: %u, 12 Mbps: %u, 18 Mbps: %u\n"
2793
			 "                   24 Mbps: %u, 36 Mbps: %u, 48 Mbps: %u, 54 Mbps: %u\n",
2794
			 htt_stats_buf->tx_legacy_ofdm_rate[0],
2795
			 htt_stats_buf->tx_legacy_ofdm_rate[1],
2796
			 htt_stats_buf->tx_legacy_ofdm_rate[2],
2797
			 htt_stats_buf->tx_legacy_ofdm_rate[3],
2798
			 htt_stats_buf->tx_legacy_ofdm_rate[4],
2799
			 htt_stats_buf->tx_legacy_ofdm_rate[5],
2800
			 htt_stats_buf->tx_legacy_ofdm_rate[6],
2801
			 htt_stats_buf->tx_legacy_ofdm_rate[7]);
2802

2803
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_mcs, "tx_mcs",
2804
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2805
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_mcs,
2806
			   "ac_mu_mimo_tx_mcs", HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2807
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_mcs,
2808
			   "ax_mu_mimo_tx_mcs", HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2809
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_mcs, "ofdma_tx_mcs",
2810
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2811
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_nss, "tx_nss",
2812
			   HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
2813
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_nss,
2814
			   "ac_mu_mimo_tx_nss",
2815
			   HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
2816
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_nss,
2817
			   "ax_mu_mimo_tx_nss",
2818
			   HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
2819
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_nss, "ofdma_tx_nss",
2820
			   HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
2821
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_bw, "tx_bw",
2822
			   HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
2823
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_bw,
2824
			   "ac_mu_mimo_tx_bw", HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
2825
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_bw,
2826
			   "ax_mu_mimo_tx_bw",
2827
			   HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
2828
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_bw, "ofdma_tx_bw",
2829
			   HTT_TX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
2830
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_stbc, "tx_stbc",
2831
			   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2832
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_pream, "tx_pream",
2833
			   HTT_TX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");
2834

2835
	len += scnprintf(buf + len, buf_len - len, "HE LTF: 1x: %u, 2x: %u, 4x: %u\n",
2836
			 htt_stats_buf->tx_he_ltf[1],
2837
			 htt_stats_buf->tx_he_ltf[2],
2838
			 htt_stats_buf->tx_he_ltf[3]);
2839

2840
	/* SU GI Stats */
2841
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
2842
		len += scnprintf(buf + len, (buf_len - len),
2843
				 "tx_gi[%u] = ", j);
2844
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_gi[j], NULL,
2845
				   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2846
	}
2847

2848
	/* AC MU-MIMO GI Stats */
2849
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
2850
		len += scnprintf(buf + len, (buf_len - len),
2851
				 "ac_mu_mimo_tx_gi[%u] = ", j);
2852
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ac_mu_mimo_tx_gi[j],
2853
				   NULL, HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2854
	}
2855

2856
	/* AX MU-MIMO GI Stats */
2857
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
2858
		len += scnprintf(buf + len, (buf_len - len),
2859
				 "ax_mu_mimo_tx_gi[%u] = ", j);
2860
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ax_mu_mimo_tx_gi[j],
2861
				   NULL, HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2862
	}
2863

2864
	/* DL OFDMA GI Stats */
2865
	for (j = 0; j < HTT_TX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
2866
		len += scnprintf(buf + len, (buf_len - len),
2867
				 "ofdma_tx_gi[%u] = ", j);
2868
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ofdma_tx_gi[j], NULL,
2869
				   HTT_TX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2870
	}
2871

2872
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->tx_dcm, "tx_dcm",
2873
			   HTT_TX_PDEV_STATS_NUM_DCM_COUNTERS, "\n\n");
2874

2875
	if (len >= buf_len)
2876
		buf[buf_len - 1] = 0;
2877
	else
2878
		buf[len] = 0;
2879

2880
	stats_req->buf_len = len;
2881
}
2882

2883
static inline void htt_print_rx_pdev_rate_stats_tlv(const void *tag_buf,
2884
						    struct debug_htt_stats_req *stats_req)
2885
{
2886
	const struct htt_rx_pdev_rate_stats_tlv *htt_stats_buf = tag_buf;
2887
	u8 *buf = stats_req->buf;
2888
	u32 len = stats_req->buf_len;
2889
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
2890
	u8 i, j;
2891

2892
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_RATE_STATS_TLV:\n");
2893
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
2894
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
2895
	len += scnprintf(buf + len, buf_len - len, "nsts = %u\n",
2896
			 htt_stats_buf->nsts);
2897
	len += scnprintf(buf + len, buf_len - len, "rx_ldpc = %u\n",
2898
			 htt_stats_buf->rx_ldpc);
2899
	len += scnprintf(buf + len, buf_len - len, "rts_cnt = %u\n",
2900
			 htt_stats_buf->rts_cnt);
2901
	len += scnprintf(buf + len, buf_len - len, "rssi_mgmt = %u\n",
2902
			 htt_stats_buf->rssi_mgmt);
2903
	len += scnprintf(buf + len, buf_len - len, "rssi_data = %u\n",
2904
			 htt_stats_buf->rssi_data);
2905
	len += scnprintf(buf + len, buf_len - len, "rssi_comb = %u\n",
2906
			 htt_stats_buf->rssi_comb);
2907
	len += scnprintf(buf + len, buf_len - len, "rssi_in_dbm = %d\n",
2908
			 htt_stats_buf->rssi_in_dbm);
2909

2910
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_mcs, "rx_mcs",
2911
			   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2912
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_nss, "rx_nss",
2913
			   HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
2914
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_dcm, "rx_dcm",
2915
			   HTT_RX_PDEV_STATS_NUM_DCM_COUNTERS, "\n");
2916
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_stbc, "rx_stbc",
2917
			   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2918
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_bw, "rx_bw",
2919
			   HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
2920

2921
	len += scnprintf(buf + len, buf_len - len, "rx_evm_nss_count = %u\n",
2922
			 htt_stats_buf->nss_count);
2923

2924
	len += scnprintf(buf + len, buf_len - len, "rx_evm_pilot_count = %u\n",
2925
			 htt_stats_buf->pilot_count);
2926

2927
	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
2928
		len += scnprintf(buf + len, buf_len - len,
2929
				 "pilot_evm_db[%u] = ", j);
2930
		for (i = 0; i < HTT_RX_PDEV_STATS_RXEVM_MAX_PILOTS_PER_NSS; i++)
2931
			len += scnprintf(buf + len,
2932
					 buf_len - len,
2933
					 " %u:%d,",
2934
					 i,
2935
					 htt_stats_buf->rx_pilot_evm_db[j][i]);
2936
		len += scnprintf(buf + len, buf_len - len, "\n");
2937
	}
2938

2939
	len += scnprintf(buf + len, buf_len - len,
2940
			 "pilot_evm_db_mean = ");
2941
	for (i = 0; i < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
2942
		len += scnprintf(buf + len,
2943
				 buf_len - len,
2944
				 " %u:%d,", i,
2945
				 htt_stats_buf->rx_pilot_evm_db_mean[i]);
2946
	len += scnprintf(buf + len, buf_len - len, "\n");
2947

2948
	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
2949
		len += scnprintf(buf + len, buf_len - len,
2950
				 "rssi_chain[%u] = ", j);
2951
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rssi_chain[j], NULL,
2952
				   HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
2953
	}
2954

2955
	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
2956
		len += scnprintf(buf + len, buf_len - len,
2957
				 "rx_gi[%u] = ", j);
2958
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_gi[j], NULL,
2959
				   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
2960
	}
2961

2962
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_pream, "rx_pream",
2963
			   HTT_RX_PDEV_STATS_NUM_PREAMBLE_TYPES, "\n");
2964

2965
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_su_ext = %u\n",
2966
			 htt_stats_buf->rx_11ax_su_ext);
2967
	len += scnprintf(buf + len, buf_len - len, "rx_11ac_mumimo = %u\n",
2968
			 htt_stats_buf->rx_11ac_mumimo);
2969
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_mumimo = %u\n",
2970
			 htt_stats_buf->rx_11ax_mumimo);
2971
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_ofdma = %u\n",
2972
			 htt_stats_buf->rx_11ax_ofdma);
2973
	len += scnprintf(buf + len, buf_len - len, "txbf = %u\n",
2974
			 htt_stats_buf->txbf);
2975

2976
	len += scnprintf(buf + len, buf_len - len, "\nrx_su_ndpa = %u",
2977
			 htt_stats_buf->rx_su_ndpa);
2978
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_su_txbf_mcs,
2979
			   "rx_11ax_su_txbf_mcs", HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS,
2980
			   "\n");
2981

2982
	len += scnprintf(buf + len, buf_len - len, "\nrx_mu_ndpa = %u",
2983
			 htt_stats_buf->rx_mu_ndpa);
2984
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_mu_txbf_mcs,
2985
			   "rx_11ax_mu_txbf_mcs", HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS,
2986
			   "\n");
2987

2988
	len += scnprintf(buf + len, buf_len - len, "\nrx_br_poll = %u",
2989
			 htt_stats_buf->rx_br_poll);
2990

2991
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_legacy_cck_rate,
2992
			   "rx_legacy_cck_rate",
2993
			   HTT_RX_PDEV_STATS_NUM_LEGACY_CCK_STATS, "\n");
2994

2995
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_legacy_ofdm_rate,
2996
			   "rx_legacy_ofdm_rate",
2997
			   HTT_RX_PDEV_STATS_NUM_LEGACY_OFDM_STATS, "\n");
2998

2999
	len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_low = %u\n",
3000
			 htt_stats_buf->rx_active_dur_us_low);
3001
	len += scnprintf(buf + len, buf_len - len, "rx_active_dur_us_high = %u\n",
3002
			 htt_stats_buf->rx_active_dur_us_high);
3003
	len += scnprintf(buf + len, buf_len - len, "rx_11ax_ul_ofdma = %u\n",
3004
			 htt_stats_buf->rx_11ax_ul_ofdma);
3005

3006
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_mcs,
3007
			   "ul_ofdma_rx_mcs",
3008
			   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
3009

3010
	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_GI_COUNTERS; j++) {
3011
		len += scnprintf(buf + len, buf_len - len,
3012
				 "ul_ofdma_rx_gi[%u] = ", j);
3013
		PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_gi[j], NULL,
3014
				   HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS, "\n");
3015
	}
3016

3017
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_nss,
3018
			   "ul_ofdma_rx_nss",
3019
			   HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS, "\n");
3020

3021
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->ul_ofdma_rx_bw, "ul_ofdma_rx_bw",
3022
			   HTT_RX_PDEV_STATS_NUM_BW_COUNTERS, "\n");
3023

3024
	len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_stbc = %u\n",
3025
			htt_stats_buf->ul_ofdma_rx_stbc);
3026
	len += scnprintf(buf + len, buf_len - len, "ul_ofdma_rx_ldpc = %u\n",
3027
			htt_stats_buf->ul_ofdma_rx_ldpc);
3028

3029
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_non_data_ppdu,
3030
			   "rx_ulofdma_non_data_ppdu",
3031
			   HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
3032

3033
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_data_ppdu,
3034
			   "rx_ulofdma_data_ppdu", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
3035

3036
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_mpdu_ok,
3037
			   "rx_ulofdma_mpdu_ok", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
3038

3039
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_mpdu_fail,
3040
			   "rx_ulofdma_mpdu_fail", HTT_RX_PDEV_MAX_OFDMA_NUM_USER, "\n");
3041

3042
	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
3043
		len += scnprintf(buf + len, buf_len - len,
3044
				 "rx_ul_fd_rssi: nss[%u] = ", j);
3045
		for (i = 0; i < HTT_RX_PDEV_MAX_OFDMA_NUM_USER; i++)
3046
			len += scnprintf(buf + len,
3047
					 buf_len - len,
3048
					 " %u:%d,",
3049
					 i, htt_stats_buf->rx_ul_fd_rssi[j][i]);
3050
		len += scnprintf(buf + len, buf_len - len, "\n");
3051
	}
3052

3053
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_non_data_nusers,
3054
			   "rx_ulofdma_non_data_nusers", HTT_RX_PDEV_MAX_OFDMA_NUM_USER,
3055
			   "\n");
3056

3057
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulofdma_data_nusers,
3058
			   "rx_ulofdma_data_nusers", HTT_RX_PDEV_MAX_OFDMA_NUM_USER,
3059
			   "\n");
3060

3061
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_mcs,
3062
			   "rx_11ax_dl_ofdma_mcs", HTT_RX_PDEV_STATS_NUM_MCS_COUNTERS,
3063
			   "\n");
3064

3065
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_11ax_dl_ofdma_ru,
3066
			   "rx_11ax_dl_ofdma_ru", HTT_RX_PDEV_STATS_NUM_RU_SIZE_COUNTERS,
3067
			   "\n");
3068

3069
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_non_data_ppdu,
3070
			   "rx_ulmumimo_non_data_ppdu", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER,
3071
			   "\n");
3072

3073
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_data_ppdu,
3074
			   "rx_ulmumimo_data_ppdu", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER,
3075
			   "\n");
3076

3077
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_mpdu_ok,
3078
			   "rx_ulmumimo_mpdu_ok", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER,
3079
			   "\n");
3080

3081
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rx_ulmumimo_mpdu_fail,
3082
			   "rx_ulmumimo_mpdu_fail", HTT_RX_PDEV_MAX_ULMUMIMO_NUM_USER,
3083
			   "\n");
3084

3085
	len += scnprintf(buf + len, buf_len - len, "per_chain_rssi_pkt_type = %#x\n",
3086
			 htt_stats_buf->per_chain_rssi_pkt_type);
3087

3088
	for (j = 0; j < HTT_RX_PDEV_STATS_NUM_SPATIAL_STREAMS; j++) {
3089
		len += scnprintf(buf + len, buf_len - len,
3090
				 "rx_per_chain_rssi_in_dbm[%u] = ", j);
3091
		for (i = 0; i < HTT_RX_PDEV_STATS_NUM_BW_COUNTERS; i++)
3092
			len += scnprintf(buf + len,
3093
					 buf_len - len,
3094
					 " %u:%d,",
3095
					 i,
3096
					 htt_stats_buf->rx_per_chain_rssi_in_dbm[j][i]);
3097
		len += scnprintf(buf + len, buf_len - len, "\n");
3098
	}
3099
	len += scnprintf(buf + len, buf_len - len, "\n");
3100

3101
	if (len >= buf_len)
3102
		buf[buf_len - 1] = 0;
3103
	else
3104
		buf[len] = 0;
3105

3106
	stats_req->buf_len = len;
3107
}
3108

3109
static inline void htt_print_rx_soc_fw_stats_tlv(const void *tag_buf,
3110
						 struct debug_htt_stats_req *stats_req)
3111
{
3112
	const struct htt_rx_soc_fw_stats_tlv *htt_stats_buf = tag_buf;
3113
	u8 *buf = stats_req->buf;
3114
	u32 len = stats_req->buf_len;
3115
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3116

3117
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_SOC_FW_STATS_TLV:\n");
3118
	len += scnprintf(buf + len, buf_len - len, "fw_reo_ring_data_msdu = %u\n",
3119
			 htt_stats_buf->fw_reo_ring_data_msdu);
3120
	len += scnprintf(buf + len, buf_len - len, "fw_to_host_data_msdu_bcmc = %u\n",
3121
			 htt_stats_buf->fw_to_host_data_msdu_bcmc);
3122
	len += scnprintf(buf + len, buf_len - len, "fw_to_host_data_msdu_uc = %u\n",
3123
			 htt_stats_buf->fw_to_host_data_msdu_uc);
3124
	len += scnprintf(buf + len, buf_len - len,
3125
			 "ofld_remote_data_buf_recycle_cnt = %u\n",
3126
			 htt_stats_buf->ofld_remote_data_buf_recycle_cnt);
3127
	len += scnprintf(buf + len, buf_len - len,
3128
			 "ofld_remote_free_buf_indication_cnt = %u\n",
3129
			 htt_stats_buf->ofld_remote_free_buf_indication_cnt);
3130
	len += scnprintf(buf + len, buf_len - len,
3131
			 "ofld_buf_to_host_data_msdu_uc = %u\n",
3132
			 htt_stats_buf->ofld_buf_to_host_data_msdu_uc);
3133
	len += scnprintf(buf + len, buf_len - len,
3134
			 "reo_fw_ring_to_host_data_msdu_uc = %u\n",
3135
			 htt_stats_buf->reo_fw_ring_to_host_data_msdu_uc);
3136
	len += scnprintf(buf + len, buf_len - len, "wbm_sw_ring_reap = %u\n",
3137
			 htt_stats_buf->wbm_sw_ring_reap);
3138
	len += scnprintf(buf + len, buf_len - len, "wbm_forward_to_host_cnt = %u\n",
3139
			 htt_stats_buf->wbm_forward_to_host_cnt);
3140
	len += scnprintf(buf + len, buf_len - len, "wbm_target_recycle_cnt = %u\n",
3141
			 htt_stats_buf->wbm_target_recycle_cnt);
3142
	len += scnprintf(buf + len, buf_len - len,
3143
			 "target_refill_ring_recycle_cnt = %u\n",
3144
			 htt_stats_buf->target_refill_ring_recycle_cnt);
3145

3146
	if (len >= buf_len)
3147
		buf[buf_len - 1] = 0;
3148
	else
3149
		buf[len] = 0;
3150

3151
	stats_req->buf_len = len;
3152
}
3153

3154
static inline void
3155
htt_print_rx_soc_fw_refill_ring_empty_tlv_v(const void *tag_buf,
3156
					    u16 tag_len,
3157
					    struct debug_htt_stats_req *stats_req)
3158
{
3159
	const struct htt_rx_soc_fw_refill_ring_empty_tlv_v *htt_stats_buf = tag_buf;
3160
	u8 *buf = stats_req->buf;
3161
	u32 len = stats_req->buf_len;
3162
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3163
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_REFILL_MAX_RING);
3164

3165
	len += scnprintf(buf + len, buf_len - len,
3166
			 "HTT_RX_SOC_FW_REFILL_RING_EMPTY_TLV_V:\n");
3167

3168
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->refill_ring_empty_cnt,
3169
			   "refill_ring_empty_cnt", num_elems, "\n\n");
3170

3171
	if (len >= buf_len)
3172
		buf[buf_len - 1] = 0;
3173
	else
3174
		buf[len] = 0;
3175

3176
	stats_req->buf_len = len;
3177
}
3178

3179
static inline void
3180
htt_print_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v(const void *tag_buf,
3181
						    u16 tag_len,
3182
						    struct debug_htt_stats_req *stats_req)
3183
{
3184
	const struct htt_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v *htt_stats_buf =
3185
		tag_buf;
3186
	u8 *buf = stats_req->buf;
3187
	u32 len = stats_req->buf_len;
3188
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3189
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_RXDMA_MAX_ERR_CODE);
3190

3191
	len += scnprintf(buf + len, buf_len - len,
3192
			 "HTT_RX_SOC_FW_REFILL_RING_NUM_RXDMA_ERR_TLV_V:\n");
3193

3194
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->rxdma_err, "rxdma_err",
3195
			   num_elems, "\n\n");
3196

3197
	if (len >= buf_len)
3198
		buf[buf_len - 1] = 0;
3199
	else
3200
		buf[len] = 0;
3201

3202
	stats_req->buf_len = len;
3203
}
3204

3205
static inline void
3206
htt_print_rx_soc_fw_refill_ring_num_reo_err_tlv_v(const void *tag_buf,
3207
						  u16 tag_len,
3208
						  struct debug_htt_stats_req *stats_req)
3209
{
3210
	const struct htt_rx_soc_fw_refill_ring_num_reo_err_tlv_v *htt_stats_buf = tag_buf;
3211
	u8 *buf = stats_req->buf;
3212
	u32 len = stats_req->buf_len;
3213
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3214
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_REO_MAX_ERR_CODE);
3215

3216
	len += scnprintf(buf + len, buf_len - len,
3217
			 "HTT_RX_SOC_FW_REFILL_RING_NUM_REO_ERR_TLV_V:\n");
3218

3219
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->reo_err, "reo_err",
3220
			   num_elems, "\n\n");
3221

3222
	if (len >= buf_len)
3223
		buf[buf_len - 1] = 0;
3224
	else
3225
		buf[len] = 0;
3226

3227
	stats_req->buf_len = len;
3228
}
3229

3230
static inline void
3231
htt_print_rx_reo_debug_stats_tlv_v(const void *tag_buf,
3232
				   struct debug_htt_stats_req *stats_req)
3233
{
3234
	const struct htt_rx_reo_resource_stats_tlv_v *htt_stats_buf = tag_buf;
3235
	u8 *buf = stats_req->buf;
3236
	u32 len = stats_req->buf_len;
3237
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3238

3239
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_REO_RESOURCE_STATS_TLV:\n");
3240
	len += scnprintf(buf + len, buf_len - len, "sample_id = %u\n",
3241
			 htt_stats_buf->sample_id);
3242
	len += scnprintf(buf + len, buf_len - len, "total_max = %u\n",
3243
			 htt_stats_buf->total_max);
3244
	len += scnprintf(buf + len, buf_len - len, "total_avg = %u\n",
3245
			 htt_stats_buf->total_avg);
3246
	len += scnprintf(buf + len, buf_len - len, "total_sample = %u\n",
3247
			 htt_stats_buf->total_sample);
3248
	len += scnprintf(buf + len, buf_len - len, "non_zeros_avg = %u\n",
3249
			 htt_stats_buf->non_zeros_avg);
3250
	len += scnprintf(buf + len, buf_len - len, "non_zeros_sample = %u\n",
3251
			 htt_stats_buf->non_zeros_sample);
3252
	len += scnprintf(buf + len, buf_len - len, "last_non_zeros_max = %u\n",
3253
			 htt_stats_buf->last_non_zeros_max);
3254
	len += scnprintf(buf + len, buf_len - len, "last_non_zeros_min %u\n",
3255
			 htt_stats_buf->last_non_zeros_min);
3256
	len += scnprintf(buf + len, buf_len - len, "last_non_zeros_avg %u\n",
3257
			 htt_stats_buf->last_non_zeros_avg);
3258
	len += scnprintf(buf + len, buf_len - len, "last_non_zeros_sample %u\n\n",
3259
			 htt_stats_buf->last_non_zeros_sample);
3260

3261
	if (len >= buf_len)
3262
		buf[buf_len - 1] = 0;
3263
	else
3264
		buf[len] = 0;
3265

3266
	stats_req->buf_len = len;
3267
}
3268

3269
static inline void
3270
htt_print_rx_soc_fw_refill_ring_num_refill_tlv_v(const void *tag_buf,
3271
						 u16 tag_len,
3272
						 struct debug_htt_stats_req *stats_req)
3273
{
3274
	const struct htt_rx_soc_fw_refill_ring_num_refill_tlv_v *htt_stats_buf = tag_buf;
3275
	u8 *buf = stats_req->buf;
3276
	u32 len = stats_req->buf_len;
3277
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3278
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_REFILL_MAX_RING);
3279

3280
	len += scnprintf(buf + len, buf_len - len,
3281
			 "HTT_RX_SOC_FW_REFILL_RING_NUM_REFILL_TLV_V:\n");
3282

3283
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->refill_ring_num_refill,
3284
			   "refill_ring_num_refill", num_elems, "\n\n");
3285

3286
	if (len >= buf_len)
3287
		buf[buf_len - 1] = 0;
3288
	else
3289
		buf[len] = 0;
3290

3291
	stats_req->buf_len = len;
3292
}
3293

3294
static inline void htt_print_rx_pdev_fw_stats_tlv(const void *tag_buf,
3295
						  struct debug_htt_stats_req *stats_req)
3296
{
3297
	const struct htt_rx_pdev_fw_stats_tlv *htt_stats_buf = tag_buf;
3298
	u8 *buf = stats_req->buf;
3299
	u32 len = stats_req->buf_len;
3300
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3301

3302
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_TLV:\n");
3303
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
3304
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
3305
	len += scnprintf(buf + len, buf_len - len, "ppdu_recvd = %u\n",
3306
			 htt_stats_buf->ppdu_recvd);
3307
	len += scnprintf(buf + len, buf_len - len, "mpdu_cnt_fcs_ok = %u\n",
3308
			 htt_stats_buf->mpdu_cnt_fcs_ok);
3309
	len += scnprintf(buf + len, buf_len - len, "mpdu_cnt_fcs_err = %u\n",
3310
			 htt_stats_buf->mpdu_cnt_fcs_err);
3311
	len += scnprintf(buf + len, buf_len - len, "tcp_msdu_cnt = %u\n",
3312
			 htt_stats_buf->tcp_msdu_cnt);
3313
	len += scnprintf(buf + len, buf_len - len, "tcp_ack_msdu_cnt = %u\n",
3314
			 htt_stats_buf->tcp_ack_msdu_cnt);
3315
	len += scnprintf(buf + len, buf_len - len, "udp_msdu_cnt = %u\n",
3316
			 htt_stats_buf->udp_msdu_cnt);
3317
	len += scnprintf(buf + len, buf_len - len, "other_msdu_cnt = %u\n",
3318
			 htt_stats_buf->other_msdu_cnt);
3319
	len += scnprintf(buf + len, buf_len - len, "fw_ring_mpdu_ind = %u\n",
3320
			 htt_stats_buf->fw_ring_mpdu_ind);
3321

3322
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_mgmt_subtype,
3323
			   "fw_ring_mgmt_subtype", HTT_STATS_SUBTYPE_MAX, "\n");
3324

3325
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_ctrl_subtype,
3326
			   "fw_ring_ctrl_subtype", HTT_STATS_SUBTYPE_MAX, "\n");
3327

3328
	len += scnprintf(buf + len, buf_len - len, "fw_ring_mcast_data_msdu = %u\n",
3329
			 htt_stats_buf->fw_ring_mcast_data_msdu);
3330
	len += scnprintf(buf + len, buf_len - len, "fw_ring_bcast_data_msdu = %u\n",
3331
			 htt_stats_buf->fw_ring_bcast_data_msdu);
3332
	len += scnprintf(buf + len, buf_len - len, "fw_ring_ucast_data_msdu = %u\n",
3333
			 htt_stats_buf->fw_ring_ucast_data_msdu);
3334
	len += scnprintf(buf + len, buf_len - len, "fw_ring_null_data_msdu = %u\n",
3335
			 htt_stats_buf->fw_ring_null_data_msdu);
3336
	len += scnprintf(buf + len, buf_len - len, "fw_ring_mpdu_drop = %u\n",
3337
			 htt_stats_buf->fw_ring_mpdu_drop);
3338
	len += scnprintf(buf + len, buf_len - len, "ofld_local_data_ind_cnt = %u\n",
3339
			 htt_stats_buf->ofld_local_data_ind_cnt);
3340
	len += scnprintf(buf + len, buf_len - len,
3341
			 "ofld_local_data_buf_recycle_cnt = %u\n",
3342
			 htt_stats_buf->ofld_local_data_buf_recycle_cnt);
3343
	len += scnprintf(buf + len, buf_len - len, "drx_local_data_ind_cnt = %u\n",
3344
			 htt_stats_buf->drx_local_data_ind_cnt);
3345
	len += scnprintf(buf + len, buf_len - len,
3346
			 "drx_local_data_buf_recycle_cnt = %u\n",
3347
			 htt_stats_buf->drx_local_data_buf_recycle_cnt);
3348
	len += scnprintf(buf + len, buf_len - len, "local_nondata_ind_cnt = %u\n",
3349
			 htt_stats_buf->local_nondata_ind_cnt);
3350
	len += scnprintf(buf + len, buf_len - len, "local_nondata_buf_recycle_cnt = %u\n",
3351
			 htt_stats_buf->local_nondata_buf_recycle_cnt);
3352
	len += scnprintf(buf + len, buf_len - len, "fw_status_buf_ring_refill_cnt = %u\n",
3353
			 htt_stats_buf->fw_status_buf_ring_refill_cnt);
3354
	len += scnprintf(buf + len, buf_len - len, "fw_status_buf_ring_empty_cnt = %u\n",
3355
			 htt_stats_buf->fw_status_buf_ring_empty_cnt);
3356
	len += scnprintf(buf + len, buf_len - len, "fw_pkt_buf_ring_refill_cnt = %u\n",
3357
			 htt_stats_buf->fw_pkt_buf_ring_refill_cnt);
3358
	len += scnprintf(buf + len, buf_len - len, "fw_pkt_buf_ring_empty_cnt = %u\n",
3359
			 htt_stats_buf->fw_pkt_buf_ring_empty_cnt);
3360
	len += scnprintf(buf + len, buf_len - len, "fw_link_buf_ring_refill_cnt = %u\n",
3361
			 htt_stats_buf->fw_link_buf_ring_refill_cnt);
3362
	len += scnprintf(buf + len, buf_len - len, "fw_link_buf_ring_empty_cnt = %u\n",
3363
			 htt_stats_buf->fw_link_buf_ring_empty_cnt);
3364
	len += scnprintf(buf + len, buf_len - len, "host_pkt_buf_ring_refill_cnt = %u\n",
3365
			 htt_stats_buf->host_pkt_buf_ring_refill_cnt);
3366
	len += scnprintf(buf + len, buf_len - len, "host_pkt_buf_ring_empty_cnt = %u\n",
3367
			 htt_stats_buf->host_pkt_buf_ring_empty_cnt);
3368
	len += scnprintf(buf + len, buf_len - len, "mon_pkt_buf_ring_refill_cnt = %u\n",
3369
			 htt_stats_buf->mon_pkt_buf_ring_refill_cnt);
3370
	len += scnprintf(buf + len, buf_len - len, "mon_pkt_buf_ring_empty_cnt = %u\n",
3371
			 htt_stats_buf->mon_pkt_buf_ring_empty_cnt);
3372
	len += scnprintf(buf + len, buf_len - len,
3373
			 "mon_status_buf_ring_refill_cnt = %u\n",
3374
			 htt_stats_buf->mon_status_buf_ring_refill_cnt);
3375
	len += scnprintf(buf + len, buf_len - len, "mon_status_buf_ring_empty_cnt = %u\n",
3376
			 htt_stats_buf->mon_status_buf_ring_empty_cnt);
3377
	len += scnprintf(buf + len, buf_len - len, "mon_desc_buf_ring_refill_cnt = %u\n",
3378
			 htt_stats_buf->mon_desc_buf_ring_refill_cnt);
3379
	len += scnprintf(buf + len, buf_len - len, "mon_desc_buf_ring_empty_cnt = %u\n",
3380
			 htt_stats_buf->mon_desc_buf_ring_empty_cnt);
3381
	len += scnprintf(buf + len, buf_len - len, "mon_dest_ring_update_cnt = %u\n",
3382
			 htt_stats_buf->mon_dest_ring_update_cnt);
3383
	len += scnprintf(buf + len, buf_len - len, "mon_dest_ring_full_cnt = %u\n",
3384
			 htt_stats_buf->mon_dest_ring_full_cnt);
3385
	len += scnprintf(buf + len, buf_len - len, "rx_suspend_cnt = %u\n",
3386
			 htt_stats_buf->rx_suspend_cnt);
3387
	len += scnprintf(buf + len, buf_len - len, "rx_suspend_fail_cnt = %u\n",
3388
			 htt_stats_buf->rx_suspend_fail_cnt);
3389
	len += scnprintf(buf + len, buf_len - len, "rx_resume_cnt = %u\n",
3390
			 htt_stats_buf->rx_resume_cnt);
3391
	len += scnprintf(buf + len, buf_len - len, "rx_resume_fail_cnt = %u\n",
3392
			 htt_stats_buf->rx_resume_fail_cnt);
3393
	len += scnprintf(buf + len, buf_len - len, "rx_ring_switch_cnt = %u\n",
3394
			 htt_stats_buf->rx_ring_switch_cnt);
3395
	len += scnprintf(buf + len, buf_len - len, "rx_ring_restore_cnt = %u\n",
3396
			 htt_stats_buf->rx_ring_restore_cnt);
3397
	len += scnprintf(buf + len, buf_len - len, "rx_flush_cnt = %u\n",
3398
			 htt_stats_buf->rx_flush_cnt);
3399
	len += scnprintf(buf + len, buf_len - len, "rx_recovery_reset_cnt = %u\n\n",
3400
			 htt_stats_buf->rx_recovery_reset_cnt);
3401

3402
	if (len >= buf_len)
3403
		buf[buf_len - 1] = 0;
3404
	else
3405
		buf[len] = 0;
3406

3407
	stats_req->buf_len = len;
3408
}
3409

3410
static inline void
3411
htt_print_rx_pdev_fw_ring_mpdu_err_tlv_v(const void *tag_buf,
3412
					 struct debug_htt_stats_req *stats_req)
3413
{
3414
	const struct htt_rx_pdev_fw_ring_mpdu_err_tlv_v *htt_stats_buf = tag_buf;
3415
	u8 *buf = stats_req->buf;
3416
	u32 len = stats_req->buf_len;
3417
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3418

3419
	len += scnprintf(buf + len, buf_len - len,
3420
			 "HTT_RX_PDEV_FW_RING_MPDU_ERR_TLV_V:\n");
3421

3422
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_ring_mpdu_err,
3423
			   "fw_ring_mpdu_err", HTT_RX_STATS_RXDMA_MAX_ERR, "\n");
3424

3425
	if (len >= buf_len)
3426
		buf[buf_len - 1] = 0;
3427
	else
3428
		buf[len] = 0;
3429

3430
	stats_req->buf_len = len;
3431
}
3432

3433
static inline void
3434
htt_print_rx_pdev_fw_mpdu_drop_tlv_v(const void *tag_buf,
3435
				     u16 tag_len,
3436
				     struct debug_htt_stats_req *stats_req)
3437
{
3438
	const struct htt_rx_pdev_fw_mpdu_drop_tlv_v *htt_stats_buf = tag_buf;
3439
	u8 *buf = stats_req->buf;
3440
	u32 len = stats_req->buf_len;
3441
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3442
	u16 num_elems = min_t(u16, (tag_len >> 2), HTT_RX_STATS_FW_DROP_REASON_MAX);
3443

3444
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_MPDU_DROP_TLV_V:\n");
3445

3446
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->fw_mpdu_drop, "fw_mpdu_drop",
3447
			   num_elems, "\n\n");
3448

3449
	if (len >= buf_len)
3450
		buf[buf_len - 1] = 0;
3451
	else
3452
		buf[len] = 0;
3453

3454
	stats_req->buf_len = len;
3455
}
3456

3457
static inline void
3458
htt_print_rx_pdev_fw_stats_phy_err_tlv(const void *tag_buf,
3459
				       struct debug_htt_stats_req *stats_req)
3460
{
3461
	const struct htt_rx_pdev_fw_stats_phy_err_tlv *htt_stats_buf = tag_buf;
3462
	u8 *buf = stats_req->buf;
3463
	u32 len = stats_req->buf_len;
3464
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3465

3466
	len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_PHY_ERR_TLV:\n");
3467
	len += scnprintf(buf + len, buf_len - len, "mac_id__word = %u\n",
3468
			 htt_stats_buf->mac_id__word);
3469
	len += scnprintf(buf + len, buf_len - len, "total_phy_err_nct = %u\n",
3470
			 htt_stats_buf->total_phy_err_cnt);
3471

3472
	PRINT_ARRAY_TO_BUF(buf, len, htt_stats_buf->phy_err, "phy_errs",
3473
			   HTT_STATS_PHY_ERR_MAX, "\n\n");
3474

3475
	if (len >= buf_len)
3476
		buf[buf_len - 1] = 0;
3477
	else
3478
		buf[len] = 0;
3479

3480
	stats_req->buf_len = len;
3481
}
3482

3483
static inline void
3484
htt_print_pdev_cca_stats_hist_tlv(const void *tag_buf,
3485
				  struct debug_htt_stats_req *stats_req)
3486
{
3487
	const struct htt_pdev_cca_stats_hist_v1_tlv *htt_stats_buf = tag_buf;
3488
	u8 *buf = stats_req->buf;
3489
	u32 len = stats_req->buf_len;
3490
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3491

3492
	len += scnprintf(buf + len, buf_len - len, "\nHTT_PDEV_CCA_STATS_HIST_TLV:\n");
3493
	len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n",
3494
			 htt_stats_buf->chan_num);
3495
	len += scnprintf(buf + len, buf_len - len, "num_records = %u\n",
3496
			 htt_stats_buf->num_records);
3497
	len += scnprintf(buf + len, buf_len - len, "valid_cca_counters_bitmap = 0x%x\n",
3498
			 htt_stats_buf->valid_cca_counters_bitmap);
3499
	len += scnprintf(buf + len, buf_len - len, "collection_interval = %u\n\n",
3500
			 htt_stats_buf->collection_interval);
3501

3502
	len += scnprintf(buf + len, buf_len - len,
3503
			 "HTT_PDEV_STATS_CCA_COUNTERS_TLV:(in usec)\n");
3504
	len += scnprintf(buf + len, buf_len - len,
3505
			 "|  tx_frame|   rx_frame|   rx_clear| my_rx_frame|        cnt| med_rx_idle| med_tx_idle_global|   cca_obss|\n");
3506

3507
	if (len >= buf_len)
3508
		buf[buf_len - 1] = 0;
3509
	else
3510
		buf[len] = 0;
3511

3512
	stats_req->buf_len = len;
3513
}
3514

3515
static inline void
3516
htt_print_pdev_stats_cca_counters_tlv(const void *tag_buf,
3517
				      struct debug_htt_stats_req *stats_req)
3518
{
3519
	const struct htt_pdev_stats_cca_counters_tlv *htt_stats_buf = tag_buf;
3520
	u8 *buf = stats_req->buf;
3521
	u32 len = stats_req->buf_len;
3522
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3523

3524
	len += scnprintf(buf + len, buf_len - len,
3525
			 "|%10u| %10u| %10u| %11u| %10u| %11u| %18u| %10u|\n",
3526
			 htt_stats_buf->tx_frame_usec,
3527
			 htt_stats_buf->rx_frame_usec,
3528
			 htt_stats_buf->rx_clear_usec,
3529
			 htt_stats_buf->my_rx_frame_usec,
3530
			 htt_stats_buf->usec_cnt,
3531
			 htt_stats_buf->med_rx_idle_usec,
3532
			 htt_stats_buf->med_tx_idle_global_usec,
3533
			 htt_stats_buf->cca_obss_usec);
3534

3535
	if (len >= buf_len)
3536
		buf[buf_len - 1] = 0;
3537
	else
3538
		buf[len] = 0;
3539

3540
	stats_req->buf_len = len;
3541
}
3542

3543
static inline void htt_print_hw_stats_whal_tx_tlv(const void *tag_buf,
3544
						  struct debug_htt_stats_req *stats_req)
3545
{
3546
	const struct htt_hw_stats_whal_tx_tlv *htt_stats_buf = tag_buf;
3547
	u8 *buf = stats_req->buf;
3548
	u32 len = stats_req->buf_len;
3549
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3550

3551
	len += scnprintf(buf + len, buf_len - len, "HTT_HW_STATS_WHAL_TX_TLV:\n");
3552
	len += scnprintf(buf + len, buf_len - len, "mac_id = %lu\n",
3553
			 FIELD_GET(HTT_STATS_MAC_ID, htt_stats_buf->mac_id__word));
3554
	len += scnprintf(buf + len, buf_len - len, "last_unpause_ppdu_id = %u\n",
3555
			 htt_stats_buf->last_unpause_ppdu_id);
3556
	len += scnprintf(buf + len, buf_len - len, "hwsch_unpause_wait_tqm_write = %u\n",
3557
			 htt_stats_buf->hwsch_unpause_wait_tqm_write);
3558
	len += scnprintf(buf + len, buf_len - len, "hwsch_dummy_tlv_skipped = %u\n",
3559
			 htt_stats_buf->hwsch_dummy_tlv_skipped);
3560
	len += scnprintf(buf + len, buf_len - len,
3561
			 "hwsch_misaligned_offset_received = %u\n",
3562
			 htt_stats_buf->hwsch_misaligned_offset_received);
3563
	len += scnprintf(buf + len, buf_len - len, "hwsch_reset_count = %u\n",
3564
			 htt_stats_buf->hwsch_reset_count);
3565
	len += scnprintf(buf + len, buf_len - len, "hwsch_dev_reset_war = %u\n",
3566
			 htt_stats_buf->hwsch_dev_reset_war);
3567
	len += scnprintf(buf + len, buf_len - len, "hwsch_delayed_pause = %u\n",
3568
			 htt_stats_buf->hwsch_delayed_pause);
3569
	len += scnprintf(buf + len, buf_len - len, "hwsch_long_delayed_pause = %u\n",
3570
			 htt_stats_buf->hwsch_long_delayed_pause);
3571
	len += scnprintf(buf + len, buf_len - len, "sch_rx_ppdu_no_response = %u\n",
3572
			 htt_stats_buf->sch_rx_ppdu_no_response);
3573
	len += scnprintf(buf + len, buf_len - len, "sch_selfgen_response = %u\n",
3574
			 htt_stats_buf->sch_selfgen_response);
3575
	len += scnprintf(buf + len, buf_len - len, "sch_rx_sifs_resp_trigger= %u\n\n",
3576
			 htt_stats_buf->sch_rx_sifs_resp_trigger);
3577

3578
	if (len >= buf_len)
3579
		buf[buf_len - 1] = 0;
3580
	else
3581
		buf[len] = 0;
3582

3583
	stats_req->buf_len = len;
3584
}
3585

3586
static inline void
3587
htt_print_pdev_stats_twt_sessions_tlv(const void *tag_buf,
3588
				      struct debug_htt_stats_req *stats_req)
3589
{
3590
	const struct htt_pdev_stats_twt_sessions_tlv *htt_stats_buf = tag_buf;
3591
	u8 *buf = stats_req->buf;
3592
	u32 len = stats_req->buf_len;
3593
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3594

3595
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_STATS_TWT_SESSIONS_TLV:\n");
3596
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
3597
			 htt_stats_buf->pdev_id);
3598
	len += scnprintf(buf + len, buf_len - len, "num_sessions = %u\n\n",
3599
			 htt_stats_buf->num_sessions);
3600

3601
	if (len >= buf_len)
3602
		buf[buf_len - 1] = 0;
3603
	else
3604
		buf[len] = 0;
3605

3606
	stats_req->buf_len = len;
3607
}
3608

3609
static inline void
3610
htt_print_pdev_stats_twt_session_tlv(const void *tag_buf,
3611
				     struct debug_htt_stats_req *stats_req)
3612
{
3613
	const struct htt_pdev_stats_twt_session_tlv *htt_stats_buf = tag_buf;
3614
	u8 *buf = stats_req->buf;
3615
	u32 len = stats_req->buf_len;
3616
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3617

3618
	len += scnprintf(buf + len, buf_len - len, "HTT_PDEV_STATS_TWT_SESSION_TLV:\n");
3619
	len += scnprintf(buf + len, buf_len - len, "vdev_id = %u\n",
3620
			 htt_stats_buf->vdev_id);
3621
	len += scnprintf(buf + len, buf_len - len,
3622
			 "peer_mac = %02lx:%02lx:%02lx:%02lx:%02lx:%02lx\n",
3623
			 FIELD_GET(HTT_MAC_ADDR_L32_0,
3624
				   htt_stats_buf->peer_mac.mac_addr_l32),
3625
			 FIELD_GET(HTT_MAC_ADDR_L32_1,
3626
				   htt_stats_buf->peer_mac.mac_addr_l32),
3627
			 FIELD_GET(HTT_MAC_ADDR_L32_2,
3628
				   htt_stats_buf->peer_mac.mac_addr_l32),
3629
			 FIELD_GET(HTT_MAC_ADDR_L32_3,
3630
				   htt_stats_buf->peer_mac.mac_addr_l32),
3631
			 FIELD_GET(HTT_MAC_ADDR_H16_0,
3632
				   htt_stats_buf->peer_mac.mac_addr_h16),
3633
			 FIELD_GET(HTT_MAC_ADDR_H16_1,
3634
				   htt_stats_buf->peer_mac.mac_addr_h16));
3635
	len += scnprintf(buf + len, buf_len - len, "flow_id_flags = %u\n",
3636
			 htt_stats_buf->flow_id_flags);
3637
	len += scnprintf(buf + len, buf_len - len, "dialog_id = %u\n",
3638
			 htt_stats_buf->dialog_id);
3639
	len += scnprintf(buf + len, buf_len - len, "wake_dura_us = %u\n",
3640
			 htt_stats_buf->wake_dura_us);
3641
	len += scnprintf(buf + len, buf_len - len, "wake_intvl_us = %u\n",
3642
			 htt_stats_buf->wake_intvl_us);
3643
	len += scnprintf(buf + len, buf_len - len, "sp_offset_us = %u\n\n",
3644
			 htt_stats_buf->sp_offset_us);
3645

3646
	if (len >= buf_len)
3647
		buf[buf_len - 1] = 0;
3648
	else
3649
		buf[len] = 0;
3650

3651
	stats_req->buf_len = len;
3652
}
3653

3654
static inline void
3655
htt_print_pdev_obss_pd_stats_tlv_v(const void *tag_buf,
3656
				   struct debug_htt_stats_req *stats_req)
3657
{
3658
	const struct htt_pdev_obss_pd_stats_tlv *htt_stats_buf = tag_buf;
3659
	u8 *buf = stats_req->buf;
3660
	u32 len = stats_req->buf_len;
3661
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3662

3663
	len += scnprintf(buf + len, buf_len - len, "OBSS Tx success PPDU = %u\n",
3664
			   htt_stats_buf->num_obss_tx_ppdu_success);
3665
	len += scnprintf(buf + len, buf_len - len, "OBSS Tx failures PPDU = %u\n",
3666
			   htt_stats_buf->num_obss_tx_ppdu_failure);
3667
	len += scnprintf(buf + len, buf_len - len, "Non-SRG Opportunities = %u\n",
3668
			   htt_stats_buf->num_non_srg_opportunities);
3669
	len += scnprintf(buf + len, buf_len - len, "Non-SRG tried PPDU = %u\n",
3670
			   htt_stats_buf->num_non_srg_ppdu_tried);
3671
	len += scnprintf(buf + len, buf_len - len, "Non-SRG success PPDU = %u\n",
3672
			   htt_stats_buf->num_non_srg_ppdu_success);
3673
	len += scnprintf(buf + len, buf_len - len, "SRG Opportunities = %u\n",
3674
			   htt_stats_buf->num_srg_opportunities);
3675
	len += scnprintf(buf + len, buf_len - len, "SRG tried PPDU = %u\n",
3676
			   htt_stats_buf->num_srg_ppdu_tried);
3677
	len += scnprintf(buf + len, buf_len - len, "SRG success PPDU = %u\n\n",
3678
			   htt_stats_buf->num_srg_ppdu_success);
3679

3680
	if (len >= buf_len)
3681
		buf[buf_len - 1] = 0;
3682
	else
3683
		buf[len] = 0;
3684

3685
	stats_req->buf_len = len;
3686
}
3687

3688
static inline void htt_print_backpressure_stats_tlv_v(const u32 *tag_buf,
3689
						      u8 *data)
3690
{
3691
	struct debug_htt_stats_req *stats_req =
3692
			(struct debug_htt_stats_req *)data;
3693
	struct htt_ring_backpressure_stats_tlv *htt_stats_buf =
3694
			(struct htt_ring_backpressure_stats_tlv *)tag_buf;
3695
	int i;
3696
	u8 *buf = stats_req->buf;
3697
	u32 len = stats_req->buf_len;
3698
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3699

3700
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
3701
			 htt_stats_buf->pdev_id);
3702
	len += scnprintf(buf + len, buf_len - len, "current_head_idx = %u\n",
3703
			 htt_stats_buf->current_head_idx);
3704
	len += scnprintf(buf + len, buf_len - len, "current_tail_idx = %u\n",
3705
			 htt_stats_buf->current_tail_idx);
3706
	len += scnprintf(buf + len, buf_len - len, "num_htt_msgs_sent = %u\n",
3707
			 htt_stats_buf->num_htt_msgs_sent);
3708
	len += scnprintf(buf + len, buf_len - len,
3709
			 "backpressure_time_ms = %u\n",
3710
			 htt_stats_buf->backpressure_time_ms);
3711

3712
	for (i = 0; i < 5; i++)
3713
		len += scnprintf(buf + len, buf_len - len,
3714
				 "backpressure_hist_%u = %u\n",
3715
				 i + 1, htt_stats_buf->backpressure_hist[i]);
3716

3717
	len += scnprintf(buf + len, buf_len - len,
3718
			 "============================\n");
3719

3720
	if (len >= buf_len) {
3721
		buf[buf_len - 1] = 0;
3722
		stats_req->buf_len = buf_len - 1;
3723
	} else {
3724
		buf[len] = 0;
3725
		stats_req->buf_len = len;
3726
	}
3727
}
3728

3729
static inline
3730
void htt_print_pdev_tx_rate_txbf_stats_tlv(const void *tag_buf,
3731
					   struct debug_htt_stats_req *stats_req)
3732
{
3733
	const struct htt_pdev_txrate_txbf_stats_tlv *htt_stats_buf = tag_buf;
3734
	u8 *buf = stats_req->buf;
3735
	u32 len = stats_req->buf_len;
3736
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3737
	int i;
3738

3739
	len += scnprintf(buf + len, buf_len - len,
3740
			 "HTT_STATS_PDEV_TX_RATE_TXBF_STATS:\n");
3741

3742
	len += scnprintf(buf + len, buf_len - len, "tx_ol_mcs = ");
3743
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++)
3744
		len += scnprintf(buf + len, buf_len - len,
3745
				 "%d:%u,", i, htt_stats_buf->tx_su_ol_mcs[i]);
3746
	len--;
3747

3748
	len += scnprintf(buf + len, buf_len - len, "\ntx_ibf_mcs = ");
3749
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++)
3750
		len += scnprintf(buf + len, buf_len - len,
3751
				 "%d:%u,", i, htt_stats_buf->tx_su_ibf_mcs[i]);
3752
	len--;
3753

3754
	len += scnprintf(buf + len, buf_len - len, "\ntx_txbf_mcs =");
3755
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_MCS_COUNTERS; i++)
3756
		len += scnprintf(buf + len, buf_len - len,
3757
				 "%d:%u,", i, htt_stats_buf->tx_su_txbf_mcs[i]);
3758
	len--;
3759

3760
	len += scnprintf(buf + len, buf_len - len, "\ntx_ol_nss = ");
3761
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
3762
		len += scnprintf(buf + len, buf_len - len,
3763
				 "%d:%u,", i, htt_stats_buf->tx_su_ol_nss[i]);
3764
	len--;
3765

3766
	len += scnprintf(buf + len, buf_len - len, "\ntx_ibf_nss = ");
3767
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
3768
		len += scnprintf(buf + len, buf_len - len,
3769
				 "%d:%u,", i, htt_stats_buf->tx_su_ibf_nss[i]);
3770
	len--;
3771

3772
	len += scnprintf(buf + len, buf_len - len, "\ntx_txbf_nss = ");
3773
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_SPATIAL_STREAMS; i++)
3774
		len += scnprintf(buf + len, buf_len - len,
3775
				 "%d:%u,", i, htt_stats_buf->tx_su_txbf_nss[i]);
3776
	len--;
3777

3778
	len += scnprintf(buf + len, buf_len - len, "\ntx_ol_bw = ");
3779
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++)
3780
		len += scnprintf(buf + len, buf_len - len,
3781
				 "%d:%u,", i, htt_stats_buf->tx_su_ol_bw[i]);
3782
	len--;
3783

3784
	len += scnprintf(buf + len, buf_len - len, "\ntx_ibf_bw = ");
3785
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++)
3786
		len += scnprintf(buf + len, buf_len - len,
3787
				 "%d:%u,", i, htt_stats_buf->tx_su_ibf_bw[i]);
3788
	len--;
3789

3790
	len += scnprintf(buf + len, buf_len - len, "\ntx_txbf_bw = ");
3791
	for (i = 0; i < HTT_TX_TXBF_RATE_STATS_NUM_BW_COUNTERS; i++)
3792
		len += scnprintf(buf + len, buf_len - len,
3793
				 "%d:%u,", i, htt_stats_buf->tx_su_txbf_bw[i]);
3794
	len--;
3795

3796
	len += scnprintf(buf + len, buf_len - len, "\n");
3797

3798
	stats_req->buf_len = len;
3799
}
3800

3801
static inline
3802
void htt_print_txbf_ofdma_ndpa_stats_tlv(const void *tag_buf,
3803
					 struct debug_htt_stats_req *stats_req)
3804
{
3805
	const struct htt_txbf_ofdma_ndpa_stats_tlv *htt_stats_buf = tag_buf;
3806
	u8 *buf = stats_req->buf;
3807
	u32 len = stats_req->buf_len;
3808
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3809
	int i;
3810

3811
	len += scnprintf(buf + len, buf_len - len,
3812
			 "HTT_TXBF_OFDMA_NDPA_STATS_TLV:\n");
3813

3814
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
3815
		len += scnprintf(buf + len, buf_len - len,
3816
				 "ax_ofdma_ndpa_queued_user%d = %u\n",
3817
				 i, htt_stats_buf->ax_ofdma_ndpa_queued[i]);
3818
		len += scnprintf(buf + len, buf_len - len,
3819
				 "ax_ofdma_ndpa_tried_user%d = %u\n",
3820
				 i, htt_stats_buf->ax_ofdma_ndpa_tried[i]);
3821
		len += scnprintf(buf + len, buf_len - len,
3822
				 "ax_ofdma_ndpa_flushed_user%d = %u\n",
3823
				 i, htt_stats_buf->ax_ofdma_ndpa_flushed[i]);
3824
		len += scnprintf(buf + len, buf_len - len,
3825
				 "ax_ofdma_ndpa_err_user%d = %u\n",
3826
				 i, htt_stats_buf->ax_ofdma_ndpa_err[i]);
3827
		len += scnprintf(buf + len, buf_len - len, "\n");
3828
	}
3829

3830
	stats_req->buf_len = len;
3831
}
3832

3833
static inline
3834
void htt_print_txbf_ofdma_ndp_stats_tlv(const void *tag_buf,
3835
					struct debug_htt_stats_req *stats_req)
3836
{
3837
	const struct htt_txbf_ofdma_ndp_stats_tlv *htt_stats_buf = tag_buf;
3838
	u8 *buf = stats_req->buf;
3839
	u32 len = stats_req->buf_len;
3840
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3841
	int i;
3842

3843
	len += scnprintf(buf + len, buf_len - len,
3844
			 "HTT_TXBF_OFDMA_NDP_STATS_TLV:\n");
3845

3846
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
3847
		len += scnprintf(buf + len, buf_len - len,
3848
				 "ax_ofdma_ndp_queued_user%d = %u\n",
3849
				 i, htt_stats_buf->ax_ofdma_ndp_queued[i]);
3850
		len += scnprintf(buf + len, buf_len - len,
3851
				 "ax_ofdma_ndp_tried_user%d = %u\n",
3852
				 i, htt_stats_buf->ax_ofdma_ndp_tried[i]);
3853
		len += scnprintf(buf + len, buf_len - len,
3854
				 "ax_ofdma_ndp_flushed_user%d = %u\n",
3855
				 i, htt_stats_buf->ax_ofdma_ndp_flushed[i]);
3856
		len += scnprintf(buf + len, buf_len - len,
3857
				 "ax_ofdma_ndp_err_user%d = %u\n",
3858
				 i, htt_stats_buf->ax_ofdma_ndp_err[i]);
3859
		len += scnprintf(buf + len, buf_len - len, "\n");
3860
	}
3861

3862
	stats_req->buf_len = len;
3863
}
3864

3865
static inline
3866
void htt_print_txbf_ofdma_brp_stats_tlv(const void *tag_buf,
3867
					struct debug_htt_stats_req *stats_req)
3868
{
3869
	const struct htt_txbf_ofdma_brp_stats_tlv *htt_stats_buf = tag_buf;
3870
	u8 *buf = stats_req->buf;
3871
	u32 len = stats_req->buf_len;
3872
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3873
	int i;
3874

3875
	len += scnprintf(buf + len, buf_len - len,
3876
			 "HTT_TXBF_OFDMA_BRP_STATS_TLV:\n");
3877

3878
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
3879
		len += scnprintf(buf + len, buf_len - len,
3880
				 "ax_ofdma_brpoll_queued_user%d = %u\n",
3881
				 i, htt_stats_buf->ax_ofdma_brpoll_queued[i]);
3882
		len += scnprintf(buf + len, buf_len - len,
3883
				 "ax_ofdma_brpoll_tried_user%d = %u\n",
3884
				 i, htt_stats_buf->ax_ofdma_brpoll_tried[i]);
3885
		len += scnprintf(buf + len, buf_len - len,
3886
				 "ax_ofdma_brpoll_flushed_user%d = %u\n",
3887
				 i, htt_stats_buf->ax_ofdma_brpoll_flushed[i]);
3888
		len += scnprintf(buf + len, buf_len - len,
3889
				 "ax_ofdma_brp_err_user%d = %u\n",
3890
				 i, htt_stats_buf->ax_ofdma_brp_err[i]);
3891
		len += scnprintf(buf + len, buf_len - len,
3892
				 "ax_ofdma_brp_err_num_cbf_rcvd_user%d = %u\n",
3893
				 i, htt_stats_buf->ax_ofdma_brp_err_num_cbf_rcvd[i]);
3894
		len += scnprintf(buf + len, buf_len - len, "\n");
3895
	}
3896

3897
	stats_req->buf_len = len;
3898
}
3899

3900
static inline
3901
void htt_print_txbf_ofdma_steer_stats_tlv(const void *tag_buf,
3902
					  struct debug_htt_stats_req *stats_req)
3903
{
3904
	const struct htt_txbf_ofdma_steer_stats_tlv *htt_stats_buf = tag_buf;
3905
	u8 *buf = stats_req->buf;
3906
	u32 len = stats_req->buf_len;
3907
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3908
	int i;
3909

3910
	len += scnprintf(buf + len, buf_len - len,
3911
			 "HTT_TXBF_OFDMA_STEER_STATS_TLV:\n");
3912

3913
	for (i = 0; i < HTT_TX_PDEV_STATS_NUM_OFDMA_USER_STATS; i++) {
3914
		len += scnprintf(buf + len, buf_len - len,
3915
				 "ax_ofdma_num_ppdu_steer_user%d = %u\n",
3916
				 i, htt_stats_buf->ax_ofdma_num_ppdu_steer[i]);
3917
		len += scnprintf(buf + len, buf_len - len,
3918
				 "ax_ofdma_num_ppdu_ol_user%d = %u\n",
3919
				 i, htt_stats_buf->ax_ofdma_num_ppdu_ol[i]);
3920
		len += scnprintf(buf + len, buf_len - len,
3921
				 "ax_ofdma_num_usrs_prefetch_user%d = %u\n",
3922
				 i, htt_stats_buf->ax_ofdma_num_usrs_prefetch[i]);
3923
		len += scnprintf(buf + len, buf_len - len,
3924
				 "ax_ofdma_num_usrs_sound_user%d = %u\n",
3925
				 i, htt_stats_buf->ax_ofdma_num_usrs_sound[i]);
3926
		len += scnprintf(buf + len, buf_len - len,
3927
				 "ax_ofdma_num_usrs_force_sound_user%d = %u\n",
3928
				 i, htt_stats_buf->ax_ofdma_num_usrs_force_sound[i]);
3929
		len += scnprintf(buf + len, buf_len - len, "\n");
3930
	}
3931

3932
	stats_req->buf_len = len;
3933
}
3934

3935
static inline
3936
void htt_print_phy_counters_tlv(const void *tag_buf,
3937
				struct debug_htt_stats_req *stats_req)
3938
{
3939
	const struct htt_phy_counters_tlv *htt_stats_buf = tag_buf;
3940
	u8 *buf = stats_req->buf;
3941
	u32 len = stats_req->buf_len;
3942
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3943
	int i;
3944

3945
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_COUNTERS_TLV:\n");
3946
	len += scnprintf(buf + len, buf_len - len, "rx_ofdma_timing_err_cnt = %u\n",
3947
			 htt_stats_buf->rx_ofdma_timing_err_cnt);
3948
	len += scnprintf(buf + len, buf_len - len, "rx_cck_fail_cnt = %u\n",
3949
			 htt_stats_buf->rx_cck_fail_cnt);
3950
	len += scnprintf(buf + len, buf_len - len, "mactx_abort_cnt = %u\n",
3951
			 htt_stats_buf->mactx_abort_cnt);
3952
	len += scnprintf(buf + len, buf_len - len, "macrx_abort_cnt = %u\n",
3953
			 htt_stats_buf->macrx_abort_cnt);
3954
	len += scnprintf(buf + len, buf_len - len, "phytx_abort_cnt = %u\n",
3955
			 htt_stats_buf->phytx_abort_cnt);
3956
	len += scnprintf(buf + len, buf_len - len, "phyrx_abort_cnt = %u\n",
3957
			 htt_stats_buf->phyrx_abort_cnt);
3958
	len += scnprintf(buf + len, buf_len - len, "phyrx_defer_abort_cnt = %u\n",
3959
			 htt_stats_buf->phyrx_defer_abort_cnt);
3960
	len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_lstf_event_cnt = %u\n",
3961
			 htt_stats_buf->rx_gain_adj_lstf_event_cnt);
3962
	len += scnprintf(buf + len, buf_len - len, "rx_gain_adj_non_legacy_cnt = %u\n",
3963
			 htt_stats_buf->rx_gain_adj_non_legacy_cnt);
3964

3965
	for (i = 0; i < HTT_MAX_RX_PKT_CNT; i++)
3966
		len += scnprintf(buf + len, buf_len - len, "rx_pkt_cnt[%d] = %u\n",
3967
				 i, htt_stats_buf->rx_pkt_cnt[i]);
3968

3969
	for (i = 0; i < HTT_MAX_RX_PKT_CRC_PASS_CNT; i++)
3970
		len += scnprintf(buf + len, buf_len - len,
3971
				 "rx_pkt_crc_pass_cnt[%d] = %u\n",
3972
				 i, htt_stats_buf->rx_pkt_crc_pass_cnt[i]);
3973

3974
	for (i = 0; i < HTT_MAX_PER_BLK_ERR_CNT; i++)
3975
		len += scnprintf(buf + len, buf_len - len,
3976
				 "per_blk_err_cnt[%d] = %u\n",
3977
				 i, htt_stats_buf->per_blk_err_cnt[i]);
3978

3979
	for (i = 0; i < HTT_MAX_RX_OTA_ERR_CNT; i++)
3980
		len += scnprintf(buf + len, buf_len - len,
3981
				 "rx_ota_err_cnt[%d] = %u\n",
3982
				 i, htt_stats_buf->rx_ota_err_cnt[i]);
3983

3984
	stats_req->buf_len = len;
3985
}
3986

3987
static inline
3988
void htt_print_phy_stats_tlv(const void *tag_buf,
3989
			     struct debug_htt_stats_req *stats_req)
3990
{
3991
	const struct htt_phy_stats_tlv *htt_stats_buf = tag_buf;
3992
	u8 *buf = stats_req->buf;
3993
	u32 len = stats_req->buf_len;
3994
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
3995
	int i;
3996

3997
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_STATS_TLV:\n");
3998

3999
	for (i = 0; i < HTT_STATS_MAX_CHAINS; i++)
4000
		len += scnprintf(buf + len, buf_len - len, "nf_chain[%d] = %d\n",
4001
				 i, htt_stats_buf->nf_chain[i]);
4002

4003
	len += scnprintf(buf + len, buf_len - len, "false_radar_cnt = %u\n",
4004
			 htt_stats_buf->false_radar_cnt);
4005
	len += scnprintf(buf + len, buf_len - len, "radar_cs_cnt = %u\n",
4006
			 htt_stats_buf->radar_cs_cnt);
4007
	len += scnprintf(buf + len, buf_len - len, "ani_level = %d\n",
4008
			 htt_stats_buf->ani_level);
4009
	len += scnprintf(buf + len, buf_len - len, "fw_run_time = %u\n",
4010
			 htt_stats_buf->fw_run_time);
4011

4012
	stats_req->buf_len = len;
4013
}
4014

4015
static inline void
4016
htt_print_phy_reset_counters_tlv(const void *tag_buf,
4017
				 u16 tag_len,
4018
				 struct debug_htt_stats_req *stats_req)
4019
{
4020
	const struct htt_phy_reset_counters_tlv *htt_stats_buf = tag_buf;
4021
	u8 *buf = stats_req->buf;
4022
	u32 len = stats_req->buf_len;
4023
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
4024

4025
	if (tag_len < sizeof(*htt_stats_buf))
4026
		return;
4027

4028
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_COUNTERS_TLV:\n");
4029

4030
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
4031
			 htt_stats_buf->pdev_id);
4032
	len += scnprintf(buf + len, buf_len - len, "cf_active_low_fail_cnt = %u\n",
4033
			 htt_stats_buf->cf_active_low_fail_cnt);
4034
	len += scnprintf(buf + len, buf_len - len, "cf_active_low_pass_cnt = %u\n",
4035
			 htt_stats_buf->cf_active_low_pass_cnt);
4036
	len += scnprintf(buf + len, buf_len - len, "phy_off_through_vreg_cnt = %u\n",
4037
			 htt_stats_buf->phy_off_through_vreg_cnt);
4038
	len += scnprintf(buf + len, buf_len - len, "force_calibration_cnt = %u\n",
4039
			 htt_stats_buf->force_calibration_cnt);
4040
	len += scnprintf(buf + len, buf_len - len, "rf_mode_switch_phy_off_cnt = %u\n",
4041
			 htt_stats_buf->rf_mode_switch_phy_off_cnt);
4042

4043
	stats_req->buf_len = len;
4044
}
4045

4046
static inline void
4047
htt_print_phy_reset_stats_tlv(const void *tag_buf,
4048
			      u16 tag_len,
4049
			      struct debug_htt_stats_req *stats_req)
4050
{
4051
	const struct htt_phy_reset_stats_tlv *htt_stats_buf = tag_buf;
4052
	u8 *buf = stats_req->buf;
4053
	u32 len = stats_req->buf_len;
4054
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
4055

4056
	if (tag_len < sizeof(*htt_stats_buf))
4057
		return;
4058

4059
	len += scnprintf(buf + len, buf_len - len, "HTT_PHY_RESET_STATS_TLV:\n");
4060

4061
	len += scnprintf(buf + len, buf_len - len, "pdev_id = %u\n",
4062
			 htt_stats_buf->pdev_id);
4063
	len += scnprintf(buf + len, buf_len - len, "chan_mhz = %u\n",
4064
			 htt_stats_buf->chan_mhz);
4065
	len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq1 = %u\n",
4066
			 htt_stats_buf->chan_band_center_freq1);
4067
	len += scnprintf(buf + len, buf_len - len, "chan_band_center_freq2 = %u\n",
4068
			 htt_stats_buf->chan_band_center_freq2);
4069
	len += scnprintf(buf + len, buf_len - len, "chan_phy_mode = %u\n",
4070
			 htt_stats_buf->chan_phy_mode);
4071
	len += scnprintf(buf + len, buf_len - len, "chan_flags = 0x%0x\n",
4072
			 htt_stats_buf->chan_flags);
4073
	len += scnprintf(buf + len, buf_len - len, "chan_num = %u\n",
4074
			 htt_stats_buf->chan_num);
4075
	len += scnprintf(buf + len, buf_len - len, "reset_cause = 0x%0x\n",
4076
			 htt_stats_buf->reset_cause);
4077
	len += scnprintf(buf + len, buf_len - len, "prev_reset_cause = 0x%0x\n",
4078
			 htt_stats_buf->prev_reset_cause);
4079
	len += scnprintf(buf + len, buf_len - len, "phy_warm_reset_src = 0x%0x\n",
4080
			 htt_stats_buf->phy_warm_reset_src);
4081
	len += scnprintf(buf + len, buf_len - len, "rx_gain_tbl_mode = %d\n",
4082
			 htt_stats_buf->rx_gain_tbl_mode);
4083
	len += scnprintf(buf + len, buf_len - len, "xbar_val = 0x%0x\n",
4084
			 htt_stats_buf->xbar_val);
4085
	len += scnprintf(buf + len, buf_len - len, "force_calibration = %u\n",
4086
			 htt_stats_buf->force_calibration);
4087
	len += scnprintf(buf + len, buf_len - len, "phyrf_mode = %u\n",
4088
			 htt_stats_buf->phyrf_mode);
4089
	len += scnprintf(buf + len, buf_len - len, "phy_homechan = %u\n",
4090
			 htt_stats_buf->phy_homechan);
4091
	len += scnprintf(buf + len, buf_len - len, "phy_tx_ch_mask = 0x%0x\n",
4092
			 htt_stats_buf->phy_tx_ch_mask);
4093
	len += scnprintf(buf + len, buf_len - len, "phy_rx_ch_mask = 0x%0x\n",
4094
			 htt_stats_buf->phy_rx_ch_mask);
4095
	len += scnprintf(buf + len, buf_len - len, "phybb_ini_mask = 0x%0x\n",
4096
			 htt_stats_buf->phybb_ini_mask);
4097
	len += scnprintf(buf + len, buf_len - len, "phyrf_ini_mask = 0x%0x\n",
4098
			 htt_stats_buf->phyrf_ini_mask);
4099
	len += scnprintf(buf + len, buf_len - len, "phy_dfs_en_mask = 0x%0x\n",
4100
			 htt_stats_buf->phy_dfs_en_mask);
4101
	len += scnprintf(buf + len, buf_len - len, "phy_sscan_en_mask = 0x%0x\n",
4102
			 htt_stats_buf->phy_sscan_en_mask);
4103
	len += scnprintf(buf + len, buf_len - len, "phy_synth_sel_mask = 0x%0x\n",
4104
			 htt_stats_buf->phy_synth_sel_mask);
4105
	len += scnprintf(buf + len, buf_len - len, "phy_adfs_freq = %u\n",
4106
			 htt_stats_buf->phy_adfs_freq);
4107
	len += scnprintf(buf + len, buf_len - len, "cck_fir_settings = 0x%0x\n",
4108
			 htt_stats_buf->cck_fir_settings);
4109
	len += scnprintf(buf + len, buf_len - len, "phy_dyn_pri_chan = %u\n",
4110
			 htt_stats_buf->phy_dyn_pri_chan);
4111
	len += scnprintf(buf + len, buf_len - len, "cca_thresh = 0x%0x\n",
4112
			 htt_stats_buf->cca_thresh);
4113
	len += scnprintf(buf + len, buf_len - len, "dyn_cca_status = %u\n",
4114
			 htt_stats_buf->dyn_cca_status);
4115
	len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_hw = 0x%x\n",
4116
			 htt_stats_buf->rxdesense_thresh_hw);
4117
	len += scnprintf(buf + len, buf_len - len, "rxdesense_thresh_sw = 0x%x\n",
4118
			 htt_stats_buf->rxdesense_thresh_sw);
4119

4120
	stats_req->buf_len = len;
4121
}
4122

4123
static inline
4124
void htt_print_peer_ctrl_path_txrx_stats_tlv(const void *tag_buf,
4125
					     struct debug_htt_stats_req *stats_req)
4126
{
4127
	const struct htt_peer_ctrl_path_txrx_stats_tlv *htt_stat_buf = tag_buf;
4128
	u8 *buf = stats_req->buf;
4129
	u32 len = stats_req->buf_len;
4130
	u32 buf_len = ATH11K_HTT_STATS_BUF_SIZE;
4131
	int i;
4132
	const char *mgmt_frm_type[ATH11K_STATS_MGMT_FRM_TYPE_MAX - 1] = {
4133
		"assoc_req", "assoc_resp",
4134
		"reassoc_req", "reassoc_resp",
4135
		"probe_req", "probe_resp",
4136
		"timing_advertisement", "reserved",
4137
		"beacon", "atim", "disassoc",
4138
		"auth", "deauth", "action", "action_no_ack"};
4139

4140
	len += scnprintf(buf + len, buf_len - len,
4141
			 "HTT_STATS_PEER_CTRL_PATH_TXRX_STATS_TAG:\n");
4142
	len += scnprintf(buf + len, buf_len - len,
4143
			 "peer_mac_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
4144
			 htt_stat_buf->peer_mac_addr[0], htt_stat_buf->peer_mac_addr[1],
4145
			 htt_stat_buf->peer_mac_addr[2], htt_stat_buf->peer_mac_addr[3],
4146
			 htt_stat_buf->peer_mac_addr[4], htt_stat_buf->peer_mac_addr[5]);
4147

4148
	len += scnprintf(buf + len, buf_len - len, "peer_tx_mgmt_subtype:\n");
4149
	for (i = 0; i < ATH11K_STATS_MGMT_FRM_TYPE_MAX - 1; i++)
4150
		len += scnprintf(buf + len, buf_len - len, "%s:%u\n",
4151
				 mgmt_frm_type[i],
4152
				 htt_stat_buf->peer_rx_mgmt_subtype[i]);
4153

4154
	len += scnprintf(buf + len, buf_len - len, "peer_rx_mgmt_subtype:\n");
4155
	for (i = 0; i < ATH11K_STATS_MGMT_FRM_TYPE_MAX - 1; i++)
4156
		len += scnprintf(buf + len, buf_len - len, "%s:%u\n",
4157
				 mgmt_frm_type[i],
4158
				 htt_stat_buf->peer_rx_mgmt_subtype[i]);
4159

4160
	len += scnprintf(buf + len, buf_len - len, "\n");
4161

4162
	stats_req->buf_len = len;
4163
}
4164

4165
static int ath11k_dbg_htt_ext_stats_parse(struct ath11k_base *ab,
4166
					  u16 tag, u16 len, const void *tag_buf,
4167
					  void *user_data)
4168
{
4169
	struct debug_htt_stats_req *stats_req = user_data;
4170

4171
	switch (tag) {
4172
	case HTT_STATS_TX_PDEV_CMN_TAG:
4173
		htt_print_tx_pdev_stats_cmn_tlv(tag_buf, stats_req);
4174
		break;
4175
	case HTT_STATS_TX_PDEV_UNDERRUN_TAG:
4176
		htt_print_tx_pdev_stats_urrn_tlv_v(tag_buf, len, stats_req);
4177
		break;
4178
	case HTT_STATS_TX_PDEV_SIFS_TAG:
4179
		htt_print_tx_pdev_stats_sifs_tlv_v(tag_buf, len, stats_req);
4180
		break;
4181
	case HTT_STATS_TX_PDEV_FLUSH_TAG:
4182
		htt_print_tx_pdev_stats_flush_tlv_v(tag_buf, len, stats_req);
4183
		break;
4184
	case HTT_STATS_TX_PDEV_PHY_ERR_TAG:
4185
		htt_print_tx_pdev_stats_phy_err_tlv_v(tag_buf, len, stats_req);
4186
		break;
4187
	case HTT_STATS_TX_PDEV_SIFS_HIST_TAG:
4188
		htt_print_tx_pdev_stats_sifs_hist_tlv_v(tag_buf, len, stats_req);
4189
		break;
4190

4191
	case HTT_STATS_TX_PDEV_TX_PPDU_STATS_TAG:
4192
		htt_print_tx_pdev_stats_tx_ppdu_stats_tlv_v(tag_buf, stats_req);
4193
		break;
4194

4195
	case HTT_STATS_TX_PDEV_TRIED_MPDU_CNT_HIST_TAG:
4196
		htt_print_tx_pdev_stats_tried_mpdu_cnt_hist_tlv_v(tag_buf, len,
4197
								  stats_req);
4198
		break;
4199

4200
	case HTT_STATS_STRING_TAG:
4201
		htt_print_stats_string_tlv(tag_buf, len, stats_req);
4202
		break;
4203

4204
	case HTT_STATS_TX_HWQ_CMN_TAG:
4205
		htt_print_tx_hwq_stats_cmn_tlv(tag_buf, stats_req);
4206
		break;
4207

4208
	case HTT_STATS_TX_HWQ_DIFS_LATENCY_TAG:
4209
		htt_print_tx_hwq_difs_latency_stats_tlv_v(tag_buf, len, stats_req);
4210
		break;
4211

4212
	case HTT_STATS_TX_HWQ_CMD_RESULT_TAG:
4213
		htt_print_tx_hwq_cmd_result_stats_tlv_v(tag_buf, len, stats_req);
4214
		break;
4215

4216
	case HTT_STATS_TX_HWQ_CMD_STALL_TAG:
4217
		htt_print_tx_hwq_cmd_stall_stats_tlv_v(tag_buf, len, stats_req);
4218
		break;
4219

4220
	case HTT_STATS_TX_HWQ_FES_STATUS_TAG:
4221
		htt_print_tx_hwq_fes_result_stats_tlv_v(tag_buf, len, stats_req);
4222
		break;
4223

4224
	case HTT_STATS_TX_HWQ_TRIED_MPDU_CNT_HIST_TAG:
4225
		htt_print_tx_hwq_tried_mpdu_cnt_hist_tlv_v(tag_buf, len, stats_req);
4226
		break;
4227

4228
	case HTT_STATS_TX_HWQ_TXOP_USED_CNT_HIST_TAG:
4229
		htt_print_tx_hwq_txop_used_cnt_hist_tlv_v(tag_buf, len, stats_req);
4230
		break;
4231
	case HTT_STATS_TX_TQM_GEN_MPDU_TAG:
4232
		htt_print_tx_tqm_gen_mpdu_stats_tlv_v(tag_buf, len, stats_req);
4233
		break;
4234

4235
	case HTT_STATS_TX_TQM_LIST_MPDU_TAG:
4236
		htt_print_tx_tqm_list_mpdu_stats_tlv_v(tag_buf, len, stats_req);
4237
		break;
4238

4239
	case HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG:
4240
		htt_print_tx_tqm_list_mpdu_cnt_tlv_v(tag_buf, len, stats_req);
4241
		break;
4242

4243
	case HTT_STATS_TX_TQM_CMN_TAG:
4244
		htt_print_tx_tqm_cmn_stats_tlv(tag_buf, stats_req);
4245
		break;
4246

4247
	case HTT_STATS_TX_TQM_PDEV_TAG:
4248
		htt_print_tx_tqm_pdev_stats_tlv_v(tag_buf, stats_req);
4249
		break;
4250

4251
	case HTT_STATS_TX_TQM_CMDQ_STATUS_TAG:
4252
		htt_print_tx_tqm_cmdq_status_tlv(tag_buf, stats_req);
4253
		break;
4254

4255
	case HTT_STATS_TX_DE_EAPOL_PACKETS_TAG:
4256
		htt_print_tx_de_eapol_packets_stats_tlv(tag_buf, stats_req);
4257
		break;
4258

4259
	case HTT_STATS_TX_DE_CLASSIFY_FAILED_TAG:
4260
		htt_print_tx_de_classify_failed_stats_tlv(tag_buf, stats_req);
4261
		break;
4262

4263
	case HTT_STATS_TX_DE_CLASSIFY_STATS_TAG:
4264
		htt_print_tx_de_classify_stats_tlv(tag_buf, stats_req);
4265
		break;
4266

4267
	case HTT_STATS_TX_DE_CLASSIFY_STATUS_TAG:
4268
		htt_print_tx_de_classify_status_stats_tlv(tag_buf, stats_req);
4269
		break;
4270

4271
	case HTT_STATS_TX_DE_ENQUEUE_PACKETS_TAG:
4272
		htt_print_tx_de_enqueue_packets_stats_tlv(tag_buf, stats_req);
4273
		break;
4274

4275
	case HTT_STATS_TX_DE_ENQUEUE_DISCARD_TAG:
4276
		htt_print_tx_de_enqueue_discard_stats_tlv(tag_buf, stats_req);
4277
		break;
4278

4279
	case HTT_STATS_TX_DE_FW2WBM_RING_FULL_HIST_TAG:
4280
		htt_print_tx_de_fw2wbm_ring_full_hist_tlv(tag_buf, len, stats_req);
4281
		break;
4282

4283
	case HTT_STATS_TX_DE_CMN_TAG:
4284
		htt_print_tx_de_cmn_stats_tlv(tag_buf, stats_req);
4285
		break;
4286

4287
	case HTT_STATS_RING_IF_TAG:
4288
		htt_print_ring_if_stats_tlv(tag_buf, stats_req);
4289
		break;
4290

4291
	case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG:
4292
		htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, stats_req);
4293
		break;
4294

4295
	case HTT_STATS_SFM_CMN_TAG:
4296
		htt_print_sfm_cmn_tlv(tag_buf, stats_req);
4297
		break;
4298

4299
	case HTT_STATS_SRING_STATS_TAG:
4300
		htt_print_sring_stats_tlv(tag_buf, stats_req);
4301
		break;
4302

4303
	case HTT_STATS_RX_PDEV_FW_STATS_TAG:
4304
		htt_print_rx_pdev_fw_stats_tlv(tag_buf, stats_req);
4305
		break;
4306

4307
	case HTT_STATS_RX_PDEV_FW_RING_MPDU_ERR_TAG:
4308
		htt_print_rx_pdev_fw_ring_mpdu_err_tlv_v(tag_buf, stats_req);
4309
		break;
4310

4311
	case HTT_STATS_RX_PDEV_FW_MPDU_DROP_TAG:
4312
		htt_print_rx_pdev_fw_mpdu_drop_tlv_v(tag_buf, len, stats_req);
4313
		break;
4314

4315
	case HTT_STATS_RX_SOC_FW_STATS_TAG:
4316
		htt_print_rx_soc_fw_stats_tlv(tag_buf, stats_req);
4317
		break;
4318

4319
	case HTT_STATS_RX_SOC_FW_REFILL_RING_EMPTY_TAG:
4320
		htt_print_rx_soc_fw_refill_ring_empty_tlv_v(tag_buf, len, stats_req);
4321
		break;
4322

4323
	case HTT_STATS_RX_SOC_FW_REFILL_RING_NUM_REFILL_TAG:
4324
		htt_print_rx_soc_fw_refill_ring_num_refill_tlv_v(
4325
				tag_buf, len, stats_req);
4326
		break;
4327
	case HTT_STATS_RX_REFILL_RXDMA_ERR_TAG:
4328
		htt_print_rx_soc_fw_refill_ring_num_rxdma_err_tlv_v(
4329
				tag_buf, len, stats_req);
4330
		break;
4331

4332
	case HTT_STATS_RX_REFILL_REO_ERR_TAG:
4333
		htt_print_rx_soc_fw_refill_ring_num_reo_err_tlv_v(
4334
				tag_buf, len, stats_req);
4335
		break;
4336

4337
	case HTT_STATS_RX_REO_RESOURCE_STATS_TAG:
4338
		htt_print_rx_reo_debug_stats_tlv_v(
4339
				tag_buf, stats_req);
4340
		break;
4341
	case HTT_STATS_RX_PDEV_FW_STATS_PHY_ERR_TAG:
4342
		htt_print_rx_pdev_fw_stats_phy_err_tlv(tag_buf, stats_req);
4343
		break;
4344

4345
	case HTT_STATS_TX_PDEV_RATE_STATS_TAG:
4346
		htt_print_tx_pdev_rate_stats_tlv(tag_buf, stats_req);
4347
		break;
4348

4349
	case HTT_STATS_RX_PDEV_RATE_STATS_TAG:
4350
		htt_print_rx_pdev_rate_stats_tlv(tag_buf, stats_req);
4351
		break;
4352

4353
	case HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG:
4354
		htt_print_tx_pdev_stats_sched_per_txq_tlv(tag_buf, stats_req);
4355
		break;
4356
	case HTT_STATS_TX_SCHED_CMN_TAG:
4357
		htt_print_stats_tx_sched_cmn_tlv(tag_buf, stats_req);
4358
		break;
4359

4360
	case HTT_STATS_TX_PDEV_MPDU_STATS_TAG:
4361
		htt_print_tx_pdev_mu_mimo_mpdu_stats_tlv(tag_buf, stats_req);
4362
		break;
4363

4364
	case HTT_STATS_SCHED_TXQ_CMD_POSTED_TAG:
4365
		htt_print_sched_txq_cmd_posted_tlv_v(tag_buf, len, stats_req);
4366
		break;
4367

4368
	case HTT_STATS_RING_IF_CMN_TAG:
4369
		htt_print_ring_if_cmn_tlv(tag_buf, stats_req);
4370
		break;
4371

4372
	case HTT_STATS_SFM_CLIENT_USER_TAG:
4373
		htt_print_sfm_client_user_tlv_v(tag_buf, len, stats_req);
4374
		break;
4375

4376
	case HTT_STATS_SFM_CLIENT_TAG:
4377
		htt_print_sfm_client_tlv(tag_buf, stats_req);
4378
		break;
4379

4380
	case HTT_STATS_TX_TQM_ERROR_STATS_TAG:
4381
		htt_print_tx_tqm_error_stats_tlv(tag_buf, stats_req);
4382
		break;
4383

4384
	case HTT_STATS_SCHED_TXQ_CMD_REAPED_TAG:
4385
		htt_print_sched_txq_cmd_reaped_tlv_v(tag_buf, len, stats_req);
4386
		break;
4387

4388
	case HTT_STATS_SRING_CMN_TAG:
4389
		htt_print_sring_cmn_tlv(tag_buf, stats_req);
4390
		break;
4391

4392
	case HTT_STATS_TX_SOUNDING_STATS_TAG:
4393
		htt_print_tx_sounding_stats_tlv(tag_buf, stats_req);
4394
		break;
4395

4396
	case HTT_STATS_TX_SELFGEN_AC_ERR_STATS_TAG:
4397
		htt_print_tx_selfgen_ac_err_stats_tlv(tag_buf, stats_req);
4398
		break;
4399

4400
	case HTT_STATS_TX_SELFGEN_CMN_STATS_TAG:
4401
		htt_print_tx_selfgen_cmn_stats_tlv(tag_buf, stats_req);
4402
		break;
4403

4404
	case HTT_STATS_TX_SELFGEN_AC_STATS_TAG:
4405
		htt_print_tx_selfgen_ac_stats_tlv(tag_buf, stats_req);
4406
		break;
4407

4408
	case HTT_STATS_TX_SELFGEN_AX_STATS_TAG:
4409
		htt_print_tx_selfgen_ax_stats_tlv(tag_buf, stats_req);
4410
		break;
4411

4412
	case HTT_STATS_TX_SELFGEN_AX_ERR_STATS_TAG:
4413
		htt_print_tx_selfgen_ax_err_stats_tlv(tag_buf, stats_req);
4414
		break;
4415

4416
	case HTT_STATS_TX_HWQ_MUMIMO_SCH_STATS_TAG:
4417
		htt_print_tx_hwq_mu_mimo_sch_stats_tlv(tag_buf, stats_req);
4418
		break;
4419

4420
	case HTT_STATS_TX_HWQ_MUMIMO_MPDU_STATS_TAG:
4421
		htt_print_tx_hwq_mu_mimo_mpdu_stats_tlv(tag_buf, stats_req);
4422
		break;
4423

4424
	case HTT_STATS_TX_HWQ_MUMIMO_CMN_STATS_TAG:
4425
		htt_print_tx_hwq_mu_mimo_cmn_stats_tlv(tag_buf, stats_req);
4426
		break;
4427

4428
	case HTT_STATS_HW_INTR_MISC_TAG:
4429
		htt_print_hw_stats_intr_misc_tlv(tag_buf, stats_req);
4430
		break;
4431

4432
	case HTT_STATS_HW_WD_TIMEOUT_TAG:
4433
		htt_print_hw_stats_wd_timeout_tlv(tag_buf, stats_req);
4434
		break;
4435

4436
	case HTT_STATS_HW_PDEV_ERRS_TAG:
4437
		htt_print_hw_stats_pdev_errs_tlv(tag_buf, stats_req);
4438
		break;
4439

4440
	case HTT_STATS_COUNTER_NAME_TAG:
4441
		htt_print_counter_tlv(tag_buf, stats_req);
4442
		break;
4443

4444
	case HTT_STATS_TX_TID_DETAILS_TAG:
4445
		htt_print_tx_tid_stats_tlv(tag_buf, stats_req);
4446
		break;
4447

4448
	case HTT_STATS_TX_TID_DETAILS_V1_TAG:
4449
		htt_print_tx_tid_stats_v1_tlv(tag_buf, stats_req);
4450
		break;
4451

4452
	case HTT_STATS_RX_TID_DETAILS_TAG:
4453
		htt_print_rx_tid_stats_tlv(tag_buf, stats_req);
4454
		break;
4455

4456
	case HTT_STATS_PEER_STATS_CMN_TAG:
4457
		htt_print_peer_stats_cmn_tlv(tag_buf, stats_req);
4458
		break;
4459

4460
	case HTT_STATS_PEER_DETAILS_TAG:
4461
		htt_print_peer_details_tlv(tag_buf, stats_req);
4462
		break;
4463

4464
	case HTT_STATS_PEER_MSDU_FLOWQ_TAG:
4465
		htt_print_msdu_flow_stats_tlv(tag_buf, stats_req);
4466
		break;
4467

4468
	case HTT_STATS_PEER_TX_RATE_STATS_TAG:
4469
		htt_print_tx_peer_rate_stats_tlv(tag_buf, stats_req);
4470
		break;
4471

4472
	case HTT_STATS_PEER_RX_RATE_STATS_TAG:
4473
		htt_print_rx_peer_rate_stats_tlv(tag_buf, stats_req);
4474
		break;
4475

4476
	case HTT_STATS_TX_DE_COMPL_STATS_TAG:
4477
		htt_print_tx_de_compl_stats_tlv(tag_buf, stats_req);
4478
		break;
4479

4480
	case HTT_STATS_PDEV_CCA_1SEC_HIST_TAG:
4481
	case HTT_STATS_PDEV_CCA_100MSEC_HIST_TAG:
4482
	case HTT_STATS_PDEV_CCA_STAT_CUMULATIVE_TAG:
4483
		htt_print_pdev_cca_stats_hist_tlv(tag_buf, stats_req);
4484
		break;
4485

4486
	case HTT_STATS_PDEV_CCA_COUNTERS_TAG:
4487
		htt_print_pdev_stats_cca_counters_tlv(tag_buf, stats_req);
4488
		break;
4489

4490
	case HTT_STATS_WHAL_TX_TAG:
4491
		htt_print_hw_stats_whal_tx_tlv(tag_buf, stats_req);
4492
		break;
4493

4494
	case HTT_STATS_PDEV_TWT_SESSIONS_TAG:
4495
		htt_print_pdev_stats_twt_sessions_tlv(tag_buf, stats_req);
4496
		break;
4497

4498
	case HTT_STATS_PDEV_TWT_SESSION_TAG:
4499
		htt_print_pdev_stats_twt_session_tlv(tag_buf, stats_req);
4500
		break;
4501

4502
	case HTT_STATS_SCHED_TXQ_SCHED_ORDER_SU_TAG:
4503
		htt_print_sched_txq_sched_order_su_tlv_v(tag_buf, len, stats_req);
4504
		break;
4505

4506
	case HTT_STATS_SCHED_TXQ_SCHED_INELIGIBILITY_TAG:
4507
		htt_print_sched_txq_sched_ineligibility_tlv_v(tag_buf, len, stats_req);
4508
		break;
4509

4510
	case HTT_STATS_PDEV_OBSS_PD_TAG:
4511
		htt_print_pdev_obss_pd_stats_tlv_v(tag_buf, stats_req);
4512
		break;
4513
	case HTT_STATS_RING_BACKPRESSURE_STATS_TAG:
4514
		htt_print_backpressure_stats_tlv_v(tag_buf, user_data);
4515
		break;
4516
	case HTT_STATS_PDEV_TX_RATE_TXBF_STATS_TAG:
4517
		htt_print_pdev_tx_rate_txbf_stats_tlv(tag_buf, stats_req);
4518
		break;
4519
	case HTT_STATS_TXBF_OFDMA_NDPA_STATS_TAG:
4520
		htt_print_txbf_ofdma_ndpa_stats_tlv(tag_buf, stats_req);
4521
		break;
4522
	case HTT_STATS_TXBF_OFDMA_NDP_STATS_TAG:
4523
		htt_print_txbf_ofdma_ndp_stats_tlv(tag_buf, stats_req);
4524
		break;
4525
	case HTT_STATS_TXBF_OFDMA_BRP_STATS_TAG:
4526
		htt_print_txbf_ofdma_brp_stats_tlv(tag_buf, stats_req);
4527
		break;
4528
	case HTT_STATS_TXBF_OFDMA_STEER_STATS_TAG:
4529
		htt_print_txbf_ofdma_steer_stats_tlv(tag_buf, stats_req);
4530
		break;
4531
	case HTT_STATS_PHY_COUNTERS_TAG:
4532
		htt_print_phy_counters_tlv(tag_buf, stats_req);
4533
		break;
4534
	case HTT_STATS_PHY_STATS_TAG:
4535
		htt_print_phy_stats_tlv(tag_buf, stats_req);
4536
		break;
4537
	case HTT_STATS_PHY_RESET_COUNTERS_TAG:
4538
		htt_print_phy_reset_counters_tlv(tag_buf, len, stats_req);
4539
		break;
4540
	case HTT_STATS_PHY_RESET_STATS_TAG:
4541
		htt_print_phy_reset_stats_tlv(tag_buf, len, stats_req);
4542
		break;
4543
	case HTT_STATS_PEER_CTRL_PATH_TXRX_STATS_TAG:
4544
		htt_print_peer_ctrl_path_txrx_stats_tlv(tag_buf, stats_req);
4545
		break;
4546
	default:
4547
		break;
4548
	}
4549

4550
	return 0;
4551
}
4552

4553
void ath11k_debugfs_htt_ext_stats_handler(struct ath11k_base *ab,
4554
					  struct sk_buff *skb)
4555
{
4556
	struct ath11k_htt_extd_stats_msg *msg;
4557
	struct debug_htt_stats_req *stats_req;
4558
	struct ath11k *ar;
4559
	u32 len;
4560
	u64 cookie;
4561
	int ret;
4562
	bool send_completion = false;
4563
	u8 pdev_id;
4564

4565
	msg = (struct ath11k_htt_extd_stats_msg *)skb->data;
4566
	cookie = msg->cookie;
4567

4568
	if (FIELD_GET(HTT_STATS_COOKIE_MSB, cookie) != HTT_STATS_MAGIC_VALUE) {
4569
		ath11k_warn(ab, "received invalid htt ext stats event\n");
4570
		return;
4571
	}
4572

4573
	pdev_id = FIELD_GET(HTT_STATS_COOKIE_LSB, cookie);
4574
	rcu_read_lock();
4575
	ar = ath11k_mac_get_ar_by_pdev_id(ab, pdev_id);
4576
	rcu_read_unlock();
4577
	if (!ar) {
4578
		ath11k_warn(ab, "failed to get ar for pdev_id %d\n", pdev_id);
4579
		return;
4580
	}
4581

4582
	stats_req = ar->debug.htt_stats.stats_req;
4583
	if (!stats_req)
4584
		return;
4585

4586
	spin_lock_bh(&ar->debug.htt_stats.lock);
4587

4588
	stats_req->done = FIELD_GET(HTT_T2H_EXT_STATS_INFO1_DONE, msg->info1);
4589
	if (stats_req->done)
4590
		send_completion = true;
4591

4592
	spin_unlock_bh(&ar->debug.htt_stats.lock);
4593

4594
	len = FIELD_GET(HTT_T2H_EXT_STATS_INFO1_LENGTH, msg->info1);
4595
	ret = ath11k_dp_htt_tlv_iter(ab, msg->data, len,
4596
				     ath11k_dbg_htt_ext_stats_parse,
4597
				     stats_req);
4598
	if (ret)
4599
		ath11k_warn(ab, "Failed to parse tlv %d\n", ret);
4600

4601
	if (send_completion)
4602
		complete(&stats_req->cmpln);
4603
}
4604

4605
static ssize_t ath11k_read_htt_stats_type(struct file *file,
4606
					  char __user *user_buf,
4607
					  size_t count, loff_t *ppos)
4608
{
4609
	struct ath11k *ar = file->private_data;
4610
	char buf[32];
4611
	size_t len;
4612

4613
	len = scnprintf(buf, sizeof(buf), "%u\n", ar->debug.htt_stats.type);
4614

4615
	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
4616
}
4617

4618
static ssize_t ath11k_write_htt_stats_type(struct file *file,
4619
					   const char __user *user_buf,
4620
					   size_t count, loff_t *ppos)
4621
{
4622
	struct ath11k *ar = file->private_data;
4623
	u8 type;
4624
	int ret;
4625

4626
	ret = kstrtou8_from_user(user_buf, count, 0, &type);
4627
	if (ret)
4628
		return ret;
4629

4630
	if (type >= ATH11K_DBG_HTT_NUM_EXT_STATS)
4631
		return -E2BIG;
4632

4633
	if (type == ATH11K_DBG_HTT_EXT_STATS_RESET)
4634
		return -EPERM;
4635

4636
	ar->debug.htt_stats.type = type;
4637

4638
	ret = count;
4639

4640
	return ret;
4641
}
4642

4643
static const struct file_operations fops_htt_stats_type = {
4644
	.read = ath11k_read_htt_stats_type,
4645
	.write = ath11k_write_htt_stats_type,
4646
	.open = simple_open,
4647
	.owner = THIS_MODULE,
4648
	.llseek = default_llseek,
4649
};
4650

4651
static int ath11k_prep_htt_stats_cfg_params(struct ath11k *ar, u8 type,
4652
					    const u8 *mac_addr,
4653
					    struct htt_ext_stats_cfg_params *cfg_params)
4654
{
4655
	if (!cfg_params)
4656
		return -EINVAL;
4657

4658
	switch (type) {
4659
	case ATH11K_DBG_HTT_EXT_STATS_PDEV_TX_HWQ:
4660
	case ATH11K_DBG_HTT_EXT_STATS_TX_MU_HWQ:
4661
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_HWQS;
4662
		break;
4663
	case ATH11K_DBG_HTT_EXT_STATS_PDEV_TX_SCHED:
4664
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_TXQS;
4665
		break;
4666
	case ATH11K_DBG_HTT_EXT_STATS_TQM_CMDQ:
4667
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_CMDQS;
4668
		break;
4669
	case ATH11K_DBG_HTT_EXT_STATS_PEER_INFO:
4670
		cfg_params->cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR;
4671
		cfg_params->cfg0 |= FIELD_PREP(GENMASK(15, 1),
4672
					HTT_PEER_STATS_REQ_MODE_FLUSH_TQM);
4673
		cfg_params->cfg1 = HTT_STAT_DEFAULT_PEER_REQ_TYPE;
4674
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(7, 0), mac_addr[0]);
4675
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(15, 8), mac_addr[1]);
4676
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(23, 16), mac_addr[2]);
4677
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(31, 24), mac_addr[3]);
4678
		cfg_params->cfg3 |= FIELD_PREP(GENMASK(7, 0), mac_addr[4]);
4679
		cfg_params->cfg3 |= FIELD_PREP(GENMASK(15, 8), mac_addr[5]);
4680
		break;
4681
	case ATH11K_DBG_HTT_EXT_STATS_RING_IF_INFO:
4682
	case ATH11K_DBG_HTT_EXT_STATS_SRNG_INFO:
4683
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ALL_RINGS;
4684
		break;
4685
	case ATH11K_DBG_HTT_EXT_STATS_ACTIVE_PEERS_LIST:
4686
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_PEERS;
4687
		break;
4688
	case ATH11K_DBG_HTT_EXT_STATS_PDEV_CCA_STATS:
4689
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_CCA_CUMULATIVE;
4690
		break;
4691
	case ATH11K_DBG_HTT_EXT_STATS_TX_SOUNDING_INFO:
4692
		cfg_params->cfg0 = HTT_STAT_DEFAULT_CFG0_ACTIVE_VDEVS;
4693
		break;
4694
	case ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS:
4695
		cfg_params->cfg0 = HTT_STAT_PEER_INFO_MAC_ADDR;
4696
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(7, 0), mac_addr[0]);
4697
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(15, 8), mac_addr[1]);
4698
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(23, 16), mac_addr[2]);
4699
		cfg_params->cfg1 |= FIELD_PREP(GENMASK(31, 24), mac_addr[3]);
4700
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(7, 0), mac_addr[4]);
4701
		cfg_params->cfg2 |= FIELD_PREP(GENMASK(15, 8), mac_addr[5]);
4702
		break;
4703
	default:
4704
		break;
4705
	}
4706

4707
	return 0;
4708
}
4709

4710
int ath11k_debugfs_htt_stats_req(struct ath11k *ar)
4711
{
4712
	struct debug_htt_stats_req *stats_req = ar->debug.htt_stats.stats_req;
4713
	u8 type = stats_req->type;
4714
	u64 cookie = 0;
4715
	int ret, pdev_id = ar->pdev->pdev_id;
4716
	struct htt_ext_stats_cfg_params cfg_params = {};
4717

4718
	init_completion(&stats_req->cmpln);
4719

4720
	stats_req->done = false;
4721
	stats_req->pdev_id = pdev_id;
4722

4723
	cookie = FIELD_PREP(HTT_STATS_COOKIE_MSB, HTT_STATS_MAGIC_VALUE) |
4724
		 FIELD_PREP(HTT_STATS_COOKIE_LSB, pdev_id);
4725

4726
	ret = ath11k_prep_htt_stats_cfg_params(ar, type, stats_req->peer_addr,
4727
					       &cfg_params);
4728
	if (ret) {
4729
		ath11k_warn(ar->ab, "failed to set htt stats cfg params: %d\n", ret);
4730
		return ret;
4731
	}
4732

4733
	ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar, type, &cfg_params, cookie);
4734
	if (ret) {
4735
		ath11k_warn(ar->ab, "failed to send htt stats request: %d\n", ret);
4736
		return ret;
4737
	}
4738

4739
	while (!wait_for_completion_timeout(&stats_req->cmpln, 3 * HZ)) {
4740
		spin_lock_bh(&ar->debug.htt_stats.lock);
4741
		if (!stats_req->done) {
4742
			stats_req->done = true;
4743
			spin_unlock_bh(&ar->debug.htt_stats.lock);
4744
			ath11k_warn(ar->ab, "stats request timed out\n");
4745
			return -ETIMEDOUT;
4746
		}
4747
		spin_unlock_bh(&ar->debug.htt_stats.lock);
4748
	}
4749

4750
	return 0;
4751
}
4752

4753
static int ath11k_open_htt_stats(struct inode *inode, struct file *file)
4754
{
4755
	struct ath11k *ar = inode->i_private;
4756
	struct debug_htt_stats_req *stats_req;
4757
	u8 type = ar->debug.htt_stats.type;
4758
	int ret;
4759

4760
	if (type == ATH11K_DBG_HTT_EXT_STATS_RESET ||
4761
	    type == ATH11K_DBG_HTT_EXT_STATS_PEER_INFO ||
4762
	    type == ATH11K_DBG_HTT_EXT_STATS_PEER_CTRL_PATH_TXRX_STATS)
4763
		return -EPERM;
4764

4765
	mutex_lock(&ar->conf_mutex);
4766

4767
	if (ar->state != ATH11K_STATE_ON) {
4768
		ret = -ENETDOWN;
4769
		goto err_unlock;
4770
	}
4771

4772
	if (ar->debug.htt_stats.stats_req) {
4773
		ret = -EAGAIN;
4774
		goto err_unlock;
4775
	}
4776

4777
	stats_req = vzalloc(sizeof(*stats_req) + ATH11K_HTT_STATS_BUF_SIZE);
4778
	if (!stats_req) {
4779
		ret = -ENOMEM;
4780
		goto err_unlock;
4781
	}
4782

4783
	ar->debug.htt_stats.stats_req = stats_req;
4784
	stats_req->type = type;
4785

4786
	ret = ath11k_debugfs_htt_stats_req(ar);
4787
	if (ret < 0)
4788
		goto out;
4789

4790
	file->private_data = stats_req;
4791

4792
	mutex_unlock(&ar->conf_mutex);
4793

4794
	return 0;
4795
out:
4796
	vfree(stats_req);
4797
	ar->debug.htt_stats.stats_req = NULL;
4798
err_unlock:
4799
	mutex_unlock(&ar->conf_mutex);
4800

4801
	return ret;
4802
}
4803

4804
static int ath11k_release_htt_stats(struct inode *inode, struct file *file)
4805
{
4806
	struct ath11k *ar = inode->i_private;
4807

4808
	mutex_lock(&ar->conf_mutex);
4809
	vfree(file->private_data);
4810
	ar->debug.htt_stats.stats_req = NULL;
4811
	mutex_unlock(&ar->conf_mutex);
4812

4813
	return 0;
4814
}
4815

4816
static ssize_t ath11k_read_htt_stats(struct file *file,
4817
				     char __user *user_buf,
4818
				     size_t count, loff_t *ppos)
4819
{
4820
	struct debug_htt_stats_req *stats_req = file->private_data;
4821
	char *buf;
4822
	u32 length = 0;
4823

4824
	buf = stats_req->buf;
4825
	length = min_t(u32, stats_req->buf_len, ATH11K_HTT_STATS_BUF_SIZE);
4826
	return simple_read_from_buffer(user_buf, count, ppos, buf, length);
4827
}
4828

4829
static const struct file_operations fops_dump_htt_stats = {
4830
	.open = ath11k_open_htt_stats,
4831
	.release = ath11k_release_htt_stats,
4832
	.read = ath11k_read_htt_stats,
4833
	.owner = THIS_MODULE,
4834
	.llseek = default_llseek,
4835
};
4836

4837
static ssize_t ath11k_read_htt_stats_reset(struct file *file,
4838
					   char __user *user_buf,
4839
					   size_t count, loff_t *ppos)
4840
{
4841
	struct ath11k *ar = file->private_data;
4842
	char buf[32];
4843
	size_t len;
4844

4845
	len = scnprintf(buf, sizeof(buf), "%u\n", ar->debug.htt_stats.reset);
4846

4847
	return simple_read_from_buffer(user_buf, count, ppos, buf, len);
4848
}
4849

4850
static ssize_t ath11k_write_htt_stats_reset(struct file *file,
4851
					    const char __user *user_buf,
4852
					    size_t count, loff_t *ppos)
4853
{
4854
	struct ath11k *ar = file->private_data;
4855
	u8 type;
4856
	struct htt_ext_stats_cfg_params cfg_params = {};
4857
	int ret;
4858

4859
	ret = kstrtou8_from_user(user_buf, count, 0, &type);
4860
	if (ret)
4861
		return ret;
4862

4863
	if (type >= ATH11K_DBG_HTT_NUM_EXT_STATS ||
4864
	    type == ATH11K_DBG_HTT_EXT_STATS_RESET)
4865
		return -E2BIG;
4866

4867
	mutex_lock(&ar->conf_mutex);
4868
	cfg_params.cfg0 = HTT_STAT_DEFAULT_RESET_START_OFFSET;
4869
	cfg_params.cfg1 = 1 << (cfg_params.cfg0 + type);
4870
	ret = ath11k_dp_tx_htt_h2t_ext_stats_req(ar,
4871
						 ATH11K_DBG_HTT_EXT_STATS_RESET,
4872
						 &cfg_params,
4873
						 0ULL);
4874
	if (ret) {
4875
		ath11k_warn(ar->ab, "failed to send htt stats request: %d\n", ret);
4876
		mutex_unlock(&ar->conf_mutex);
4877
		return ret;
4878
	}
4879

4880
	ar->debug.htt_stats.reset = type;
4881
	mutex_unlock(&ar->conf_mutex);
4882

4883
	ret = count;
4884

4885
	return ret;
4886
}
4887

4888
static const struct file_operations fops_htt_stats_reset = {
4889
	.read = ath11k_read_htt_stats_reset,
4890
	.write = ath11k_write_htt_stats_reset,
4891
	.open = simple_open,
4892
	.owner = THIS_MODULE,
4893
	.llseek = default_llseek,
4894
};
4895

4896
void ath11k_debugfs_htt_stats_init(struct ath11k *ar)
4897
{
4898
	spin_lock_init(&ar->debug.htt_stats.lock);
4899
	debugfs_create_file("htt_stats_type", 0600, ar->debug.debugfs_pdev,
4900
			    ar, &fops_htt_stats_type);
4901
	debugfs_create_file("htt_stats", 0400, ar->debug.debugfs_pdev,
4902
			    ar, &fops_dump_htt_stats);
4903
	debugfs_create_file("htt_stats_reset", 0600, ar->debug.debugfs_pdev,
4904
			    ar, &fops_htt_stats_reset);
4905
}
4906

4907
Product

Resources

Company
