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