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 Qualcomm Innovation Center, Inc. All rights reserved.
5
 */
6

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

14
#define HTT_MAX_PRINT_CHAR_PER_ELEM 15
15

16
#define HTT_TLV_HDR_LEN 4
17

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

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

48
	tag_len = tag_len >> 2;
49

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

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

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

67
	stats_req->buf_len = len;
68
}
69

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

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

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

185
	stats_req->buf_len = len;
186
}
187

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

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

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

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

209
	stats_req->buf_len = len;
210
}
211

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

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

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

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

233
	stats_req->buf_len = len;
234
}
235

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

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

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

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

257
	stats_req->buf_len = len;
258
}
259

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

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

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

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

281
	stats_req->buf_len = len;
282
}
283

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

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

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

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

306
	stats_req->buf_len = len;
307
}
308

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

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

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

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

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

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

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

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

341
	stats_req->buf_len = len;
342
}
343

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

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

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

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

368
	stats_req->buf_len = len;
369
}
370

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

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

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

394
	stats_req->buf_len = len;
395
}
396

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

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

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

420
	stats_req->buf_len = len;
421
}
422

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

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

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

460
	stats_req->buf_len = len;
461
}
462

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

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

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

507
	stats_req->buf_len = len;
508
}
509

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

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

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

560
	stats_req->buf_len = len;
561
}
562

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

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

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

617
	stats_req->buf_len = len;
618
}
619

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

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

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

652
	stats_req->buf_len = len;
653
}
654

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

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

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

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

676
	stats_req->buf_len = len;
677
}
678

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

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

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

722
	stats_req->buf_len = len;
723
}
724

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

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

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

771
	stats_req->buf_len = len;
772
}
773

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

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

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

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

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

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

821
	stats_req->buf_len = len;
822
}
823

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

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

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

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

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

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

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

880
	stats_req->buf_len = len;
881
}
882

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

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

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

905
	stats_req->buf_len = len;
906
}
907

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

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

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

939
	stats_req->buf_len = len;
940
}
941

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

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

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

964
	stats_req->buf_len = len;
965
}
966

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

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

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

1029
	stats_req->buf_len = len;
1030
}
1031

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

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

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

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

1056
	stats_req->buf_len = len;
1057
}
1058

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

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

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

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

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

1083
	stats_req->buf_len = len;
1084
}
1085

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

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

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

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

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

1109
	stats_req->buf_len = len;
1110
}
1111

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

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

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

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

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

1136
	stats_req->buf_len = len;
1137
}
1138

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

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

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

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

1164
	stats_req->buf_len = len;
1165
}
1166

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

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

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

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

1189
	stats_req->buf_len = len;
1190
}
1191

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

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

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

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

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

1294
	stats_req->buf_len = len;
1295
}
1296

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

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

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

1337
	stats_req->buf_len = len;
1338
}
1339

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

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

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

1370
	stats_req->buf_len = len;
1371
}
1372

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

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

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

1421
	stats_req->buf_len = len;
1422
}
1423

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

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

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

1454
	stats_req->buf_len = len;
1455
}
1456

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

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

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

1505
	stats_req->buf_len = len;
1506
}
1507

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

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

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

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

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

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

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

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

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

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

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

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

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

1587
	stats_req->buf_len = len;
1588
}
1589

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

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

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

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

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

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

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

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

1717
	stats_req->buf_len = len;
1718
}
1719

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

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

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

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

1741
	stats_req->buf_len = len;
1742
}
1743

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

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

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

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

1765
	stats_req->buf_len = len;
1766
}
1767

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

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

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

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

1792
	stats_req->buf_len = len;
1793
}
1794

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

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

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

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

1819
	stats_req->buf_len = len;
1820
}
1821

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

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

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

1887
	stats_req->buf_len = len;
1888
}
1889

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

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

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

1909
	stats_req->buf_len = len;
1910
}
1911

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

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

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

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

1934
	stats_req->buf_len = len;
1935
}
1936

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

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

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

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

1959
	stats_req->buf_len = len;
1960
}
1961

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

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

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

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

1984
	stats_req->buf_len = len;
1985
}
1986

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

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

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

2065
	stats_req->buf_len = len;
2066
}
2067

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

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

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

2099
	stats_req->buf_len = len;
2100
}
2101

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

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

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

2123
	stats_req->buf_len = len;
2124
}
2125

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

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

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

2169
	stats_req->buf_len = len;
2170
}
2171

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

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

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

2201
	stats_req->buf_len = len;
2202
}
2203

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

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

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

2247
	stats_req->buf_len = len;
2248
}
2249

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

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

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

2332
	stats_req->buf_len = len;
2333
}
2334

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

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

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

2368
	stats_req->buf_len = len;
2369
}
2370

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

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

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

2394
	stats_req->buf_len = len;
2395
}
2396

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

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

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

2420
	stats_req->buf_len = len;
2421
}
2422

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

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

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

2448
	stats_req->buf_len = len;
2449
}
2450

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

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

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

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

2473
	stats_req->buf_len = len;
2474
}
2475

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

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

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

2505
	stats_req->buf_len = len;
2506
}
2507

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

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

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

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

2566
	stats_req->buf_len = len;
2567
}
2568

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

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

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

2588
	stats_req->buf_len = len;
2589
}
2590

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

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

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

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

2611
	stats_req->buf_len = len;
2612
}
2613

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

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

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

2643
	stats_req->buf_len = len;
2644
}
2645

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

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

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

2671
	stats_req->buf_len = len;
2672
}
2673

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

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

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

2733
	stats_req->buf_len = len;
2734
}
2735

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

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

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

2753
	stats_req->buf_len = len;
2754
}
2755

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

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

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

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

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

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

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

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

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

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

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

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

2879
	stats_req->buf_len = len;
2880
}
2881

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3105
	stats_req->buf_len = len;
3106
}
3107

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

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

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

3150
	stats_req->buf_len = len;
3151
}
3152

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

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

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

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

3175
	stats_req->buf_len = len;
3176
}
3177

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

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

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

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

3201
	stats_req->buf_len = len;
3202
}
3203

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

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

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

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

3226
	stats_req->buf_len = len;
3227
}
3228

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

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

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

3265
	stats_req->buf_len = len;
3266
}
3267

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

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

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

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

3290
	stats_req->buf_len = len;
3291
}
3292

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

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

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

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

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

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

3406
	stats_req->buf_len = len;
3407
}
3408

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

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

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

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

3429
	stats_req->buf_len = len;
3430
}
3431

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

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

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

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

3453
	stats_req->buf_len = len;
3454
}
3455

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

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

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

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

3479
	stats_req->buf_len = len;
3480
}
3481

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

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

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

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

3511
	stats_req->buf_len = len;
3512
}
3513

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

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

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

3539
	stats_req->buf_len = len;
3540
}
3541

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

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

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

3582
	stats_req->buf_len = len;
3583
}
3584

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

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

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

3605
	stats_req->buf_len = len;
3606
}
3607

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

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

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

3650
	stats_req->buf_len = len;
3651
}
3652

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

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

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

3684
	stats_req->buf_len = len;
3685
}
3686

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3797
	stats_req->buf_len = len;
3798
}
3799

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

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

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

3829
	stats_req->buf_len = len;
3830
}
3831

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

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

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

3861
	stats_req->buf_len = len;
3862
}
3863

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

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

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

3896
	stats_req->buf_len = len;
3897
}
3898

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

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

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

3931
	stats_req->buf_len = len;
3932
}
3933

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

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

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

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

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

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

3983
	stats_req->buf_len = len;
3984
}
3985

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

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

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

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

4011
	stats_req->buf_len = len;
4012
}
4013

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

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

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

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

4042
	stats_req->buf_len = len;
4043
}
4044

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

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

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

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

4119
	stats_req->buf_len = len;
4120
}
4121

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

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

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

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

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

4161
	stats_req->buf_len = len;
4162
}
4163

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4549
	return 0;
4550
}
4551

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4637
	ret = count;
4638

4639
	return ret;
4640
}
4641

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

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

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

4706
	return 0;
4707
}
4708

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

4717
	init_completion(&stats_req->cmpln);
4718

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

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

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

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

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

4749
	return 0;
4750
}
4751

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

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

4764
	mutex_lock(&ar->conf_mutex);
4765

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

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

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

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

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

4789
	file->private_data = stats_req;
4790

4791
	mutex_unlock(&ar->conf_mutex);
4792

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

4800
	return ret;
4801
}
4802

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

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

4812
	return 0;
4813
}
4814

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

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

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

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

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

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

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

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

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

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

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

4882
	ret = count;
4883

4884
	return ret;
4885
}
4886

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

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

4906
Product

Resources

Company
