1	// SPDX-License-Identifier: ISC
2	/*
3	* Copyright (c) 2005-2011 Atheros Communications Inc.
4	* Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
5	* Copyright (c) 2018, The Linux Foundation. All rights reserved.
6	* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
7	*/
8
9	#include <linux/module.h>
10	#include <linux/debugfs.h>
11	#include <linux/vmalloc.h>
12	#include <linux/crc32.h>
13	#include <linux/firmware.h>
14	#include <linux/kstrtox.h>
15
16	#include "core.h"
17	#include "debug.h"
18	#include "hif.h"
19	#include "wmi-ops.h"
20
21	/* ms */
22	#define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
23
24	#define ATH10K_DEBUG_CAL_DATA_LEN 12064
25
26	void ath10k_info(struct ath10k *ar, const char *fmt, ...)
27	{
28	struct va_format vaf = {
29	.fmt = fmt,
30	};
31	va_list args;
32
33	va_start(args, fmt);
34	vaf.va = &args;
35	dev_info(ar->dev, "%pV", &vaf);
36	trace_ath10k_log_info(ar, vaf: &vaf);
37	va_end(args);
38	}
39	EXPORT_SYMBOL(ath10k_info);
40
41	void ath10k_debug_print_hwfw_info(struct ath10k *ar)
42	{
43	const struct firmware *firmware;
44	char fw_features[128] = {};
45	u32 crc = 0;
46
47	ath10k_core_get_fw_features_str(ar, buf: fw_features, max_len: sizeof(fw_features));
48
49	ath10k_info(ar, "%s target 0x%08x chip_id 0x%08x sub %04x:%04x",
50	ar->hw_params.name,
51	ar->target_version,
52	ar->bus_param.chip_id,
53	ar->id.subsystem_vendor, ar->id.subsystem_device);
54
55	ath10k_info(ar, "kconfig debug %d debugfs %d tracing %d dfs %d testmode %d\n",
56	IS_ENABLED(CONFIG_ATH10K_DEBUG),
57	IS_ENABLED(CONFIG_ATH10K_DEBUGFS),
58	IS_ENABLED(CONFIG_ATH10K_TRACING),
59	IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED),
60	IS_ENABLED(CONFIG_NL80211_TESTMODE));
61
62	firmware = ar->normal_mode_fw.fw_file.firmware;
63	if (firmware)
64	crc = crc32_le(crc: 0, p: firmware->data, len: firmware->size);
65
66	ath10k_info(ar, "firmware ver %s api %d features %s crc32 %08x\n",
67	ar->hw->wiphy->fw_version,
68	ar->fw_api,
69	fw_features,
70	crc);
71	}
72
73	void ath10k_debug_print_board_info(struct ath10k *ar)
74	{
75	char boardinfo[100];
76	const struct firmware *board;
77	u32 crc;
78
79	if (ar->id.bmi_ids_valid)
80	scnprintf(buf: boardinfo, size: sizeof(boardinfo), fmt: "%d:%d",
81	ar->id.bmi_chip_id, ar->id.bmi_board_id);
82	else
83	scnprintf(buf: boardinfo, size: sizeof(boardinfo), fmt: "N/A");
84
85	board = ar->normal_mode_fw.board;
86	if (!IS_ERR_OR_NULL(ptr: board))
87	crc = crc32_le(crc: 0, p: board->data, len: board->size);
88	else
89	crc = 0;
90
91	ath10k_info(ar, "board_file api %d bmi_id %s crc32 %08x",
92	ar->bd_api,
93	boardinfo,
94	crc);
95	}
96
97	void ath10k_debug_print_boot_info(struct ath10k *ar)
98	{
99	ath10k_info(ar, "htt-ver %d.%d wmi-op %d htt-op %d cal %s max-sta %d raw %d hwcrypto %d\n",
100	ar->htt.target_version_major,
101	ar->htt.target_version_minor,
102	ar->normal_mode_fw.fw_file.wmi_op_version,
103	ar->normal_mode_fw.fw_file.htt_op_version,
104	ath10k_cal_mode_str(mode: ar->cal_mode),
105	ar->max_num_stations,
106	test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags),
107	!test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags));
108	}
109
110	void ath10k_print_driver_info(struct ath10k *ar)
111	{
112	ath10k_debug_print_hwfw_info(ar);
113	ath10k_debug_print_board_info(ar);
114	ath10k_debug_print_boot_info(ar);
115	}
116	EXPORT_SYMBOL(ath10k_print_driver_info);
117
118	void ath10k_err(struct ath10k *ar, const char *fmt, ...)
119	{
120	struct va_format vaf = {
121	.fmt = fmt,
122	};
123	va_list args;
124
125	va_start(args, fmt);
126	vaf.va = &args;
127	dev_err(ar->dev, "%pV", &vaf);
128	trace_ath10k_log_err(ar, vaf: &vaf);
129	va_end(args);
130	}
131	EXPORT_SYMBOL(ath10k_err);
132
133	void ath10k_warn(struct ath10k *ar, const char *fmt, ...)
134	{
135	struct va_format vaf = {
136	.fmt = fmt,
137	};
138	va_list args;
139
140	va_start(args, fmt);
141	vaf.va = &args;
142	dev_warn_ratelimited(ar->dev, "%pV", &vaf);
143	trace_ath10k_log_warn(ar, vaf: &vaf);
144
145	va_end(args);
146	}
147	EXPORT_SYMBOL(ath10k_warn);
148
149	#ifdef CONFIG_ATH10K_DEBUGFS
150
151	static ssize_t ath10k_read_wmi_services(struct file *file,
152	char __user *user_buf,
153	size_t count, loff_t *ppos)
154	{
155	struct ath10k *ar = file->private_data;
156	char *buf;
157	size_t len = 0, buf_len = 8192;
158	const char *name;
159	ssize_t ret_cnt;
160	bool enabled;
161	int i;
162
163	buf = kzalloc(size: buf_len, GFP_KERNEL);
164	if (!buf)
165	return -ENOMEM;
166
167	mutex_lock(&ar->conf_mutex);
168
169	spin_lock_bh(lock: &ar->data_lock);
170	for (i = 0; i < WMI_SERVICE_MAX; i++) {
171	enabled = test_bit(i, ar->wmi.svc_map);
172	name = wmi_service_name(service_id: i);
173
174	if (!name) {
175	if (enabled)
176	len += scnprintf(buf: buf + len, size: buf_len - len,
177	fmt: "%-40s %s (bit %d)\n",
178	"unknown", "enabled", i);
179
180	continue;
181	}
182
183	len += scnprintf(buf: buf + len, size: buf_len - len,
184	fmt: "%-40s %s\n",
185	name, enabled ? "enabled" : "-");
186	}
187	spin_unlock_bh(lock: &ar->data_lock);
188
189	ret_cnt = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
190
191	mutex_unlock(lock: &ar->conf_mutex);
192
193	kfree(objp: buf);
194	return ret_cnt;
195	}
196
197	static const struct file_operations fops_wmi_services = {
198	.read = ath10k_read_wmi_services,
199	.open = simple_open,
200	.owner = THIS_MODULE,
201	.llseek = default_llseek,
202	};
203
204	static void ath10k_fw_stats_pdevs_free(struct list_head *head)
205	{
206	struct ath10k_fw_stats_pdev *i, *tmp;
207
208	list_for_each_entry_safe(i, tmp, head, list) {
209	list_del(entry: &i->list);
210	kfree(objp: i);
211	}
212	}
213
214	static void ath10k_fw_stats_vdevs_free(struct list_head *head)
215	{
216	struct ath10k_fw_stats_vdev *i, *tmp;
217
218	list_for_each_entry_safe(i, tmp, head, list) {
219	list_del(entry: &i->list);
220	kfree(objp: i);
221	}
222	}
223
224	static void ath10k_fw_stats_peers_free(struct list_head *head)
225	{
226	struct ath10k_fw_stats_peer *i, *tmp;
227
228	list_for_each_entry_safe(i, tmp, head, list) {
229	list_del(entry: &i->list);
230	kfree(objp: i);
231	}
232	}
233
234	static void ath10k_fw_extd_stats_peers_free(struct list_head *head)
235	{
236	struct ath10k_fw_extd_stats_peer *i, *tmp;
237
238	list_for_each_entry_safe(i, tmp, head, list) {
239	list_del(entry: &i->list);
240	kfree(objp: i);
241	}
242	}
243
244	static void ath10k_debug_fw_stats_reset(struct ath10k *ar)
245	{
246	spin_lock_bh(lock: &ar->data_lock);
247	ar->debug.fw_stats_done = false;
248	ar->debug.fw_stats.extended = false;
249	ath10k_fw_stats_pdevs_free(head: &ar->debug.fw_stats.pdevs);
250	ath10k_fw_stats_vdevs_free(head: &ar->debug.fw_stats.vdevs);
251	ath10k_fw_stats_peers_free(head: &ar->debug.fw_stats.peers);
252	ath10k_fw_extd_stats_peers_free(head: &ar->debug.fw_stats.peers_extd);
253	spin_unlock_bh(lock: &ar->data_lock);
254	}
255
256	void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
257	{
258	struct ath10k_fw_stats stats = {};
259	bool is_start, is_started, is_end;
260	size_t num_peers;
261	size_t num_vdevs;
262	int ret;
263
264	INIT_LIST_HEAD(list: &stats.pdevs);
265	INIT_LIST_HEAD(list: &stats.vdevs);
266	INIT_LIST_HEAD(list: &stats.peers);
267	INIT_LIST_HEAD(list: &stats.peers_extd);
268
269	spin_lock_bh(lock: &ar->data_lock);
270	ret = ath10k_wmi_pull_fw_stats(ar, skb, stats: &stats);
271	if (ret) {
272	ath10k_warn(ar, "failed to pull fw stats: %d\n", ret);
273	goto free;
274	}
275
276	/* Stat data may exceed htc-wmi buffer limit. In such case firmware
277	* splits the stats data and delivers it in a ping-pong fashion of
278	* request cmd-update event.
279	*
280	* However there is no explicit end-of-data. Instead start-of-data is
281	* used as an implicit one. This works as follows:
282	* a) discard stat update events until one with pdev stats is
283	* delivered - this skips session started at end of (b)
284	* b) consume stat update events until another one with pdev stats is
285	* delivered which is treated as end-of-data and is itself discarded
286	*/
287	if (ath10k_peer_stats_enabled(ar))
288	ath10k_sta_update_rx_duration(ar, stats: &stats);
289
290	if (ar->debug.fw_stats_done) {
291	if (!ath10k_peer_stats_enabled(ar))
292	ath10k_warn(ar, "received unsolicited stats update event\n");
293
294	goto free;
295	}
296
297	num_peers = list_count_nodes(head: &ar->debug.fw_stats.peers);
298	num_vdevs = list_count_nodes(head: &ar->debug.fw_stats.vdevs);
299	is_start = (list_empty(head: &ar->debug.fw_stats.pdevs) &&
300	!list_empty(head: &stats.pdevs));
301	is_end = (!list_empty(head: &ar->debug.fw_stats.pdevs) &&
302	!list_empty(head: &stats.pdevs));
303
304	if (is_start)
305	list_splice_tail_init(list: &stats.pdevs, head: &ar->debug.fw_stats.pdevs);
306
307	if (is_end)
308	ar->debug.fw_stats_done = true;
309
310	if (stats.extended)
311	ar->debug.fw_stats.extended = true;
312
313	is_started = !list_empty(head: &ar->debug.fw_stats.pdevs);
314
315	if (is_started && !is_end) {
316	if (num_peers >= ATH10K_MAX_NUM_PEER_IDS) {
317	/* Although this is unlikely impose a sane limit to
318	* prevent firmware from DoS-ing the host.
319	*/
320	ath10k_fw_stats_peers_free(head: &ar->debug.fw_stats.peers);
321	ath10k_fw_extd_stats_peers_free(head: &ar->debug.fw_stats.peers_extd);
322	ath10k_warn(ar, "dropping fw peer stats\n");
323	goto free;
324	}
325
326	if (num_vdevs >= BITS_PER_LONG) {
327	ath10k_fw_stats_vdevs_free(head: &ar->debug.fw_stats.vdevs);
328	ath10k_warn(ar, "dropping fw vdev stats\n");
329	goto free;
330	}
331
332	if (!list_empty(head: &stats.peers))
333	list_splice_tail_init(list: &stats.peers_extd,
334	head: &ar->debug.fw_stats.peers_extd);
335
336	list_splice_tail_init(list: &stats.peers, head: &ar->debug.fw_stats.peers);
337	list_splice_tail_init(list: &stats.vdevs, head: &ar->debug.fw_stats.vdevs);
338	}
339
340	complete(&ar->debug.fw_stats_complete);
341
342	free:
343	/* In some cases lists have been spliced and cleared. Free up
344	* resources if that is not the case.
345	*/
346	ath10k_fw_stats_pdevs_free(head: &stats.pdevs);
347	ath10k_fw_stats_vdevs_free(head: &stats.vdevs);
348	ath10k_fw_stats_peers_free(head: &stats.peers);
349	ath10k_fw_extd_stats_peers_free(head: &stats.peers_extd);
350
351	spin_unlock_bh(lock: &ar->data_lock);
352	}
353
354	int ath10k_debug_fw_stats_request(struct ath10k *ar)
355	{
356	unsigned long timeout, time_left;
357	int ret;
358
359	lockdep_assert_held(&ar->conf_mutex);
360
361	timeout = jiffies + msecs_to_jiffies(m: 1 * HZ);
362
363	ath10k_debug_fw_stats_reset(ar);
364
365	for (;;) {
366	if (time_after(jiffies, timeout))
367	return -ETIMEDOUT;
368
369	reinit_completion(x: &ar->debug.fw_stats_complete);
370
371	ret = ath10k_wmi_request_stats(ar, stats_mask: ar->fw_stats_req_mask);
372	if (ret) {
373	ath10k_warn(ar, "could not request stats (%d)\n", ret);
374	return ret;
375	}
376
377	time_left =
378	wait_for_completion_timeout(x: &ar->debug.fw_stats_complete,
379	timeout: 1 * HZ);
380	if (!time_left)
381	return -ETIMEDOUT;
382
383	spin_lock_bh(lock: &ar->data_lock);
384	if (ar->debug.fw_stats_done) {
385	spin_unlock_bh(lock: &ar->data_lock);
386	break;
387	}
388	spin_unlock_bh(lock: &ar->data_lock);
389	}
390
391	return 0;
392	}
393
394	static int ath10k_fw_stats_open(struct inode *inode, struct file *file)
395	{
396	struct ath10k *ar = inode->i_private;
397	void *buf = NULL;
398	int ret;
399
400	mutex_lock(&ar->conf_mutex);
401
402	if (ar->state != ATH10K_STATE_ON) {
403	ret = -ENETDOWN;
404	goto err_unlock;
405	}
406
407	buf = vmalloc(ATH10K_FW_STATS_BUF_SIZE);
408	if (!buf) {
409	ret = -ENOMEM;
410	goto err_unlock;
411	}
412
413	ret = ath10k_debug_fw_stats_request(ar);
414	if (ret) {
415	ath10k_warn(ar, "failed to request fw stats: %d\n", ret);
416	goto err_free;
417	}
418
419	ret = ath10k_wmi_fw_stats_fill(ar, fw_stats: &ar->debug.fw_stats, buf);
420	if (ret) {
421	ath10k_warn(ar, "failed to fill fw stats: %d\n", ret);
422	goto err_free;
423	}
424
425	file->private_data = buf;
426
427	mutex_unlock(lock: &ar->conf_mutex);
428	return 0;
429
430	err_free:
431	vfree(addr: buf);
432
433	err_unlock:
434	mutex_unlock(lock: &ar->conf_mutex);
435	return ret;
436	}
437
438	static int ath10k_fw_stats_release(struct inode *inode, struct file *file)
439	{
440	vfree(addr: file->private_data);
441
442	return 0;
443	}
444
445	static ssize_t ath10k_fw_stats_read(struct file *file, char __user *user_buf,
446	size_t count, loff_t *ppos)
447	{
448	const char *buf = file->private_data;
449	size_t len = strlen(buf);
450
451	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
452	}
453
454	static const struct file_operations fops_fw_stats = {
455	.open = ath10k_fw_stats_open,
456	.release = ath10k_fw_stats_release,
457	.read = ath10k_fw_stats_read,
458	.owner = THIS_MODULE,
459	.llseek = default_llseek,
460	};
461
462	static ssize_t ath10k_debug_fw_reset_stats_read(struct file *file,
463	char __user *user_buf,
464	size_t count, loff_t *ppos)
465	{
466	struct ath10k *ar = file->private_data;
467	int ret;
468	size_t len = 0, buf_len = 500;
469	char *buf;
470
471	buf = kmalloc(size: buf_len, GFP_KERNEL);
472	if (!buf)
473	return -ENOMEM;
474
475	spin_lock_bh(lock: &ar->data_lock);
476
477	len += scnprintf(buf: buf + len, size: buf_len - len,
478	fmt: "fw_crash_counter\t\t%d\n", ar->stats.fw_crash_counter);
479	len += scnprintf(buf: buf + len, size: buf_len - len,
480	fmt: "fw_warm_reset_counter\t\t%d\n",
481	ar->stats.fw_warm_reset_counter);
482	len += scnprintf(buf: buf + len, size: buf_len - len,
483	fmt: "fw_cold_reset_counter\t\t%d\n",
484	ar->stats.fw_cold_reset_counter);
485
486	spin_unlock_bh(lock: &ar->data_lock);
487
488	ret = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
489
490	kfree(objp: buf);
491
492	return ret;
493	}
494
495	static const struct file_operations fops_fw_reset_stats = {
496	.open = simple_open,
497	.read = ath10k_debug_fw_reset_stats_read,
498	.owner = THIS_MODULE,
499	.llseek = default_llseek,
500	};
501
502	/* This is a clean assert crash in firmware. */
503	static int ath10k_debug_fw_assert(struct ath10k *ar)
504	{
505	struct wmi_vdev_install_key_cmd *cmd;
506	struct sk_buff *skb;
507
508	skb = ath10k_wmi_alloc_skb(ar, len: sizeof(*cmd) + 16);
509	if (!skb)
510	return -ENOMEM;
511
512	cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
513	memset(cmd, 0, sizeof(*cmd));
514
515	/* big enough number so that firmware asserts */
516	cmd->vdev_id = __cpu_to_le32(0x7ffe);
517
518	return ath10k_wmi_cmd_send(ar, skb,
519	cmd_id: ar->wmi.cmd->vdev_install_key_cmdid);
520	}
521
522	static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
523	char __user *user_buf,
524	size_t count, loff_t *ppos)
525	{
526	const char buf[] =
527	"To simulate firmware crash write one of the keywords to this file:\n"
528	"`soft` - this will send WMI_FORCE_FW_HANG_ASSERT to firmware if FW supports that command.\n"
529	"`hard` - this will send to firmware command with illegal parameters causing firmware crash.\n"
530	"`assert` - this will send special illegal parameter to firmware to cause assert failure and crash.\n"
531	"`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n";
532
533	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, strlen(buf));
534	}
535
536	/* Simulate firmware crash:
537	* 'soft': Call wmi command causing firmware hang. This firmware hang is
538	* recoverable by warm firmware reset.
539	* 'hard': Force firmware crash by setting any vdev parameter for not allowed
540	* vdev id. This is hard firmware crash because it is recoverable only by cold
541	* firmware reset.
542	*/
543	static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
544	const char __user *user_buf,
545	size_t count, loff_t *ppos)
546	{
547	struct ath10k *ar = file->private_data;
548	char buf[32] = {0};
549	ssize_t rc;
550	int ret;
551
552	/* filter partial writes and invalid commands */
553	if (*ppos != 0 || count >= sizeof(buf) || count == 0)
554	return -EINVAL;
555
556	rc = simple_write_to_buffer(to: buf, available: sizeof(buf) - 1, ppos, from: user_buf, count);
557	if (rc < 0)
558	return rc;
559
560	/* drop the possible '\n' from the end */
561	if (buf[*ppos - 1] == '\n')
562	buf[*ppos - 1] = '\0';
563
564	mutex_lock(&ar->conf_mutex);
565
566	if (ar->state != ATH10K_STATE_ON &&
567	ar->state != ATH10K_STATE_RESTARTED) {
568	ret = -ENETDOWN;
569	goto exit;
570	}
571
572	if (!strcmp(buf, "soft")) {
573	ath10k_info(ar, "simulating soft firmware crash\n");
574	ret = ath10k_wmi_force_fw_hang(ar, type: WMI_FORCE_FW_HANG_ASSERT, delay_ms: 0);
575	} else if (!strcmp(buf, "hard")) {
576	ath10k_info(ar, "simulating hard firmware crash\n");
577	/* 0x7fff is vdev id, and it is always out of range for all
578	* firmware variants in order to force a firmware crash.
579	*/
580	ret = ath10k_wmi_vdev_set_param(ar, vdev_id: 0x7fff,
581	param_id: ar->wmi.vdev_param->rts_threshold,
582	param_value: 0);
583	} else if (!strcmp(buf, "assert")) {
584	ath10k_info(ar, "simulating firmware assert crash\n");
585	ret = ath10k_debug_fw_assert(ar);
586	} else if (!strcmp(buf, "hw-restart")) {
587	ath10k_info(ar, "user requested hw restart\n");
588	ath10k_core_start_recovery(ar);
589	ret = 0;
590	} else {
591	ret = -EINVAL;
592	goto exit;
593	}
594
595	if (ret) {
596	ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
597	goto exit;
598	}
599
600	ret = count;
601
602	exit:
603	mutex_unlock(lock: &ar->conf_mutex);
604	return ret;
605	}
606
607	static const struct file_operations fops_simulate_fw_crash = {
608	.read = ath10k_read_simulate_fw_crash,
609	.write = ath10k_write_simulate_fw_crash,
610	.open = simple_open,
611	.owner = THIS_MODULE,
612	.llseek = default_llseek,
613	};
614
615	static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
616	size_t count, loff_t *ppos)
617	{
618	struct ath10k *ar = file->private_data;
619	size_t len;
620	char buf[50];
621
622	len = scnprintf(buf, size: sizeof(buf), fmt: "0x%08x\n", ar->bus_param.chip_id);
623
624	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
625	}
626
627	static const struct file_operations fops_chip_id = {
628	.read = ath10k_read_chip_id,
629	.open = simple_open,
630	.owner = THIS_MODULE,
631	.llseek = default_llseek,
632	};
633
634	static ssize_t ath10k_reg_addr_read(struct file *file,
635	char __user *user_buf,
636	size_t count, loff_t *ppos)
637	{
638	struct ath10k *ar = file->private_data;
639	u8 buf[32];
640	size_t len = 0;
641	u32 reg_addr;
642
643	mutex_lock(&ar->conf_mutex);
644	reg_addr = ar->debug.reg_addr;
645	mutex_unlock(lock: &ar->conf_mutex);
646
647	len += scnprintf(buf: buf + len, size: sizeof(buf) - len, fmt: "0x%x\n", reg_addr);
648
649	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
650	}
651
652	static ssize_t ath10k_reg_addr_write(struct file *file,
653	const char __user *user_buf,
654	size_t count, loff_t *ppos)
655	{
656	struct ath10k *ar = file->private_data;
657	u32 reg_addr;
658	int ret;
659
660	ret = kstrtou32_from_user(s: user_buf, count, base: 0, res: &reg_addr);
661	if (ret)
662	return ret;
663
664	if (!IS_ALIGNED(reg_addr, 4))
665	return -EFAULT;
666
667	mutex_lock(&ar->conf_mutex);
668	ar->debug.reg_addr = reg_addr;
669	mutex_unlock(lock: &ar->conf_mutex);
670
671	return count;
672	}
673
674	static const struct file_operations fops_reg_addr = {
675	.read = ath10k_reg_addr_read,
676	.write = ath10k_reg_addr_write,
677	.open = simple_open,
678	.owner = THIS_MODULE,
679	.llseek = default_llseek,
680	};
681
682	static ssize_t ath10k_reg_value_read(struct file *file,
683	char __user *user_buf,
684	size_t count, loff_t *ppos)
685	{
686	struct ath10k *ar = file->private_data;
687	u8 buf[48];
688	size_t len;
689	u32 reg_addr, reg_val;
690	int ret;
691
692	mutex_lock(&ar->conf_mutex);
693
694	if (ar->state != ATH10K_STATE_ON &&
695	ar->state != ATH10K_STATE_UTF) {
696	ret = -ENETDOWN;
697	goto exit;
698	}
699
700	reg_addr = ar->debug.reg_addr;
701
702	reg_val = ath10k_hif_read32(ar, address: reg_addr);
703	len = scnprintf(buf, size: sizeof(buf), fmt: "0x%08x:0x%08x\n", reg_addr, reg_val);
704
705	ret = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
706
707	exit:
708	mutex_unlock(lock: &ar->conf_mutex);
709
710	return ret;
711	}
712
713	static ssize_t ath10k_reg_value_write(struct file *file,
714	const char __user *user_buf,
715	size_t count, loff_t *ppos)
716	{
717	struct ath10k *ar = file->private_data;
718	u32 reg_addr, reg_val;
719	int ret;
720
721	mutex_lock(&ar->conf_mutex);
722
723	if (ar->state != ATH10K_STATE_ON &&
724	ar->state != ATH10K_STATE_UTF) {
725	ret = -ENETDOWN;
726	goto exit;
727	}
728
729	reg_addr = ar->debug.reg_addr;
730
731	ret = kstrtou32_from_user(s: user_buf, count, base: 0, res: &reg_val);
732	if (ret)
733	goto exit;
734
735	ath10k_hif_write32(ar, address: reg_addr, data: reg_val);
736
737	ret = count;
738
739	exit:
740	mutex_unlock(lock: &ar->conf_mutex);
741
742	return ret;
743	}
744
745	static const struct file_operations fops_reg_value = {
746	.read = ath10k_reg_value_read,
747	.write = ath10k_reg_value_write,
748	.open = simple_open,
749	.owner = THIS_MODULE,
750	.llseek = default_llseek,
751	};
752
753	static ssize_t ath10k_mem_value_read(struct file *file,
754	char __user *user_buf,
755	size_t count, loff_t *ppos)
756	{
757	struct ath10k *ar = file->private_data;
758	u8 *buf;
759	int ret;
760
761	if (*ppos < 0)
762	return -EINVAL;
763
764	if (!count)
765	return 0;
766
767	mutex_lock(&ar->conf_mutex);
768
769	buf = vmalloc(size: count);
770	if (!buf) {
771	ret = -ENOMEM;
772	goto exit;
773	}
774
775	if (ar->state != ATH10K_STATE_ON &&
776	ar->state != ATH10K_STATE_UTF) {
777	ret = -ENETDOWN;
778	goto exit;
779	}
780
781	ret = ath10k_hif_diag_read(ar, address: *ppos, buf, buf_len: count);
782	if (ret) {
783	ath10k_warn(ar, "failed to read address 0x%08x via diagnose window from debugfs: %d\n",
784	(u32)(*ppos), ret);
785	goto exit;
786	}
787
788	ret = copy_to_user(to: user_buf, from: buf, n: count);
789	if (ret) {
790	ret = -EFAULT;
791	goto exit;
792	}
793
794	count -= ret;
795	*ppos += count;
796	ret = count;
797
798	exit:
799	vfree(addr: buf);
800	mutex_unlock(lock: &ar->conf_mutex);
801
802	return ret;
803	}
804
805	static ssize_t ath10k_mem_value_write(struct file *file,
806	const char __user *user_buf,
807	size_t count, loff_t *ppos)
808	{
809	struct ath10k *ar = file->private_data;
810	u8 *buf;
811	int ret;
812
813	if (*ppos < 0)
814	return -EINVAL;
815
816	if (!count)
817	return 0;
818
819	mutex_lock(&ar->conf_mutex);
820
821	buf = vmalloc(size: count);
822	if (!buf) {
823	ret = -ENOMEM;
824	goto exit;
825	}
826
827	if (ar->state != ATH10K_STATE_ON &&
828	ar->state != ATH10K_STATE_UTF) {
829	ret = -ENETDOWN;
830	goto exit;
831	}
832
833	ret = copy_from_user(to: buf, from: user_buf, n: count);
834	if (ret) {
835	ret = -EFAULT;
836	goto exit;
837	}
838
839	ret = ath10k_hif_diag_write(ar, address: *ppos, data: buf, nbytes: count);
840	if (ret) {
841	ath10k_warn(ar, "failed to write address 0x%08x via diagnose window from debugfs: %d\n",
842	(u32)(*ppos), ret);
843	goto exit;
844	}
845
846	*ppos += count;
847	ret = count;
848
849	exit:
850	vfree(addr: buf);
851	mutex_unlock(lock: &ar->conf_mutex);
852
853	return ret;
854	}
855
856	static const struct file_operations fops_mem_value = {
857	.read = ath10k_mem_value_read,
858	.write = ath10k_mem_value_write,
859	.open = simple_open,
860	.owner = THIS_MODULE,
861	.llseek = default_llseek,
862	};
863
864	static int ath10k_debug_htt_stats_req(struct ath10k *ar)
865	{
866	u64 cookie;
867	int ret;
868
869	lockdep_assert_held(&ar->conf_mutex);
870
871	if (ar->debug.htt_stats_mask == 0)
872	/* htt stats are disabled */
873	return 0;
874
875	if (ar->state != ATH10K_STATE_ON)
876	return 0;
877
878	cookie = get_jiffies_64();
879
880	ret = ath10k_htt_h2t_stats_req(htt: &ar->htt, mask: ar->debug.htt_stats_mask,
881	reset_mask: ar->debug.reset_htt_stats, cookie);
882	if (ret) {
883	ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
884	return ret;
885	}
886
887	queue_delayed_work(wq: ar->workqueue, dwork: &ar->debug.htt_stats_dwork,
888	delay: msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
889
890	return 0;
891	}
892
893	static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
894	{
895	struct ath10k *ar = container_of(work, struct ath10k,
896	debug.htt_stats_dwork.work);
897
898	mutex_lock(&ar->conf_mutex);
899
900	ath10k_debug_htt_stats_req(ar);
901
902	mutex_unlock(lock: &ar->conf_mutex);
903	}
904
905	static ssize_t ath10k_read_htt_stats_mask(struct file *file,
906	char __user *user_buf,
907	size_t count, loff_t *ppos)
908	{
909	struct ath10k *ar = file->private_data;
910	char buf[32];
911	size_t len;
912
913	len = scnprintf(buf, size: sizeof(buf), fmt: "%lu\n", ar->debug.htt_stats_mask);
914
915	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
916	}
917
918	static ssize_t ath10k_write_htt_stats_mask(struct file *file,
919	const char __user *user_buf,
920	size_t count, loff_t *ppos)
921	{
922	struct ath10k *ar = file->private_data;
923	unsigned long mask;
924	int ret;
925
926	ret = kstrtoul_from_user(s: user_buf, count, base: 0, res: &mask);
927	if (ret)
928	return ret;
929
930	/* max 17 bit masks (for now) */
931	if (mask > HTT_STATS_BIT_MASK)
932	return -E2BIG;
933
934	mutex_lock(&ar->conf_mutex);
935
936	ar->debug.htt_stats_mask = mask;
937
938	ret = ath10k_debug_htt_stats_req(ar);
939	if (ret)
940	goto out;
941
942	ret = count;
943
944	out:
945	mutex_unlock(lock: &ar->conf_mutex);
946
947	return ret;
948	}
949
950	static const struct file_operations fops_htt_stats_mask = {
951	.read = ath10k_read_htt_stats_mask,
952	.write = ath10k_write_htt_stats_mask,
953	.open = simple_open,
954	.owner = THIS_MODULE,
955	.llseek = default_llseek,
956	};
957
958	static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
959	char __user *user_buf,
960	size_t count, loff_t *ppos)
961	{
962	struct ath10k *ar = file->private_data;
963	char buf[64];
964	u8 amsdu, ampdu;
965	size_t len;
966
967	mutex_lock(&ar->conf_mutex);
968
969	amsdu = ar->htt.max_num_amsdu;
970	ampdu = ar->htt.max_num_ampdu;
971	mutex_unlock(lock: &ar->conf_mutex);
972
973	len = scnprintf(buf, size: sizeof(buf), fmt: "%u %u\n", amsdu, ampdu);
974
975	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
976	}
977
978	static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
979	const char __user *user_buf,
980	size_t count, loff_t *ppos)
981	{
982	struct ath10k *ar = file->private_data;
983	int res;
984	char buf[64] = {0};
985	unsigned int amsdu, ampdu;
986
987	res = simple_write_to_buffer(to: buf, available: sizeof(buf) - 1, ppos,
988	from: user_buf, count);
989	if (res <= 0)
990	return res;
991
992	res = sscanf(buf, "%u %u", &amsdu, &ampdu);
993
994	if (res != 2)
995	return -EINVAL;
996
997	mutex_lock(&ar->conf_mutex);
998
999	res = ath10k_htt_h2t_aggr_cfg_msg(htt: &ar->htt, max_subfrms_ampdu: ampdu, max_subfrms_amsdu: amsdu);
1000	if (res)
1001	goto out;
1002
1003	res = count;
1004	ar->htt.max_num_amsdu = amsdu;
1005	ar->htt.max_num_ampdu = ampdu;
1006
1007	out:
1008	mutex_unlock(lock: &ar->conf_mutex);
1009	return res;
1010	}
1011
1012	static const struct file_operations fops_htt_max_amsdu_ampdu = {
1013	.read = ath10k_read_htt_max_amsdu_ampdu,
1014	.write = ath10k_write_htt_max_amsdu_ampdu,
1015	.open = simple_open,
1016	.owner = THIS_MODULE,
1017	.llseek = default_llseek,
1018	};
1019
1020	static ssize_t ath10k_read_fw_dbglog(struct file *file,
1021	char __user *user_buf,
1022	size_t count, loff_t *ppos)
1023	{
1024	struct ath10k *ar = file->private_data;
1025	size_t len;
1026	char buf[96];
1027
1028	len = scnprintf(buf, size: sizeof(buf), fmt: "0x%16llx %u\n",
1029	ar->debug.fw_dbglog_mask, ar->debug.fw_dbglog_level);
1030
1031	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
1032	}
1033
1034	static ssize_t ath10k_write_fw_dbglog(struct file *file,
1035	const char __user *user_buf,
1036	size_t count, loff_t *ppos)
1037	{
1038	struct ath10k *ar = file->private_data;
1039	int ret;
1040	char buf[96] = {0};
1041	unsigned int log_level;
1042	u64 mask;
1043
1044	ret = simple_write_to_buffer(to: buf, available: sizeof(buf) - 1, ppos,
1045	from: user_buf, count);
1046	if (ret <= 0)
1047	return ret;
1048
1049	ret = sscanf(buf, "%llx %u", &mask, &log_level);
1050
1051	if (!ret)
1052	return -EINVAL;
1053
1054	if (ret == 1)
1055	/* default if user did not specify */
1056	log_level = ATH10K_DBGLOG_LEVEL_WARN;
1057
1058	mutex_lock(&ar->conf_mutex);
1059
1060	ar->debug.fw_dbglog_mask = mask;
1061	ar->debug.fw_dbglog_level = log_level;
1062
1063	if (ar->state == ATH10K_STATE_ON) {
1064	ret = ath10k_wmi_dbglog_cfg(ar, module_enable: ar->debug.fw_dbglog_mask,
1065	log_level: ar->debug.fw_dbglog_level);
1066	if (ret) {
1067	ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1068	ret);
1069	goto exit;
1070	}
1071	}
1072
1073	ret = count;
1074
1075	exit:
1076	mutex_unlock(lock: &ar->conf_mutex);
1077
1078	return ret;
1079	}
1080
1081	/* TODO: Would be nice to always support ethtool stats, would need to
1082	* move the stats storage out of ath10k_debug, or always have ath10k_debug
1083	* struct available..
1084	*/
1085
1086	/* This generally corresponds to the debugfs fw_stats file */
1087	static const char ath10k_gstrings_stats[][ETH_GSTRING_LEN] = {
1088	"tx_pkts_nic",
1089	"tx_bytes_nic",
1090	"rx_pkts_nic",
1091	"rx_bytes_nic",
1092	"d_noise_floor",
1093	"d_cycle_count",
1094	"d_phy_error",
1095	"d_rts_bad",
1096	"d_rts_good",
1097	"d_tx_power", /* in .5 dbM I think */
1098	"d_rx_crc_err", /* fcs_bad */
1099	"d_rx_crc_err_drop", /* frame with FCS error, dropped late in kernel */
1100	"d_no_beacon",
1101	"d_tx_mpdus_queued",
1102	"d_tx_msdu_queued",
1103	"d_tx_msdu_dropped",
1104	"d_local_enqued",
1105	"d_local_freed",
1106	"d_tx_ppdu_hw_queued",
1107	"d_tx_ppdu_reaped",
1108	"d_tx_fifo_underrun",
1109	"d_tx_ppdu_abort",
1110	"d_tx_mpdu_requeued",
1111	"d_tx_excessive_retries",
1112	"d_tx_hw_rate",
1113	"d_tx_dropped_sw_retries",
1114	"d_tx_illegal_rate",
1115	"d_tx_continuous_xretries",
1116	"d_tx_timeout",
1117	"d_tx_mpdu_txop_limit",
1118	"d_pdev_resets",
1119	"d_rx_mid_ppdu_route_change",
1120	"d_rx_status",
1121	"d_rx_extra_frags_ring0",
1122	"d_rx_extra_frags_ring1",
1123	"d_rx_extra_frags_ring2",
1124	"d_rx_extra_frags_ring3",
1125	"d_rx_msdu_htt",
1126	"d_rx_mpdu_htt",
1127	"d_rx_msdu_stack",
1128	"d_rx_mpdu_stack",
1129	"d_rx_phy_err",
1130	"d_rx_phy_err_drops",
1131	"d_rx_mpdu_errors", /* FCS, MIC, ENC */
1132	"d_fw_crash_count",
1133	"d_fw_warm_reset_count",
1134	"d_fw_cold_reset_count",
1135	};
1136
1137	#define ATH10K_SSTATS_LEN ARRAY_SIZE(ath10k_gstrings_stats)
1138
1139	void ath10k_debug_get_et_strings(struct ieee80211_hw *hw,
1140	struct ieee80211_vif *vif,
1141	u32 sset, u8 *data)
1142	{
1143	if (sset == ETH_SS_STATS)
1144	memcpy(data, ath10k_gstrings_stats,
1145	sizeof(ath10k_gstrings_stats));
1146	}
1147
1148	int ath10k_debug_get_et_sset_count(struct ieee80211_hw *hw,
1149	struct ieee80211_vif *vif, int sset)
1150	{
1151	if (sset == ETH_SS_STATS)
1152	return ATH10K_SSTATS_LEN;
1153
1154	return 0;
1155	}
1156
1157	void ath10k_debug_get_et_stats(struct ieee80211_hw *hw,
1158	struct ieee80211_vif *vif,
1159	struct ethtool_stats *stats, u64 *data)
1160	{
1161	struct ath10k *ar = hw->priv;
1162	static const struct ath10k_fw_stats_pdev zero_stats = {};
1163	const struct ath10k_fw_stats_pdev *pdev_stats;
1164	int i = 0, ret;
1165
1166	mutex_lock(&ar->conf_mutex);
1167
1168	if (ar->state == ATH10K_STATE_ON) {
1169	ret = ath10k_debug_fw_stats_request(ar);
1170	if (ret) {
1171	/* just print a warning and try to use older results */
1172	ath10k_warn(ar,
1173	"failed to get fw stats for ethtool: %d\n",
1174	ret);
1175	}
1176	}
1177
1178	pdev_stats = list_first_entry_or_null(&ar->debug.fw_stats.pdevs,
1179	struct ath10k_fw_stats_pdev,
1180	list);
1181	if (!pdev_stats) {
1182	/* no results available so just return zeroes */
1183	pdev_stats = &zero_stats;
1184	}
1185
1186	spin_lock_bh(lock: &ar->data_lock);
1187
1188	data[i++] = pdev_stats->hw_reaped; /* ppdu reaped */
1189	data[i++] = 0; /* tx bytes */
1190	data[i++] = pdev_stats->htt_mpdus;
1191	data[i++] = 0; /* rx bytes */
1192	data[i++] = pdev_stats->ch_noise_floor;
1193	data[i++] = pdev_stats->cycle_count;
1194	data[i++] = pdev_stats->phy_err_count;
1195	data[i++] = pdev_stats->rts_bad;
1196	data[i++] = pdev_stats->rts_good;
1197	data[i++] = pdev_stats->chan_tx_power;
1198	data[i++] = pdev_stats->fcs_bad;
1199	data[i++] = ar->stats.rx_crc_err_drop;
1200	data[i++] = pdev_stats->no_beacons;
1201	data[i++] = pdev_stats->mpdu_enqued;
1202	data[i++] = pdev_stats->msdu_enqued;
1203	data[i++] = pdev_stats->wmm_drop;
1204	data[i++] = pdev_stats->local_enqued;
1205	data[i++] = pdev_stats->local_freed;
1206	data[i++] = pdev_stats->hw_queued;
1207	data[i++] = pdev_stats->hw_reaped;
1208	data[i++] = pdev_stats->underrun;
1209	data[i++] = pdev_stats->tx_abort;
1210	data[i++] = pdev_stats->mpdus_requeued;
1211	data[i++] = pdev_stats->tx_ko;
1212	data[i++] = pdev_stats->data_rc;
1213	data[i++] = pdev_stats->sw_retry_failure;
1214	data[i++] = pdev_stats->illgl_rate_phy_err;
1215	data[i++] = pdev_stats->pdev_cont_xretry;
1216	data[i++] = pdev_stats->pdev_tx_timeout;
1217	data[i++] = pdev_stats->txop_ovf;
1218	data[i++] = pdev_stats->pdev_resets;
1219	data[i++] = pdev_stats->mid_ppdu_route_change;
1220	data[i++] = pdev_stats->status_rcvd;
1221	data[i++] = pdev_stats->r0_frags;
1222	data[i++] = pdev_stats->r1_frags;
1223	data[i++] = pdev_stats->r2_frags;
1224	data[i++] = pdev_stats->r3_frags;
1225	data[i++] = pdev_stats->htt_msdus;
1226	data[i++] = pdev_stats->htt_mpdus;
1227	data[i++] = pdev_stats->loc_msdus;
1228	data[i++] = pdev_stats->loc_mpdus;
1229	data[i++] = pdev_stats->phy_errs;
1230	data[i++] = pdev_stats->phy_err_drop;
1231	data[i++] = pdev_stats->mpdu_errs;
1232	data[i++] = ar->stats.fw_crash_counter;
1233	data[i++] = ar->stats.fw_warm_reset_counter;
1234	data[i++] = ar->stats.fw_cold_reset_counter;
1235
1236	spin_unlock_bh(lock: &ar->data_lock);
1237
1238	mutex_unlock(lock: &ar->conf_mutex);
1239
1240	WARN_ON(i != ATH10K_SSTATS_LEN);
1241	}
1242
1243	static const struct file_operations fops_fw_dbglog = {
1244	.read = ath10k_read_fw_dbglog,
1245	.write = ath10k_write_fw_dbglog,
1246	.open = simple_open,
1247	.owner = THIS_MODULE,
1248	.llseek = default_llseek,
1249	};
1250
1251	static int ath10k_debug_cal_data_fetch(struct ath10k *ar)
1252	{
1253	u32 hi_addr;
1254	__le32 addr;
1255	int ret;
1256
1257	lockdep_assert_held(&ar->conf_mutex);
1258
1259	if (WARN_ON(ar->hw_params.cal_data_len > ATH10K_DEBUG_CAL_DATA_LEN))
1260	return -EINVAL;
1261
1262	if (ar->hw_params.cal_data_len == 0)
1263	return -EOPNOTSUPP;
1264
1265	hi_addr = host_interest_item_address(HI_ITEM(hi_board_data));
1266
1267	ret = ath10k_hif_diag_read(ar, address: hi_addr, buf: &addr, buf_len: sizeof(addr));
1268	if (ret) {
1269	ath10k_warn(ar, "failed to read hi_board_data address: %d\n",
1270	ret);
1271	return ret;
1272	}
1273
1274	ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), buf: ar->debug.cal_data,
1275	buf_len: ar->hw_params.cal_data_len);
1276	if (ret) {
1277	ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
1278	return ret;
1279	}
1280
1281	return 0;
1282	}
1283
1284	static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
1285	{
1286	struct ath10k *ar = inode->i_private;
1287
1288	mutex_lock(&ar->conf_mutex);
1289
1290	if (ar->state == ATH10K_STATE_ON ||
1291	ar->state == ATH10K_STATE_UTF) {
1292	ath10k_debug_cal_data_fetch(ar);
1293	}
1294
1295	file->private_data = ar;
1296	mutex_unlock(lock: &ar->conf_mutex);
1297
1298	return 0;
1299	}
1300
1301	static ssize_t ath10k_debug_cal_data_read(struct file *file,
1302	char __user *user_buf,
1303	size_t count, loff_t *ppos)
1304	{
1305	struct ath10k *ar = file->private_data;
1306
1307	mutex_lock(&ar->conf_mutex);
1308
1309	count = simple_read_from_buffer(to: user_buf, count, ppos,
1310	from: ar->debug.cal_data,
1311	available: ar->hw_params.cal_data_len);
1312
1313	mutex_unlock(lock: &ar->conf_mutex);
1314
1315	return count;
1316	}
1317
1318	static ssize_t ath10k_write_ani_enable(struct file *file,
1319	const char __user *user_buf,
1320	size_t count, loff_t *ppos)
1321	{
1322	struct ath10k *ar = file->private_data;
1323	int ret;
1324	u8 enable;
1325
1326	if (kstrtou8_from_user(s: user_buf, count, base: 0, res: &enable))
1327	return -EINVAL;
1328
1329	mutex_lock(&ar->conf_mutex);
1330
1331	if (ar->ani_enabled == enable) {
1332	ret = count;
1333	goto exit;
1334	}
1335
1336	ret = ath10k_wmi_pdev_set_param(ar, id: ar->wmi.pdev_param->ani_enable,
1337	value: enable);
1338	if (ret) {
1339	ath10k_warn(ar, "ani_enable failed from debugfs: %d\n", ret);
1340	goto exit;
1341	}
1342	ar->ani_enabled = enable;
1343
1344	ret = count;
1345
1346	exit:
1347	mutex_unlock(lock: &ar->conf_mutex);
1348
1349	return ret;
1350	}
1351
1352	static ssize_t ath10k_read_ani_enable(struct file *file, char __user *user_buf,
1353	size_t count, loff_t *ppos)
1354	{
1355	struct ath10k *ar = file->private_data;
1356	size_t len;
1357	char buf[32];
1358
1359	len = scnprintf(buf, size: sizeof(buf), fmt: "%d\n", ar->ani_enabled);
1360
1361	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
1362	}
1363
1364	static const struct file_operations fops_ani_enable = {
1365	.read = ath10k_read_ani_enable,
1366	.write = ath10k_write_ani_enable,
1367	.open = simple_open,
1368	.owner = THIS_MODULE,
1369	.llseek = default_llseek,
1370	};
1371
1372	static const struct file_operations fops_cal_data = {
1373	.open = ath10k_debug_cal_data_open,
1374	.read = ath10k_debug_cal_data_read,
1375	.owner = THIS_MODULE,
1376	.llseek = default_llseek,
1377	};
1378
1379	static ssize_t ath10k_read_nf_cal_period(struct file *file,
1380	char __user *user_buf,
1381	size_t count, loff_t *ppos)
1382	{
1383	struct ath10k *ar = file->private_data;
1384	size_t len;
1385	char buf[32];
1386
1387	len = scnprintf(buf, size: sizeof(buf), fmt: "%d\n", ar->debug.nf_cal_period);
1388
1389	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
1390	}
1391
1392	static ssize_t ath10k_write_nf_cal_period(struct file *file,
1393	const char __user *user_buf,
1394	size_t count, loff_t *ppos)
1395	{
1396	struct ath10k *ar = file->private_data;
1397	unsigned long period;
1398	int ret;
1399
1400	ret = kstrtoul_from_user(s: user_buf, count, base: 0, res: &period);
1401	if (ret)
1402	return ret;
1403
1404	if (period > WMI_PDEV_PARAM_CAL_PERIOD_MAX)
1405	return -EINVAL;
1406
1407	/* there's no way to switch back to the firmware default */
1408	if (period == 0)
1409	return -EINVAL;
1410
1411	mutex_lock(&ar->conf_mutex);
1412
1413	ar->debug.nf_cal_period = period;
1414
1415	if (ar->state != ATH10K_STATE_ON) {
1416	/* firmware is not running, nothing else to do */
1417	ret = count;
1418	goto exit;
1419	}
1420
1421	ret = ath10k_wmi_pdev_set_param(ar, id: ar->wmi.pdev_param->cal_period,
1422	value: ar->debug.nf_cal_period);
1423	if (ret) {
1424	ath10k_warn(ar, "cal period cfg failed from debugfs: %d\n",
1425	ret);
1426	goto exit;
1427	}
1428
1429	ret = count;
1430
1431	exit:
1432	mutex_unlock(lock: &ar->conf_mutex);
1433
1434	return ret;
1435	}
1436
1437	static const struct file_operations fops_nf_cal_period = {
1438	.read = ath10k_read_nf_cal_period,
1439	.write = ath10k_write_nf_cal_period,
1440	.open = simple_open,
1441	.owner = THIS_MODULE,
1442	.llseek = default_llseek,
1443	};
1444
1445	#define ATH10K_TPC_CONFIG_BUF_SIZE (1024 * 1024)
1446
1447	static int ath10k_debug_tpc_stats_request(struct ath10k *ar)
1448	{
1449	int ret;
1450	unsigned long time_left;
1451
1452	lockdep_assert_held(&ar->conf_mutex);
1453
1454	reinit_completion(x: &ar->debug.tpc_complete);
1455
1456	ret = ath10k_wmi_pdev_get_tpc_config(ar, WMI_TPC_CONFIG_PARAM);
1457	if (ret) {
1458	ath10k_warn(ar, "failed to request tpc config: %d\n", ret);
1459	return ret;
1460	}
1461
1462	time_left = wait_for_completion_timeout(x: &ar->debug.tpc_complete,
1463	timeout: 1 * HZ);
1464	if (time_left == 0)
1465	return -ETIMEDOUT;
1466
1467	return 0;
1468	}
1469
1470	void ath10k_debug_tpc_stats_process(struct ath10k *ar,
1471	struct ath10k_tpc_stats *tpc_stats)
1472	{
1473	spin_lock_bh(lock: &ar->data_lock);
1474
1475	kfree(objp: ar->debug.tpc_stats);
1476	ar->debug.tpc_stats = tpc_stats;
1477	complete(&ar->debug.tpc_complete);
1478
1479	spin_unlock_bh(lock: &ar->data_lock);
1480	}
1481
1482	void
1483	ath10k_debug_tpc_stats_final_process(struct ath10k *ar,
1484	struct ath10k_tpc_stats_final *tpc_stats)
1485	{
1486	spin_lock_bh(lock: &ar->data_lock);
1487
1488	kfree(objp: ar->debug.tpc_stats_final);
1489	ar->debug.tpc_stats_final = tpc_stats;
1490	complete(&ar->debug.tpc_complete);
1491
1492	spin_unlock_bh(lock: &ar->data_lock);
1493	}
1494
1495	static void ath10k_tpc_stats_print(struct ath10k_tpc_stats *tpc_stats,
1496	unsigned int j, char *buf, size_t *len)
1497	{
1498	int i;
1499	size_t buf_len;
1500	static const char table_str[][5] = { "CDD",
1501	"STBC",
1502	"TXBF" };
1503	static const char pream_str[][6] = { "CCK",
1504	"OFDM",
1505	"HT20",
1506	"HT40",
1507	"VHT20",
1508	"VHT40",
1509	"VHT80",
1510	"HTCUP" };
1511
1512	buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1513	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1514	fmt: "********************************\n");
1515	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1516	fmt: "******************* %s POWER TABLE ****************\n",
1517	table_str[j]);
1518	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1519	fmt: "********************************\n");
1520	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1521	fmt: "No. Preamble Rate_code ");
1522
1523	for (i = 0; i < tpc_stats->num_tx_chain; i++)
1524	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1525	fmt: "tpc_value%d ", i);
1526
1527	*len += scnprintf(buf: buf + *len, size: buf_len - *len, fmt: "\n");
1528
1529	for (i = 0; i < tpc_stats->rate_max; i++) {
1530	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1531	fmt: "%8d %s 0x%2x %s\n", i,
1532	pream_str[tpc_stats->tpc_table[j].pream_idx[i]],
1533	tpc_stats->tpc_table[j].rate_code[i],
1534	tpc_stats->tpc_table[j].tpc_value[i]);
1535	}
1536
1537	*len += scnprintf(buf: buf + *len, size: buf_len - *len,
1538	fmt: "***********************************\n");
1539	}
1540
1541	static void ath10k_tpc_stats_fill(struct ath10k *ar,
1542	struct ath10k_tpc_stats *tpc_stats,
1543	char *buf)
1544	{
1545	int j;
1546	size_t len, buf_len;
1547
1548	len = 0;
1549	buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1550
1551	spin_lock_bh(lock: &ar->data_lock);
1552
1553	if (!tpc_stats) {
1554	ath10k_warn(ar, "failed to get tpc stats\n");
1555	goto unlock;
1556	}
1557
1558	len += scnprintf(buf: buf + len, size: buf_len - len, fmt: "\n");
1559	len += scnprintf(buf: buf + len, size: buf_len - len,
1560	fmt: "*************************************\n");
1561	len += scnprintf(buf: buf + len, size: buf_len - len,
1562	fmt: "TPC config for channel %4d mode %d\n",
1563	tpc_stats->chan_freq,
1564	tpc_stats->phy_mode);
1565	len += scnprintf(buf: buf + len, size: buf_len - len,
1566	fmt: "*************************************\n");
1567	len += scnprintf(buf: buf + len, size: buf_len - len,
1568	fmt: "CTL = 0x%2x Reg. Domain = %2d\n",
1569	tpc_stats->ctl,
1570	tpc_stats->reg_domain);
1571	len += scnprintf(buf: buf + len, size: buf_len - len,
1572	fmt: "Antenna Gain = %2d Reg. Max Antenna Gain = %2d\n",
1573	tpc_stats->twice_antenna_gain,
1574	tpc_stats->twice_antenna_reduction);
1575	len += scnprintf(buf: buf + len, size: buf_len - len,
1576	fmt: "Power Limit = %2d Reg. Max Power = %2d\n",
1577	tpc_stats->power_limit,
1578	tpc_stats->twice_max_rd_power / 2);
1579	len += scnprintf(buf: buf + len, size: buf_len - len,
1580	fmt: "Num tx chains = %2d Num supported rates = %2d\n",
1581	tpc_stats->num_tx_chain,
1582	tpc_stats->rate_max);
1583
1584	for (j = 0; j < WMI_TPC_FLAG; j++) {
1585	switch (j) {
1586	case WMI_TPC_TABLE_TYPE_CDD:
1587	if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1588	len += scnprintf(buf: buf + len, size: buf_len - len,
1589	fmt: "CDD not supported\n");
1590	break;
1591	}
1592
1593	ath10k_tpc_stats_print(tpc_stats, j, buf, len: &len);
1594	break;
1595	case WMI_TPC_TABLE_TYPE_STBC:
1596	if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1597	len += scnprintf(buf: buf + len, size: buf_len - len,
1598	fmt: "STBC not supported\n");
1599	break;
1600	}
1601
1602	ath10k_tpc_stats_print(tpc_stats, j, buf, len: &len);
1603	break;
1604	case WMI_TPC_TABLE_TYPE_TXBF:
1605	if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1606	len += scnprintf(buf: buf + len, size: buf_len - len,
1607	fmt: "TXBF not supported\n***************************\n");
1608	break;
1609	}
1610
1611	ath10k_tpc_stats_print(tpc_stats, j, buf, len: &len);
1612	break;
1613	default:
1614	len += scnprintf(buf: buf + len, size: buf_len - len,
1615	fmt: "Invalid Type\n");
1616	break;
1617	}
1618	}
1619
1620	unlock:
1621	spin_unlock_bh(lock: &ar->data_lock);
1622
1623	if (len >= buf_len)
1624	buf[len - 1] = 0;
1625	else
1626	buf[len] = 0;
1627	}
1628
1629	static int ath10k_tpc_stats_open(struct inode *inode, struct file *file)
1630	{
1631	struct ath10k *ar = inode->i_private;
1632	void *buf = NULL;
1633	int ret;
1634
1635	mutex_lock(&ar->conf_mutex);
1636
1637	if (ar->state != ATH10K_STATE_ON) {
1638	ret = -ENETDOWN;
1639	goto err_unlock;
1640	}
1641
1642	buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
1643	if (!buf) {
1644	ret = -ENOMEM;
1645	goto err_unlock;
1646	}
1647
1648	ret = ath10k_debug_tpc_stats_request(ar);
1649	if (ret) {
1650	ath10k_warn(ar, "failed to request tpc config stats: %d\n",
1651	ret);
1652	goto err_free;
1653	}
1654
1655	ath10k_tpc_stats_fill(ar, tpc_stats: ar->debug.tpc_stats, buf);
1656	file->private_data = buf;
1657
1658	mutex_unlock(lock: &ar->conf_mutex);
1659	return 0;
1660
1661	err_free:
1662	vfree(addr: buf);
1663
1664	err_unlock:
1665	mutex_unlock(lock: &ar->conf_mutex);
1666	return ret;
1667	}
1668
1669	static int ath10k_tpc_stats_release(struct inode *inode, struct file *file)
1670	{
1671	vfree(addr: file->private_data);
1672
1673	return 0;
1674	}
1675
1676	static ssize_t ath10k_tpc_stats_read(struct file *file, char __user *user_buf,
1677	size_t count, loff_t *ppos)
1678	{
1679	const char *buf = file->private_data;
1680	size_t len = strlen(buf);
1681
1682	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
1683	}
1684
1685	static const struct file_operations fops_tpc_stats = {
1686	.open = ath10k_tpc_stats_open,
1687	.release = ath10k_tpc_stats_release,
1688	.read = ath10k_tpc_stats_read,
1689	.owner = THIS_MODULE,
1690	.llseek = default_llseek,
1691	};
1692
1693	int ath10k_debug_start(struct ath10k *ar)
1694	{
1695	int ret;
1696
1697	lockdep_assert_held(&ar->conf_mutex);
1698
1699	ret = ath10k_debug_htt_stats_req(ar);
1700	if (ret)
1701	/* continue normally anyway, this isn't serious */
1702	ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1703	ret);
1704
1705	if (ar->debug.fw_dbglog_mask) {
1706	ret = ath10k_wmi_dbglog_cfg(ar, module_enable: ar->debug.fw_dbglog_mask,
1707	log_level: ATH10K_DBGLOG_LEVEL_WARN);
1708	if (ret)
1709	/* not serious */
1710	ath10k_warn(ar, "failed to enable dbglog during start: %d",
1711	ret);
1712	}
1713
1714	if (ar->pktlog_filter) {
1715	ret = ath10k_wmi_pdev_pktlog_enable(ar,
1716	filter: ar->pktlog_filter);
1717	if (ret)
1718	/* not serious */
1719	ath10k_warn(ar,
1720	"failed to enable pktlog filter %x: %d\n",
1721	ar->pktlog_filter, ret);
1722	} else {
1723	ret = ath10k_wmi_pdev_pktlog_disable(ar);
1724	if (ret)
1725	/* not serious */
1726	ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1727	}
1728
1729	if (ar->debug.nf_cal_period &&
1730	!test_bit(ATH10K_FW_FEATURE_NON_BMI,
1731	ar->normal_mode_fw.fw_file.fw_features)) {
1732	ret = ath10k_wmi_pdev_set_param(ar,
1733	id: ar->wmi.pdev_param->cal_period,
1734	value: ar->debug.nf_cal_period);
1735	if (ret)
1736	/* not serious */
1737	ath10k_warn(ar, "cal period cfg failed from debug start: %d\n",
1738	ret);
1739	}
1740
1741	return ret;
1742	}
1743
1744	void ath10k_debug_stop(struct ath10k *ar)
1745	{
1746	lockdep_assert_held(&ar->conf_mutex);
1747
1748	if (!test_bit(ATH10K_FW_FEATURE_NON_BMI,
1749	ar->normal_mode_fw.fw_file.fw_features))
1750	ath10k_debug_cal_data_fetch(ar);
1751
1752	/* Must not use _sync to avoid deadlock, we do that in
1753	* ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1754	* warning from del_timer().
1755	*/
1756	if (ar->debug.htt_stats_mask != 0)
1757	cancel_delayed_work(dwork: &ar->debug.htt_stats_dwork);
1758
1759	ath10k_wmi_pdev_pktlog_disable(ar);
1760	}
1761
1762	static ssize_t ath10k_write_simulate_radar(struct file *file,
1763	const char __user *user_buf,
1764	size_t count, loff_t *ppos)
1765	{
1766	struct ath10k *ar = file->private_data;
1767	struct ath10k_vif *arvif;
1768
1769	/* Just check for the first vif alone, as all the vifs will be
1770	* sharing the same channel and if the channel is disabled, all the
1771	* vifs will share the same 'is_started' state.
1772	*/
1773	arvif = list_first_entry(&ar->arvifs, typeof(*arvif), list);
1774	if (!arvif->is_started)
1775	return -EINVAL;
1776
1777	ieee80211_radar_detected(hw: ar->hw);
1778
1779	return count;
1780	}
1781
1782	static const struct file_operations fops_simulate_radar = {
1783	.write = ath10k_write_simulate_radar,
1784	.open = simple_open,
1785	.owner = THIS_MODULE,
1786	.llseek = default_llseek,
1787	};
1788
1789	#define ATH10K_DFS_STAT(s, p) (\
1790	len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1791	ar->debug.dfs_stats.p))
1792
1793	#define ATH10K_DFS_POOL_STAT(s, p) (\
1794	len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1795	ar->debug.dfs_pool_stats.p))
1796
1797	static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1798	size_t count, loff_t *ppos)
1799	{
1800	int retval = 0, len = 0;
1801	const int size = 8000;
1802	struct ath10k *ar = file->private_data;
1803	char *buf;
1804
1805	buf = kzalloc(size, GFP_KERNEL);
1806	if (buf == NULL)
1807	return -ENOMEM;
1808
1809	if (!ar->dfs_detector) {
1810	len += scnprintf(buf: buf + len, size: size - len, fmt: "DFS not enabled\n");
1811	goto exit;
1812	}
1813
1814	ar->debug.dfs_pool_stats =
1815	ar->dfs_detector->get_stats(ar->dfs_detector);
1816
1817	len += scnprintf(buf: buf + len, size: size - len, fmt: "Pulse detector statistics:\n");
1818
1819	ATH10K_DFS_STAT("reported phy errors", phy_errors);
1820	ATH10K_DFS_STAT("pulse events reported", pulses_total);
1821	ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1822	ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1823	ATH10K_DFS_STAT("Radars detected", radar_detected);
1824
1825	len += scnprintf(buf: buf + len, size: size - len, fmt: "Global Pool statistics:\n");
1826	ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1827	ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1828	ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1829	ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1830	ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1831	ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1832	ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1833
1834	exit:
1835	if (len > size)
1836	len = size;
1837
1838	retval = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
1839	kfree(objp: buf);
1840
1841	return retval;
1842	}
1843
1844	static const struct file_operations fops_dfs_stats = {
1845	.read = ath10k_read_dfs_stats,
1846	.open = simple_open,
1847	.owner = THIS_MODULE,
1848	.llseek = default_llseek,
1849	};
1850
1851	static ssize_t ath10k_write_pktlog_filter(struct file *file,
1852	const char __user *ubuf,
1853	size_t count, loff_t *ppos)
1854	{
1855	struct ath10k *ar = file->private_data;
1856	u32 filter;
1857	int ret;
1858
1859	if (kstrtouint_from_user(s: ubuf, count, base: 0, res: &filter))
1860	return -EINVAL;
1861
1862	mutex_lock(&ar->conf_mutex);
1863
1864	if (ar->state != ATH10K_STATE_ON) {
1865	ar->pktlog_filter = filter;
1866	ret = count;
1867	goto out;
1868	}
1869
1870	if (filter == ar->pktlog_filter) {
1871	ret = count;
1872	goto out;
1873	}
1874
1875	if (filter) {
1876	ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
1877	if (ret) {
1878	ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
1879	ar->pktlog_filter, ret);
1880	goto out;
1881	}
1882	} else {
1883	ret = ath10k_wmi_pdev_pktlog_disable(ar);
1884	if (ret) {
1885	ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1886	goto out;
1887	}
1888	}
1889
1890	ar->pktlog_filter = filter;
1891	ret = count;
1892
1893	out:
1894	mutex_unlock(lock: &ar->conf_mutex);
1895	return ret;
1896	}
1897
1898	static ssize_t ath10k_read_pktlog_filter(struct file *file, char __user *ubuf,
1899	size_t count, loff_t *ppos)
1900	{
1901	char buf[32];
1902	struct ath10k *ar = file->private_data;
1903	int len = 0;
1904
1905	mutex_lock(&ar->conf_mutex);
1906	len = scnprintf(buf, size: sizeof(buf) - len, fmt: "%08x\n",
1907	ar->pktlog_filter);
1908	mutex_unlock(lock: &ar->conf_mutex);
1909
1910	return simple_read_from_buffer(to: ubuf, count, ppos, from: buf, available: len);
1911	}
1912
1913	static const struct file_operations fops_pktlog_filter = {
1914	.read = ath10k_read_pktlog_filter,
1915	.write = ath10k_write_pktlog_filter,
1916	.open = simple_open
1917	};
1918
1919	static ssize_t ath10k_write_quiet_period(struct file *file,
1920	const char __user *ubuf,
1921	size_t count, loff_t *ppos)
1922	{
1923	struct ath10k *ar = file->private_data;
1924	u32 period;
1925
1926	if (kstrtouint_from_user(s: ubuf, count, base: 0, res: &period))
1927	return -EINVAL;
1928
1929	if (period < ATH10K_QUIET_PERIOD_MIN) {
1930	ath10k_warn(ar, "Quiet period %u can not be lesser than 25ms\n",
1931	period);
1932	return -EINVAL;
1933	}
1934	mutex_lock(&ar->conf_mutex);
1935	ar->thermal.quiet_period = period;
1936	ath10k_thermal_set_throttling(ar);
1937	mutex_unlock(lock: &ar->conf_mutex);
1938
1939	return count;
1940	}
1941
1942	static ssize_t ath10k_read_quiet_period(struct file *file, char __user *ubuf,
1943	size_t count, loff_t *ppos)
1944	{
1945	char buf[32];
1946	struct ath10k *ar = file->private_data;
1947	int len = 0;
1948
1949	mutex_lock(&ar->conf_mutex);
1950	len = scnprintf(buf, size: sizeof(buf) - len, fmt: "%d\n",
1951	ar->thermal.quiet_period);
1952	mutex_unlock(lock: &ar->conf_mutex);
1953
1954	return simple_read_from_buffer(to: ubuf, count, ppos, from: buf, available: len);
1955	}
1956
1957	static const struct file_operations fops_quiet_period = {
1958	.read = ath10k_read_quiet_period,
1959	.write = ath10k_write_quiet_period,
1960	.open = simple_open
1961	};
1962
1963	static ssize_t ath10k_write_btcoex(struct file *file,
1964	const char __user *ubuf,
1965	size_t count, loff_t *ppos)
1966	{
1967	struct ath10k *ar = file->private_data;
1968	ssize_t ret;
1969	bool val;
1970	u32 pdev_param;
1971
1972	ret = kstrtobool_from_user(s: ubuf, count, res: &val);
1973	if (ret)
1974	return ret;
1975
1976	if (!ar->coex_support)
1977	return -EOPNOTSUPP;
1978
1979	mutex_lock(&ar->conf_mutex);
1980
1981	if (ar->state != ATH10K_STATE_ON &&
1982	ar->state != ATH10K_STATE_RESTARTED) {
1983	ret = -ENETDOWN;
1984	goto exit;
1985	}
1986
1987	if (!(test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags) ^ val)) {
1988	ret = count;
1989	goto exit;
1990	}
1991
1992	pdev_param = ar->wmi.pdev_param->enable_btcoex;
1993	if (test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
1994	ar->running_fw->fw_file.fw_features)) {
1995	ret = ath10k_wmi_pdev_set_param(ar, id: pdev_param, value: val);
1996	if (ret) {
1997	ath10k_warn(ar, "failed to enable btcoex: %zd\n", ret);
1998	ret = count;
1999	goto exit;
2000	}
2001	} else {
2002	ath10k_info(ar, "restarting firmware due to btcoex change");
2003	ath10k_core_start_recovery(ar);
2004	}
2005
2006	if (val)
2007	set_bit(nr: ATH10K_FLAG_BTCOEX, addr: &ar->dev_flags);
2008	else
2009	clear_bit(nr: ATH10K_FLAG_BTCOEX, addr: &ar->dev_flags);
2010
2011	ret = count;
2012
2013	exit:
2014	mutex_unlock(lock: &ar->conf_mutex);
2015
2016	return ret;
2017	}
2018
2019	static ssize_t ath10k_read_btcoex(struct file *file, char __user *ubuf,
2020	size_t count, loff_t *ppos)
2021	{
2022	char buf[32];
2023	struct ath10k *ar = file->private_data;
2024	int len = 0;
2025
2026	mutex_lock(&ar->conf_mutex);
2027	len = scnprintf(buf, size: sizeof(buf) - len, fmt: "%d\n",
2028	test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags));
2029	mutex_unlock(lock: &ar->conf_mutex);
2030
2031	return simple_read_from_buffer(to: ubuf, count, ppos, from: buf, available: len);
2032	}
2033
2034	static const struct file_operations fops_btcoex = {
2035	.read = ath10k_read_btcoex,
2036	.write = ath10k_write_btcoex,
2037	.open = simple_open
2038	};
2039
2040	static ssize_t ath10k_write_enable_extd_tx_stats(struct file *file,
2041	const char __user *ubuf,
2042	size_t count, loff_t *ppos)
2043	{
2044	struct ath10k *ar = file->private_data;
2045	u32 filter;
2046	int ret;
2047
2048	if (kstrtouint_from_user(s: ubuf, count, base: 0, res: &filter))
2049	return -EINVAL;
2050
2051	mutex_lock(&ar->conf_mutex);
2052
2053	if (ar->state != ATH10K_STATE_ON) {
2054	ar->debug.enable_extd_tx_stats = filter;
2055	ret = count;
2056	goto out;
2057	}
2058
2059	if (filter == ar->debug.enable_extd_tx_stats) {
2060	ret = count;
2061	goto out;
2062	}
2063
2064	ar->debug.enable_extd_tx_stats = filter;
2065	ret = count;
2066
2067	out:
2068	mutex_unlock(lock: &ar->conf_mutex);
2069	return ret;
2070	}
2071
2072	static ssize_t ath10k_read_enable_extd_tx_stats(struct file *file,
2073	char __user *ubuf,
2074	size_t count, loff_t *ppos)
2075
2076	{
2077	char buf[32];
2078	struct ath10k *ar = file->private_data;
2079	int len = 0;
2080
2081	mutex_lock(&ar->conf_mutex);
2082	len = scnprintf(buf, size: sizeof(buf) - len, fmt: "%08x\n",
2083	ar->debug.enable_extd_tx_stats);
2084	mutex_unlock(lock: &ar->conf_mutex);
2085
2086	return simple_read_from_buffer(to: ubuf, count, ppos, from: buf, available: len);
2087	}
2088
2089	static const struct file_operations fops_enable_extd_tx_stats = {
2090	.read = ath10k_read_enable_extd_tx_stats,
2091	.write = ath10k_write_enable_extd_tx_stats,
2092	.open = simple_open
2093	};
2094
2095	static ssize_t ath10k_write_peer_stats(struct file *file,
2096	const char __user *ubuf,
2097	size_t count, loff_t *ppos)
2098	{
2099	struct ath10k *ar = file->private_data;
2100	ssize_t ret;
2101	bool val;
2102
2103	ret = kstrtobool_from_user(s: ubuf, count, res: &val);
2104	if (ret)
2105	return ret;
2106
2107	mutex_lock(&ar->conf_mutex);
2108
2109	if (ar->state != ATH10K_STATE_ON &&
2110	ar->state != ATH10K_STATE_RESTARTED) {
2111	ret = -ENETDOWN;
2112	goto exit;
2113	}
2114
2115	if (!(test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) ^ val)) {
2116	ret = count;
2117	goto exit;
2118	}
2119
2120	if (val)
2121	set_bit(nr: ATH10K_FLAG_PEER_STATS, addr: &ar->dev_flags);
2122	else
2123	clear_bit(nr: ATH10K_FLAG_PEER_STATS, addr: &ar->dev_flags);
2124
2125	ath10k_info(ar, "restarting firmware due to Peer stats change");
2126
2127	ath10k_core_start_recovery(ar);
2128	ret = count;
2129
2130	exit:
2131	mutex_unlock(lock: &ar->conf_mutex);
2132	return ret;
2133	}
2134
2135	static ssize_t ath10k_read_peer_stats(struct file *file, char __user *ubuf,
2136	size_t count, loff_t *ppos)
2137
2138	{
2139	char buf[32];
2140	struct ath10k *ar = file->private_data;
2141	int len = 0;
2142
2143	mutex_lock(&ar->conf_mutex);
2144	len = scnprintf(buf, size: sizeof(buf) - len, fmt: "%d\n",
2145	test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags));
2146	mutex_unlock(lock: &ar->conf_mutex);
2147
2148	return simple_read_from_buffer(to: ubuf, count, ppos, from: buf, available: len);
2149	}
2150
2151	static const struct file_operations fops_peer_stats = {
2152	.read = ath10k_read_peer_stats,
2153	.write = ath10k_write_peer_stats,
2154	.open = simple_open
2155	};
2156
2157	static ssize_t ath10k_debug_fw_checksums_read(struct file *file,
2158	char __user *user_buf,
2159	size_t count, loff_t *ppos)
2160	{
2161	struct ath10k *ar = file->private_data;
2162	size_t len = 0, buf_len = 4096;
2163	ssize_t ret_cnt;
2164	char *buf;
2165
2166	buf = kzalloc(size: buf_len, GFP_KERNEL);
2167	if (!buf)
2168	return -ENOMEM;
2169
2170	mutex_lock(&ar->conf_mutex);
2171
2172	len += scnprintf(buf: buf + len, size: buf_len - len,
2173	fmt: "firmware-N.bin\t\t%08x\n",
2174	crc32_le(crc: 0, p: ar->normal_mode_fw.fw_file.firmware->data,
2175	len: ar->normal_mode_fw.fw_file.firmware->size));
2176	len += scnprintf(buf: buf + len, size: buf_len - len,
2177	fmt: "athwlan\t\t\t%08x\n",
2178	crc32_le(crc: 0, p: ar->normal_mode_fw.fw_file.firmware_data,
2179	len: ar->normal_mode_fw.fw_file.firmware_len));
2180	len += scnprintf(buf: buf + len, size: buf_len - len,
2181	fmt: "otp\t\t\t%08x\n",
2182	crc32_le(crc: 0, p: ar->normal_mode_fw.fw_file.otp_data,
2183	len: ar->normal_mode_fw.fw_file.otp_len));
2184	len += scnprintf(buf: buf + len, size: buf_len - len,
2185	fmt: "codeswap\t\t%08x\n",
2186	crc32_le(crc: 0, p: ar->normal_mode_fw.fw_file.codeswap_data,
2187	len: ar->normal_mode_fw.fw_file.codeswap_len));
2188	len += scnprintf(buf: buf + len, size: buf_len - len,
2189	fmt: "board-N.bin\t\t%08x\n",
2190	crc32_le(crc: 0, p: ar->normal_mode_fw.board->data,
2191	len: ar->normal_mode_fw.board->size));
2192	len += scnprintf(buf: buf + len, size: buf_len - len,
2193	fmt: "board\t\t\t%08x\n",
2194	crc32_le(crc: 0, p: ar->normal_mode_fw.board_data,
2195	len: ar->normal_mode_fw.board_len));
2196
2197	ret_cnt = simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
2198
2199	mutex_unlock(lock: &ar->conf_mutex);
2200
2201	kfree(objp: buf);
2202	return ret_cnt;
2203	}
2204
2205	static const struct file_operations fops_fw_checksums = {
2206	.read = ath10k_debug_fw_checksums_read,
2207	.open = simple_open,
2208	.owner = THIS_MODULE,
2209	.llseek = default_llseek,
2210	};
2211
2212	static ssize_t ath10k_sta_tid_stats_mask_read(struct file *file,
2213	char __user *user_buf,
2214	size_t count, loff_t *ppos)
2215	{
2216	struct ath10k *ar = file->private_data;
2217	char buf[32];
2218	size_t len;
2219
2220	len = scnprintf(buf, size: sizeof(buf), fmt: "0x%08x\n", ar->sta_tid_stats_mask);
2221	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
2222	}
2223
2224	static ssize_t ath10k_sta_tid_stats_mask_write(struct file *file,
2225	const char __user *user_buf,
2226	size_t count, loff_t *ppos)
2227	{
2228	struct ath10k *ar = file->private_data;
2229	ssize_t ret;
2230	u32 mask;
2231
2232	ret = kstrtoint_from_user(s: user_buf, count, base: 0, res: &mask);
2233	if (ret)
2234	return ret;
2235
2236	ar->sta_tid_stats_mask = mask;
2237
2238	return count;
2239	}
2240
2241	static const struct file_operations fops_sta_tid_stats_mask = {
2242	.read = ath10k_sta_tid_stats_mask_read,
2243	.write = ath10k_sta_tid_stats_mask_write,
2244	.open = simple_open,
2245	.owner = THIS_MODULE,
2246	.llseek = default_llseek,
2247	};
2248
2249	static int ath10k_debug_tpc_stats_final_request(struct ath10k *ar)
2250	{
2251	int ret;
2252	unsigned long time_left;
2253
2254	lockdep_assert_held(&ar->conf_mutex);
2255
2256	reinit_completion(x: &ar->debug.tpc_complete);
2257
2258	ret = ath10k_wmi_pdev_get_tpc_table_cmdid(ar, WMI_TPC_CONFIG_PARAM);
2259	if (ret) {
2260	ath10k_warn(ar, "failed to request tpc table cmdid: %d\n", ret);
2261	return ret;
2262	}
2263
2264	time_left = wait_for_completion_timeout(x: &ar->debug.tpc_complete,
2265	timeout: 1 * HZ);
2266	if (time_left == 0)
2267	return -ETIMEDOUT;
2268
2269	return 0;
2270	}
2271
2272	static int ath10k_tpc_stats_final_open(struct inode *inode, struct file *file)
2273	{
2274	struct ath10k *ar = inode->i_private;
2275	void *buf;
2276	int ret;
2277
2278	mutex_lock(&ar->conf_mutex);
2279
2280	if (ar->state != ATH10K_STATE_ON) {
2281	ret = -ENETDOWN;
2282	goto err_unlock;
2283	}
2284
2285	buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
2286	if (!buf) {
2287	ret = -ENOMEM;
2288	goto err_unlock;
2289	}
2290
2291	ret = ath10k_debug_tpc_stats_final_request(ar);
2292	if (ret) {
2293	ath10k_warn(ar, "failed to request tpc stats final: %d\n",
2294	ret);
2295	goto err_free;
2296	}
2297
2298	ath10k_tpc_stats_fill(ar, tpc_stats: ar->debug.tpc_stats, buf);
2299	file->private_data = buf;
2300
2301	mutex_unlock(lock: &ar->conf_mutex);
2302	return 0;
2303
2304	err_free:
2305	vfree(addr: buf);
2306
2307	err_unlock:
2308	mutex_unlock(lock: &ar->conf_mutex);
2309	return ret;
2310	}
2311
2312	static int ath10k_tpc_stats_final_release(struct inode *inode,
2313	struct file *file)
2314	{
2315	vfree(addr: file->private_data);
2316
2317	return 0;
2318	}
2319
2320	static ssize_t ath10k_tpc_stats_final_read(struct file *file,
2321	char __user *user_buf,
2322	size_t count, loff_t *ppos)
2323	{
2324	const char *buf = file->private_data;
2325	unsigned int len = strlen(buf);
2326
2327	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
2328	}
2329
2330	static const struct file_operations fops_tpc_stats_final = {
2331	.open = ath10k_tpc_stats_final_open,
2332	.release = ath10k_tpc_stats_final_release,
2333	.read = ath10k_tpc_stats_final_read,
2334	.owner = THIS_MODULE,
2335	.llseek = default_llseek,
2336	};
2337
2338	static ssize_t ath10k_write_warm_hw_reset(struct file *file,
2339	const char __user *user_buf,
2340	size_t count, loff_t *ppos)
2341	{
2342	struct ath10k *ar = file->private_data;
2343	int ret;
2344	bool val;
2345
2346	if (kstrtobool_from_user(s: user_buf, count, res: &val))
2347	return -EFAULT;
2348
2349	if (!val)
2350	return -EINVAL;
2351
2352	mutex_lock(&ar->conf_mutex);
2353
2354	if (ar->state != ATH10K_STATE_ON) {
2355	ret = -ENETDOWN;
2356	goto exit;
2357	}
2358
2359	ret = ath10k_wmi_pdev_set_param(ar, id: ar->wmi.pdev_param->pdev_reset,
2360	value: WMI_RST_MODE_WARM_RESET);
2361
2362	if (ret) {
2363	ath10k_warn(ar, "failed to enable warm hw reset: %d\n", ret);
2364	goto exit;
2365	}
2366
2367	ret = count;
2368
2369	exit:
2370	mutex_unlock(lock: &ar->conf_mutex);
2371	return ret;
2372	}
2373
2374	static const struct file_operations fops_warm_hw_reset = {
2375	.write = ath10k_write_warm_hw_reset,
2376	.open = simple_open,
2377	.owner = THIS_MODULE,
2378	.llseek = default_llseek,
2379	};
2380
2381	static void ath10k_peer_ps_state_disable(void *data,
2382	struct ieee80211_sta *sta)
2383	{
2384	struct ath10k *ar = data;
2385	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
2386
2387	spin_lock_bh(lock: &ar->data_lock);
2388	arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
2389	spin_unlock_bh(lock: &ar->data_lock);
2390	}
2391
2392	static ssize_t ath10k_write_ps_state_enable(struct file *file,
2393	const char __user *user_buf,
2394	size_t count, loff_t *ppos)
2395	{
2396	struct ath10k *ar = file->private_data;
2397	int ret;
2398	u32 param;
2399	u8 ps_state_enable;
2400
2401	if (kstrtou8_from_user(s: user_buf, count, base: 0, res: &ps_state_enable))
2402	return -EINVAL;
2403
2404	if (ps_state_enable > 1)
2405	return -EINVAL;
2406
2407	mutex_lock(&ar->conf_mutex);
2408
2409	if (ar->ps_state_enable == ps_state_enable) {
2410	ret = count;
2411	goto exit;
2412	}
2413
2414	param = ar->wmi.pdev_param->peer_sta_ps_statechg_enable;
2415	ret = ath10k_wmi_pdev_set_param(ar, id: param, value: ps_state_enable);
2416	if (ret) {
2417	ath10k_warn(ar, "failed to enable ps_state_enable: %d\n",
2418	ret);
2419	goto exit;
2420	}
2421	ar->ps_state_enable = ps_state_enable;
2422
2423	if (!ar->ps_state_enable)
2424	ieee80211_iterate_stations_atomic(hw: ar->hw,
2425	iterator: ath10k_peer_ps_state_disable,
2426	data: ar);
2427
2428	ret = count;
2429
2430	exit:
2431	mutex_unlock(lock: &ar->conf_mutex);
2432
2433	return ret;
2434	}
2435
2436	static ssize_t ath10k_read_ps_state_enable(struct file *file,
2437	char __user *user_buf,
2438	size_t count, loff_t *ppos)
2439	{
2440	struct ath10k *ar = file->private_data;
2441	int len = 0;
2442	char buf[32];
2443
2444	mutex_lock(&ar->conf_mutex);
2445	len = scnprintf(buf, size: sizeof(buf) - len, fmt: "%d\n",
2446	ar->ps_state_enable);
2447	mutex_unlock(lock: &ar->conf_mutex);
2448
2449	return simple_read_from_buffer(to: user_buf, count, ppos, from: buf, available: len);
2450	}
2451
2452	static const struct file_operations fops_ps_state_enable = {
2453	.read = ath10k_read_ps_state_enable,
2454	.write = ath10k_write_ps_state_enable,
2455	.open = simple_open,
2456	.owner = THIS_MODULE,
2457	.llseek = default_llseek,
2458	};
2459
2460	static ssize_t ath10k_write_reset_htt_stats(struct file *file,
2461	const char __user *user_buf,
2462	size_t count, loff_t *ppos)
2463	{
2464	struct ath10k *ar = file->private_data;
2465	unsigned long reset;
2466	int ret;
2467
2468	ret = kstrtoul_from_user(s: user_buf, count, base: 0, res: &reset);
2469	if (ret)
2470	return ret;
2471
2472	if (reset == 0 || reset > 0x1ffff)
2473	return -EINVAL;
2474
2475	mutex_lock(&ar->conf_mutex);
2476
2477	ar->debug.reset_htt_stats = reset;
2478
2479	ret = ath10k_debug_htt_stats_req(ar);
2480	if (ret)
2481	goto out;
2482
2483	ar->debug.reset_htt_stats = 0;
2484	ret = count;
2485
2486	out:
2487	mutex_unlock(lock: &ar->conf_mutex);
2488	return ret;
2489	}
2490
2491	static const struct file_operations fops_reset_htt_stats = {
2492	.write = ath10k_write_reset_htt_stats,
2493	.owner = THIS_MODULE,
2494	.open = simple_open,
2495	.llseek = default_llseek,
2496	};
2497
2498	int ath10k_debug_create(struct ath10k *ar)
2499	{
2500	ar->debug.cal_data = vzalloc(ATH10K_DEBUG_CAL_DATA_LEN);
2501	if (!ar->debug.cal_data)
2502	return -ENOMEM;
2503
2504	INIT_LIST_HEAD(list: &ar->debug.fw_stats.pdevs);
2505	INIT_LIST_HEAD(list: &ar->debug.fw_stats.vdevs);
2506	INIT_LIST_HEAD(list: &ar->debug.fw_stats.peers);
2507	INIT_LIST_HEAD(list: &ar->debug.fw_stats.peers_extd);
2508
2509	return 0;
2510	}
2511
2512	void ath10k_debug_destroy(struct ath10k *ar)
2513	{
2514	vfree(addr: ar->debug.cal_data);
2515	ar->debug.cal_data = NULL;
2516
2517	ath10k_debug_fw_stats_reset(ar);
2518
2519	kfree(objp: ar->debug.tpc_stats);
2520	kfree(objp: ar->debug.tpc_stats_final);
2521	}
2522
2523	int ath10k_debug_register(struct ath10k *ar)
2524	{
2525	ar->debug.debugfs_phy = debugfs_create_dir(name: "ath10k",
2526	parent: ar->hw->wiphy->debugfsdir);
2527	if (IS_ERR_OR_NULL(ptr: ar->debug.debugfs_phy)) {
2528	if (IS_ERR(ptr: ar->debug.debugfs_phy))
2529	return PTR_ERR(ptr: ar->debug.debugfs_phy);
2530
2531	return -ENOMEM;
2532	}
2533
2534	INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
2535	ath10k_debug_htt_stats_dwork);
2536
2537	init_completion(x: &ar->debug.tpc_complete);
2538	init_completion(x: &ar->debug.fw_stats_complete);
2539
2540	debugfs_create_file(name: "fw_stats", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2541	fops: &fops_fw_stats);
2542
2543	debugfs_create_file(name: "fw_reset_stats", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2544	fops: &fops_fw_reset_stats);
2545
2546	debugfs_create_file(name: "wmi_services", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2547	fops: &fops_wmi_services);
2548
2549	debugfs_create_file(name: "simulate_fw_crash", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2550	fops: &fops_simulate_fw_crash);
2551
2552	debugfs_create_file(name: "reg_addr", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2553	fops: &fops_reg_addr);
2554
2555	debugfs_create_file(name: "reg_value", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2556	fops: &fops_reg_value);
2557
2558	debugfs_create_file(name: "mem_value", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2559	fops: &fops_mem_value);
2560
2561	debugfs_create_file(name: "chip_id", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2562	fops: &fops_chip_id);
2563
2564	debugfs_create_file(name: "htt_stats_mask", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2565	fops: &fops_htt_stats_mask);
2566
2567	debugfs_create_file(name: "htt_max_amsdu_ampdu", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2568	fops: &fops_htt_max_amsdu_ampdu);
2569
2570	debugfs_create_file(name: "fw_dbglog", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2571	fops: &fops_fw_dbglog);
2572
2573	if (!test_bit(ATH10K_FW_FEATURE_NON_BMI,
2574	ar->normal_mode_fw.fw_file.fw_features)) {
2575	debugfs_create_file(name: "cal_data", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2576	fops: &fops_cal_data);
2577
2578	debugfs_create_file(name: "nf_cal_period", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2579	fops: &fops_nf_cal_period);
2580	}
2581
2582	debugfs_create_file(name: "ani_enable", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2583	fops: &fops_ani_enable);
2584
2585	if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
2586	debugfs_create_file(name: "dfs_simulate_radar", mode: 0200, parent: ar->debug.debugfs_phy,
2587	data: ar, fops: &fops_simulate_radar);
2588
2589	debugfs_create_bool(name: "dfs_block_radar_events", mode: 0200,
2590	parent: ar->debug.debugfs_phy,
2591	value: &ar->dfs_block_radar_events);
2592
2593	debugfs_create_file(name: "dfs_stats", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2594	fops: &fops_dfs_stats);
2595	}
2596
2597	debugfs_create_file(name: "pktlog_filter", mode: 0644, parent: ar->debug.debugfs_phy, data: ar,
2598	fops: &fops_pktlog_filter);
2599
2600	if (test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
2601	debugfs_create_file(name: "quiet_period", mode: 0644, parent: ar->debug.debugfs_phy, data: ar,
2602	fops: &fops_quiet_period);
2603
2604	debugfs_create_file(name: "tpc_stats", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2605	fops: &fops_tpc_stats);
2606
2607	if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
2608	debugfs_create_file(name: "btcoex", mode: 0644, parent: ar->debug.debugfs_phy, data: ar,
2609	fops: &fops_btcoex);
2610
2611	if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
2612	debugfs_create_file(name: "peer_stats", mode: 0644, parent: ar->debug.debugfs_phy, data: ar,
2613	fops: &fops_peer_stats);
2614
2615	debugfs_create_file(name: "enable_extd_tx_stats", mode: 0644,
2616	parent: ar->debug.debugfs_phy, data: ar,
2617	fops: &fops_enable_extd_tx_stats);
2618	}
2619
2620	debugfs_create_file(name: "fw_checksums", mode: 0400, parent: ar->debug.debugfs_phy, data: ar,
2621	fops: &fops_fw_checksums);
2622
2623	if (IS_ENABLED(CONFIG_MAC80211_DEBUGFS))
2624	debugfs_create_file(name: "sta_tid_stats_mask", mode: 0600,
2625	parent: ar->debug.debugfs_phy,
2626	data: ar, fops: &fops_sta_tid_stats_mask);
2627
2628	if (test_bit(WMI_SERVICE_TPC_STATS_FINAL, ar->wmi.svc_map))
2629	debugfs_create_file(name: "tpc_stats_final", mode: 0400,
2630	parent: ar->debug.debugfs_phy, data: ar,
2631	fops: &fops_tpc_stats_final);
2632
2633	if (test_bit(WMI_SERVICE_RESET_CHIP, ar->wmi.svc_map))
2634	debugfs_create_file(name: "warm_hw_reset", mode: 0600,
2635	parent: ar->debug.debugfs_phy, data: ar,
2636	fops: &fops_warm_hw_reset);
2637
2638	debugfs_create_file(name: "ps_state_enable", mode: 0600, parent: ar->debug.debugfs_phy, data: ar,
2639	fops: &fops_ps_state_enable);
2640
2641	debugfs_create_file(name: "reset_htt_stats", mode: 0200, parent: ar->debug.debugfs_phy, data: ar,
2642	fops: &fops_reset_htt_stats);
2643
2644	return 0;
2645	}
2646
2647	void ath10k_debug_unregister(struct ath10k *ar)
2648	{
2649	cancel_delayed_work_sync(dwork: &ar->debug.htt_stats_dwork);
2650	}
2651
2652	#endif /* CONFIG_ATH10K_DEBUGFS */
2653
2654	#ifdef CONFIG_ATH10K_DEBUG
2655	void __ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
2656	const char *fmt, ...)
2657	{
2658	struct va_format vaf;
2659	va_list args;
2660
2661	va_start(args, fmt);
2662
2663	vaf.fmt = fmt;
2664	vaf.va = &args;
2665
2666	if (ath10k_debug_mask & mask)
2667	dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
2668
2669	trace_ath10k_log_dbg(ar, level: mask, vaf: &vaf);
2670
2671	va_end(args);
2672	}
2673	EXPORT_SYMBOL(__ath10k_dbg);
2674
2675	void ath10k_dbg_dump(struct ath10k *ar,
2676	enum ath10k_debug_mask mask,
2677	const char *msg, const char *prefix,
2678	const void *buf, size_t len)
2679	{
2680	char linebuf[256];
2681	size_t linebuflen;
2682	const void *ptr;
2683
2684	if (ath10k_debug_mask & mask) {
2685	if (msg)
2686	__ath10k_dbg(ar, mask, "%s\n", msg);
2687
2688	for (ptr = buf; (ptr - buf) < len; ptr += 16) {
2689	linebuflen = 0;
2690	linebuflen += scnprintf(buf: linebuf + linebuflen,
2691	size: sizeof(linebuf) - linebuflen,
2692	fmt: "%s%08x: ",
2693	(prefix ? prefix : ""),
2694	(unsigned int)(ptr - buf));
2695	hex_dump_to_buffer(buf: ptr, len: len - (ptr - buf), rowsize: 16, groupsize: 1,
2696	linebuf: linebuf + linebuflen,
2697	linebuflen: sizeof(linebuf) - linebuflen, ascii: true);
2698	dev_printk(KERN_DEBUG, ar->dev, "%s\n", linebuf);
2699	}
2700	}
2701
2702	/* tracing code doesn't like null strings :/ */
2703	trace_ath10k_log_dbg_dump(ar, msg: msg ? msg : "", prefix: prefix ? prefix : "",
2704	buf, buf_len: len);
2705	}
2706	EXPORT_SYMBOL(ath10k_dbg_dump);
2707
2708	#endif /* CONFIG_ATH10K_DEBUG */
2709