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