projects/linux·blob master · refs

2709 lines · 63.9 KiB

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