?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / net / wireless / ath / ath10k / debug.c
blobfd052f6ed01900643b93053d285343755a8da1a7
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_requed",
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_requed;
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 */
Linux with added FPC-III support