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