?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/rockchip: Don't change hdmi reference clock rate
[drm/drm-misc.git] / drivers / net / wireless / ath / ath11k / debugfs.c
blob57281a135dd7fa6b8610636f47873c8bba21053c
1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (c) 2018-2020 The Linux Foundation. All rights reserved.
4 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
5 */
6
7 #include <linux/vmalloc.h>
8
9 #include "debugfs.h"
10
11 #include "core.h"
12 #include "debug.h"
13 #include "wmi.h"
14 #include "hal_rx.h"
15 #include "dp_tx.h"
16 #include "debugfs_htt_stats.h"
17 #include "peer.h"
18 #include "hif.h"
19
20 static const char *htt_bp_umac_ring[HTT_SW_UMAC_RING_IDX_MAX] = {
21 "REO2SW1_RING",
22 "REO2SW2_RING",
23 "REO2SW3_RING",
24 "REO2SW4_RING",
25 "WBM2REO_LINK_RING",
26 "REO2TCL_RING",
27 "REO2FW_RING",
28 "RELEASE_RING",
29 "PPE_RELEASE_RING",
30 "TCL2TQM_RING",
31 "TQM_RELEASE_RING",
32 "REO_RELEASE_RING",
33 "WBM2SW0_RELEASE_RING",
34 "WBM2SW1_RELEASE_RING",
35 "WBM2SW2_RELEASE_RING",
36 "WBM2SW3_RELEASE_RING",
37 "REO_CMD_RING",
38 "REO_STATUS_RING",
39 };
40
41 static const char *htt_bp_lmac_ring[HTT_SW_LMAC_RING_IDX_MAX] = {
42 "FW2RXDMA_BUF_RING",
43 "FW2RXDMA_STATUS_RING",
44 "FW2RXDMA_LINK_RING",
45 "SW2RXDMA_BUF_RING",
46 "WBM2RXDMA_LINK_RING",
47 "RXDMA2FW_RING",
48 "RXDMA2SW_RING",
49 "RXDMA2RELEASE_RING",
50 "RXDMA2REO_RING",
51 "MONITOR_STATUS_RING",
52 "MONITOR_BUF_RING",
53 "MONITOR_DESC_RING",
54 "MONITOR_DEST_RING",
55 };
56
57 void ath11k_debugfs_add_dbring_entry(struct ath11k *ar,
58 enum wmi_direct_buffer_module id,
59 enum ath11k_dbg_dbr_event event,
60 struct hal_srng *srng)
61 {
62 struct ath11k_debug_dbr *dbr_debug;
63 struct ath11k_dbg_dbr_data *dbr_data;
64 struct ath11k_dbg_dbr_entry *entry;
65
66 if (id >= WMI_DIRECT_BUF_MAX || event >= ATH11K_DBG_DBR_EVENT_MAX)
67 return;
68
69 dbr_debug = ar->debug.dbr_debug[id];
70 if (!dbr_debug)
71 return;
72
73 if (!dbr_debug->dbr_debug_enabled)
74 return;
75
76 dbr_data = &dbr_debug->dbr_dbg_data;
77
78 spin_lock_bh(&dbr_data->lock);
79
80 if (dbr_data->entries) {
81 entry = &dbr_data->entries[dbr_data->dbr_debug_idx];
82 entry->hp = srng->u.src_ring.hp;
83 entry->tp = *srng->u.src_ring.tp_addr;
84 entry->timestamp = jiffies;
85 entry->event = event;
86
87 dbr_data->dbr_debug_idx++;
88 if (dbr_data->dbr_debug_idx ==
89 dbr_data->num_ring_debug_entries)
90 dbr_data->dbr_debug_idx = 0;
91 }
92
93 spin_unlock_bh(&dbr_data->lock);
94 }
95
96 static void ath11k_debugfs_fw_stats_reset(struct ath11k *ar)
97 {
98 spin_lock_bh(&ar->data_lock);
99 ar->fw_stats_done = false;
100 ath11k_fw_stats_pdevs_free(&ar->fw_stats.pdevs);
101 ath11k_fw_stats_vdevs_free(&ar->fw_stats.vdevs);
102 spin_unlock_bh(&ar->data_lock);
103 }
104
105 void ath11k_debugfs_fw_stats_process(struct ath11k *ar, struct ath11k_fw_stats *stats)
106 {
107 struct ath11k_base *ab = ar->ab;
108 struct ath11k_pdev *pdev;
109 bool is_end;
110 static unsigned int num_vdev, num_bcn;
111 size_t total_vdevs_started = 0;
112 int i;
113
114 /* WMI_REQUEST_PDEV_STAT request has been already processed */
115
116 if (stats->stats_id == WMI_REQUEST_RSSI_PER_CHAIN_STAT) {
117 ar->fw_stats_done = true;
118 return;
119 }
120
121 if (stats->stats_id == WMI_REQUEST_VDEV_STAT) {
122 if (list_empty(&stats->vdevs)) {
123 ath11k_warn(ab, "empty vdev stats");
124 return;
125 }
126 /* FW sends all the active VDEV stats irrespective of PDEV,
127 * hence limit until the count of all VDEVs started
128 */
129 for (i = 0; i < ab->num_radios; i++) {
130 pdev = rcu_dereference(ab->pdevs_active[i]);
131 if (pdev && pdev->ar)
132 total_vdevs_started += ar->num_started_vdevs;
133 }
134
135 is_end = ((++num_vdev) == total_vdevs_started);
136
137 list_splice_tail_init(&stats->vdevs,
138 &ar->fw_stats.vdevs);
139
140 if (is_end) {
141 ar->fw_stats_done = true;
142 num_vdev = 0;
143 }
144 return;
145 }
146
147 if (stats->stats_id == WMI_REQUEST_BCN_STAT) {
148 if (list_empty(&stats->bcn)) {
149 ath11k_warn(ab, "empty bcn stats");
150 return;
151 }
152 /* Mark end until we reached the count of all started VDEVs
153 * within the PDEV
154 */
155 is_end = ((++num_bcn) == ar->num_started_vdevs);
156
157 list_splice_tail_init(&stats->bcn,
158 &ar->fw_stats.bcn);
159
160 if (is_end) {
161 ar->fw_stats_done = true;
162 num_bcn = 0;
163 }
164 }
165 }
166
167 static int ath11k_debugfs_fw_stats_request(struct ath11k *ar,
168 struct stats_request_params *req_param)
169 {
170 struct ath11k_base *ab = ar->ab;
171 unsigned long timeout, time_left;
172 int ret;
173
174 lockdep_assert_held(&ar->conf_mutex);
175
176 /* FW stats can get split when exceeding the stats data buffer limit.
177 * In that case, since there is no end marking for the back-to-back
178 * received 'update stats' event, we keep a 3 seconds timeout in case,
179 * fw_stats_done is not marked yet
180 */
181 timeout = jiffies + msecs_to_jiffies(3 * 1000);
182
183 ath11k_debugfs_fw_stats_reset(ar);
184
185 reinit_completion(&ar->fw_stats_complete);
186
187 ret = ath11k_wmi_send_stats_request_cmd(ar, req_param);
188
189 if (ret) {
190 ath11k_warn(ab, "could not request fw stats (%d)\n",
191 ret);
192 return ret;
193 }
194
195 time_left = wait_for_completion_timeout(&ar->fw_stats_complete, 1 * HZ);
196
197 if (!time_left)
198 return -ETIMEDOUT;
199
200 for (;;) {
201 if (time_after(jiffies, timeout))
202 break;
203
204 spin_lock_bh(&ar->data_lock);
205 if (ar->fw_stats_done) {
206 spin_unlock_bh(&ar->data_lock);
207 break;
208 }
209 spin_unlock_bh(&ar->data_lock);
210 }
211 return 0;
212 }
213
214 int ath11k_debugfs_get_fw_stats(struct ath11k *ar, u32 pdev_id,
215 u32 vdev_id, u32 stats_id)
216 {
217 struct ath11k_base *ab = ar->ab;
218 struct stats_request_params req_param;
219 int ret;
220
221 mutex_lock(&ar->conf_mutex);
222
223 if (ar->state != ATH11K_STATE_ON) {
224 ret = -ENETDOWN;
225 goto err_unlock;
226 }
227
228 req_param.pdev_id = pdev_id;
229 req_param.vdev_id = vdev_id;
230 req_param.stats_id = stats_id;
231
232 ret = ath11k_debugfs_fw_stats_request(ar, &req_param);
233 if (ret)
234 ath11k_warn(ab, "failed to request fw stats: %d\n", ret);
235
236 ath11k_dbg(ab, ATH11K_DBG_WMI,
237 "debug get fw stat pdev id %d vdev id %d stats id 0x%x\n",
238 pdev_id, vdev_id, stats_id);
239
240 err_unlock:
241 mutex_unlock(&ar->conf_mutex);
242
243 return ret;
244 }
245
246 static int ath11k_open_pdev_stats(struct inode *inode, struct file *file)
247 {
248 struct ath11k *ar = inode->i_private;
249 struct ath11k_base *ab = ar->ab;
250 struct stats_request_params req_param;
251 void *buf = NULL;
252 int ret;
253
254 mutex_lock(&ar->conf_mutex);
255
256 if (ar->state != ATH11K_STATE_ON) {
257 ret = -ENETDOWN;
258 goto err_unlock;
259 }
260
261 buf = vmalloc(ATH11K_FW_STATS_BUF_SIZE);
262 if (!buf) {
263 ret = -ENOMEM;
264 goto err_unlock;
265 }
266
267 req_param.pdev_id = ar->pdev->pdev_id;
268 req_param.vdev_id = 0;
269 req_param.stats_id = WMI_REQUEST_PDEV_STAT;
270
271 ret = ath11k_debugfs_fw_stats_request(ar, &req_param);
272 if (ret) {
273 ath11k_warn(ab, "failed to request fw pdev stats: %d\n", ret);
274 goto err_free;
275 }
276
277 ath11k_wmi_fw_stats_fill(ar, &ar->fw_stats, req_param.stats_id, buf);
278
279 file->private_data = buf;
280
281 mutex_unlock(&ar->conf_mutex);
282 return 0;
283
284 err_free:
285 vfree(buf);
286
287 err_unlock:
288 mutex_unlock(&ar->conf_mutex);
289 return ret;
290 }
291
292 static int ath11k_release_pdev_stats(struct inode *inode, struct file *file)
293 {
294 vfree(file->private_data);
295
296 return 0;
297 }
298
299 static ssize_t ath11k_read_pdev_stats(struct file *file,
300 char __user *user_buf,
301 size_t count, loff_t *ppos)
302 {
303 const char *buf = file->private_data;
304 size_t len = strlen(buf);
305
306 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
307 }
308
309 static const struct file_operations fops_pdev_stats = {
310 .open = ath11k_open_pdev_stats,
311 .release = ath11k_release_pdev_stats,
312 .read = ath11k_read_pdev_stats,
313 .owner = THIS_MODULE,
314 .llseek = default_llseek,
315 };
316
317 static int ath11k_open_vdev_stats(struct inode *inode, struct file *file)
318 {
319 struct ath11k *ar = inode->i_private;
320 struct stats_request_params req_param;
321 void *buf = NULL;
322 int ret;
323
324 mutex_lock(&ar->conf_mutex);
325
326 if (ar->state != ATH11K_STATE_ON) {
327 ret = -ENETDOWN;
328 goto err_unlock;
329 }
330
331 buf = vmalloc(ATH11K_FW_STATS_BUF_SIZE);
332 if (!buf) {
333 ret = -ENOMEM;
334 goto err_unlock;
335 }
336
337 req_param.pdev_id = ar->pdev->pdev_id;
338 /* VDEV stats is always sent for all active VDEVs from FW */
339 req_param.vdev_id = 0;
340 req_param.stats_id = WMI_REQUEST_VDEV_STAT;
341
342 ret = ath11k_debugfs_fw_stats_request(ar, &req_param);
343 if (ret) {
344 ath11k_warn(ar->ab, "failed to request fw vdev stats: %d\n", ret);
345 goto err_free;
346 }
347
348 ath11k_wmi_fw_stats_fill(ar, &ar->fw_stats, req_param.stats_id, buf);
349
350 file->private_data = buf;
351
352 mutex_unlock(&ar->conf_mutex);
353 return 0;
354
355 err_free:
356 vfree(buf);
357
358 err_unlock:
359 mutex_unlock(&ar->conf_mutex);
360 return ret;
361 }
362
363 static int ath11k_release_vdev_stats(struct inode *inode, struct file *file)
364 {
365 vfree(file->private_data);
366
367 return 0;
368 }
369
370 static ssize_t ath11k_read_vdev_stats(struct file *file,
371 char __user *user_buf,
372 size_t count, loff_t *ppos)
373 {
374 const char *buf = file->private_data;
375 size_t len = strlen(buf);
376
377 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
378 }
379
380 static const struct file_operations fops_vdev_stats = {
381 .open = ath11k_open_vdev_stats,
382 .release = ath11k_release_vdev_stats,
383 .read = ath11k_read_vdev_stats,
384 .owner = THIS_MODULE,
385 .llseek = default_llseek,
386 };
387
388 static int ath11k_open_bcn_stats(struct inode *inode, struct file *file)
389 {
390 struct ath11k *ar = inode->i_private;
391 struct ath11k_vif *arvif;
392 struct stats_request_params req_param;
393 void *buf = NULL;
394 int ret;
395
396 mutex_lock(&ar->conf_mutex);
397
398 if (ar->state != ATH11K_STATE_ON) {
399 ret = -ENETDOWN;
400 goto err_unlock;
401 }
402
403 buf = vmalloc(ATH11K_FW_STATS_BUF_SIZE);
404 if (!buf) {
405 ret = -ENOMEM;
406 goto err_unlock;
407 }
408
409 req_param.stats_id = WMI_REQUEST_BCN_STAT;
410 req_param.pdev_id = ar->pdev->pdev_id;
411
412 /* loop all active VDEVs for bcn stats */
413 list_for_each_entry(arvif, &ar->arvifs, list) {
414 if (!arvif->is_up)
415 continue;
416
417 req_param.vdev_id = arvif->vdev_id;
418 ret = ath11k_debugfs_fw_stats_request(ar, &req_param);
419 if (ret) {
420 ath11k_warn(ar->ab, "failed to request fw bcn stats: %d\n", ret);
421 goto err_free;
422 }
423 }
424
425 ath11k_wmi_fw_stats_fill(ar, &ar->fw_stats, req_param.stats_id, buf);
426
427 /* since beacon stats request is looped for all active VDEVs, saved fw
428 * stats is not freed for each request until done for all active VDEVs
429 */
430 spin_lock_bh(&ar->data_lock);
431 ath11k_fw_stats_bcn_free(&ar->fw_stats.bcn);
432 spin_unlock_bh(&ar->data_lock);
433
434 file->private_data = buf;
435
436 mutex_unlock(&ar->conf_mutex);
437 return 0;
438
439 err_free:
440 vfree(buf);
441
442 err_unlock:
443 mutex_unlock(&ar->conf_mutex);
444 return ret;
445 }
446
447 static int ath11k_release_bcn_stats(struct inode *inode, struct file *file)
448 {
449 vfree(file->private_data);
450
451 return 0;
452 }
453
454 static ssize_t ath11k_read_bcn_stats(struct file *file,
455 char __user *user_buf,
456 size_t count, loff_t *ppos)
457 {
458 const char *buf = file->private_data;
459 size_t len = strlen(buf);
460
461 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
462 }
463
464 static const struct file_operations fops_bcn_stats = {
465 .open = ath11k_open_bcn_stats,
466 .release = ath11k_release_bcn_stats,
467 .read = ath11k_read_bcn_stats,
468 .owner = THIS_MODULE,
469 .llseek = default_llseek,
470 };
471
472 static ssize_t ath11k_read_simulate_fw_crash(struct file *file,
473 char __user *user_buf,
474 size_t count, loff_t *ppos)
475 {
476 const char buf[] =
477 "To simulate firmware crash write one of the keywords to this file:\n"
478 "`assert` - this will send WMI_FORCE_FW_HANG_CMDID to firmware to cause assert.\n"
479 "`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n";
480
481 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
482 }
483
484 /* Simulate firmware crash:
485 * 'soft': Call wmi command causing firmware hang. This firmware hang is
486 * recoverable by warm firmware reset.
487 * 'hard': Force firmware crash by setting any vdev parameter for not allowed
488 * vdev id. This is hard firmware crash because it is recoverable only by cold
489 * firmware reset.
490 */
491 static ssize_t ath11k_write_simulate_fw_crash(struct file *file,
492 const char __user *user_buf,
493 size_t count, loff_t *ppos)
494 {
495 struct ath11k_base *ab = file->private_data;
496 struct ath11k_pdev *pdev;
497 struct ath11k *ar = ab->pdevs[0].ar;
498 char buf[32] = {0};
499 ssize_t rc;
500 int i, ret, radioup = 0;
501
502 for (i = 0; i < ab->num_radios; i++) {
503 pdev = &ab->pdevs[i];
504 ar = pdev->ar;
505 if (ar && ar->state == ATH11K_STATE_ON) {
506 radioup = 1;
507 break;
508 }
509 }
510 /* filter partial writes and invalid commands */
511 if (*ppos != 0 || count >= sizeof(buf) || count == 0)
512 return -EINVAL;
513
514 rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
515 if (rc < 0)
516 return rc;
517
518 /* drop the possible '\n' from the end */
519 if (buf[*ppos - 1] == '\n')
520 buf[*ppos - 1] = '\0';
521
522 if (radioup == 0) {
523 ret = -ENETDOWN;
524 goto exit;
525 }
526
527 if (!strcmp(buf, "assert")) {
528 ath11k_info(ab, "simulating firmware assert crash\n");
529 ret = ath11k_wmi_force_fw_hang_cmd(ar,
530 ATH11K_WMI_FW_HANG_ASSERT_TYPE,
531 ATH11K_WMI_FW_HANG_DELAY);
532 } else if (!strcmp(buf, "hw-restart")) {
533 ath11k_info(ab, "user requested hw restart\n");
534 queue_work(ab->workqueue_aux, &ab->reset_work);
535 ret = 0;
536 } else {
537 ret = -EINVAL;
538 goto exit;
539 }
540
541 if (ret) {
542 ath11k_warn(ab, "failed to simulate firmware crash: %d\n", ret);
543 goto exit;
544 }
545
546 ret = count;
547
548 exit:
549 return ret;
550 }
551
552 static const struct file_operations fops_simulate_fw_crash = {
553 .read = ath11k_read_simulate_fw_crash,
554 .write = ath11k_write_simulate_fw_crash,
555 .open = simple_open,
556 .owner = THIS_MODULE,
557 .llseek = default_llseek,
558 };
559
560 static ssize_t ath11k_write_enable_extd_tx_stats(struct file *file,
561 const char __user *ubuf,
562 size_t count, loff_t *ppos)
563 {
564 struct ath11k *ar = file->private_data;
565 u32 filter;
566 int ret;
567
568 if (kstrtouint_from_user(ubuf, count, 0, &filter))
569 return -EINVAL;
570
571 mutex_lock(&ar->conf_mutex);
572
573 if (ar->state != ATH11K_STATE_ON) {
574 ret = -ENETDOWN;
575 goto out;
576 }
577
578 if (filter == ar->debug.extd_tx_stats) {
579 ret = count;
580 goto out;
581 }
582
583 ar->debug.extd_tx_stats = filter;
584 ret = count;
585
586 out:
587 mutex_unlock(&ar->conf_mutex);
588 return ret;
589 }
590
591 static ssize_t ath11k_read_enable_extd_tx_stats(struct file *file,
592 char __user *ubuf,
593 size_t count, loff_t *ppos)
594
595 {
596 char buf[32] = {0};
597 struct ath11k *ar = file->private_data;
598 int len = 0;
599
600 mutex_lock(&ar->conf_mutex);
601 len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
602 ar->debug.extd_tx_stats);
603 mutex_unlock(&ar->conf_mutex);
604
605 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
606 }
607
608 static const struct file_operations fops_extd_tx_stats = {
609 .read = ath11k_read_enable_extd_tx_stats,
610 .write = ath11k_write_enable_extd_tx_stats,
611 .open = simple_open
612 };
613
614 static ssize_t ath11k_write_extd_rx_stats(struct file *file,
615 const char __user *ubuf,
616 size_t count, loff_t *ppos)
617 {
618 struct ath11k *ar = file->private_data;
619 struct ath11k_base *ab = ar->ab;
620 struct htt_rx_ring_tlv_filter tlv_filter = {0};
621 u32 enable, rx_filter = 0, ring_id;
622 int i;
623 int ret;
624
625 if (kstrtouint_from_user(ubuf, count, 0, &enable))
626 return -EINVAL;
627
628 mutex_lock(&ar->conf_mutex);
629
630 if (ar->state != ATH11K_STATE_ON) {
631 ret = -ENETDOWN;
632 goto exit;
633 }
634
635 if (enable > 1) {
636 ret = -EINVAL;
637 goto exit;
638 }
639
640 if (enable == ar->debug.extd_rx_stats) {
641 ret = count;
642 goto exit;
643 }
644
645 if (test_bit(ATH11K_FLAG_MONITOR_STARTED, &ar->monitor_flags)) {
646 ar->debug.extd_rx_stats = enable;
647 ret = count;
648 goto exit;
649 }
650
651 if (enable) {
652 rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START;
653 rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_START;
654 rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END;
655 rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS;
656 rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS_EXT;
657 rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE;
658
659 tlv_filter.rx_filter = rx_filter;
660 tlv_filter.pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0;
661 tlv_filter.pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1;
662 tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2;
663 tlv_filter.pkt_filter_flags3 = HTT_RX_FP_CTRL_FILTER_FLASG3 |
664 HTT_RX_FP_DATA_FILTER_FLASG3;
665 } else {
666 tlv_filter = ath11k_mac_mon_status_filter_default;
667 }
668
669 ar->debug.rx_filter = tlv_filter.rx_filter;
670
671 for (i = 0; i < ab->hw_params.num_rxdma_per_pdev; i++) {
672 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
673 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, ar->dp.mac_id,
674 HAL_RXDMA_MONITOR_STATUS,
675 DP_RX_BUFFER_SIZE, &tlv_filter);
676
677 if (ret) {
678 ath11k_warn(ar->ab, "failed to set rx filter for monitor status ring\n");
679 goto exit;
680 }
681 }
682
683 ar->debug.extd_rx_stats = enable;
684 ret = count;
685 exit:
686 mutex_unlock(&ar->conf_mutex);
687 return ret;
688 }
689
690 static ssize_t ath11k_read_extd_rx_stats(struct file *file,
691 char __user *ubuf,
692 size_t count, loff_t *ppos)
693 {
694 struct ath11k *ar = file->private_data;
695 char buf[32];
696 int len = 0;
697
698 mutex_lock(&ar->conf_mutex);
699 len = scnprintf(buf, sizeof(buf) - len, "%d\n",
700 ar->debug.extd_rx_stats);
701 mutex_unlock(&ar->conf_mutex);
702
703 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
704 }
705
706 static const struct file_operations fops_extd_rx_stats = {
707 .read = ath11k_read_extd_rx_stats,
708 .write = ath11k_write_extd_rx_stats,
709 .open = simple_open,
710 };
711
712 static int ath11k_fill_bp_stats(struct ath11k_base *ab,
713 struct ath11k_bp_stats *bp_stats,
714 char *buf, int len, int size)
715 {
716 lockdep_assert_held(&ab->base_lock);
717
718 len += scnprintf(buf + len, size - len, "count: %u\n",
719 bp_stats->count);
720 len += scnprintf(buf + len, size - len, "hp: %u\n",
721 bp_stats->hp);
722 len += scnprintf(buf + len, size - len, "tp: %u\n",
723 bp_stats->tp);
724 len += scnprintf(buf + len, size - len, "seen before: %ums\n\n",
725 jiffies_to_msecs(jiffies - bp_stats->jiffies));
726 return len;
727 }
728
729 static ssize_t ath11k_debugfs_dump_soc_ring_bp_stats(struct ath11k_base *ab,
730 char *buf, int size)
731 {
732 struct ath11k_bp_stats *bp_stats;
733 bool stats_rxd = false;
734 u8 i, pdev_idx;
735 int len = 0;
736
737 len += scnprintf(buf + len, size - len, "\nBackpressure Stats\n");
738 len += scnprintf(buf + len, size - len, "==================\n");
739
740 spin_lock_bh(&ab->base_lock);
741 for (i = 0; i < HTT_SW_UMAC_RING_IDX_MAX; i++) {
742 bp_stats = &ab->soc_stats.bp_stats.umac_ring_bp_stats[i];
743
744 if (!bp_stats->count)
745 continue;
746
747 len += scnprintf(buf + len, size - len, "Ring: %s\n",
748 htt_bp_umac_ring[i]);
749 len = ath11k_fill_bp_stats(ab, bp_stats, buf, len, size);
750 stats_rxd = true;
751 }
752
753 for (i = 0; i < HTT_SW_LMAC_RING_IDX_MAX; i++) {
754 for (pdev_idx = 0; pdev_idx < MAX_RADIOS; pdev_idx++) {
755 bp_stats =
756 &ab->soc_stats.bp_stats.lmac_ring_bp_stats[i][pdev_idx];
757
758 if (!bp_stats->count)
759 continue;
760
761 len += scnprintf(buf + len, size - len, "Ring: %s\n",
762 htt_bp_lmac_ring[i]);
763 len += scnprintf(buf + len, size - len, "pdev: %d\n",
764 pdev_idx);
765 len = ath11k_fill_bp_stats(ab, bp_stats, buf, len, size);
766 stats_rxd = true;
767 }
768 }
769 spin_unlock_bh(&ab->base_lock);
770
771 if (!stats_rxd)
772 len += scnprintf(buf + len, size - len,
773 "No Ring Backpressure stats received\n\n");
774
775 return len;
776 }
777
778 static ssize_t ath11k_debugfs_dump_soc_dp_stats(struct file *file,
779 char __user *user_buf,
780 size_t count, loff_t *ppos)
781 {
782 struct ath11k_base *ab = file->private_data;
783 struct ath11k_soc_dp_stats *soc_stats = &ab->soc_stats;
784 int len = 0, i, retval;
785 const int size = 4096;
786 static const char *rxdma_err[HAL_REO_ENTR_RING_RXDMA_ECODE_MAX] = {
787 "Overflow", "MPDU len", "FCS", "Decrypt", "TKIP MIC",
788 "Unencrypt", "MSDU len", "MSDU limit", "WiFi parse",
789 "AMSDU parse", "SA timeout", "DA timeout",
790 "Flow timeout", "Flush req"};
791 static const char *reo_err[HAL_REO_DEST_RING_ERROR_CODE_MAX] = {
792 "Desc addr zero", "Desc inval", "AMPDU in non BA",
793 "Non BA dup", "BA dup", "Frame 2k jump", "BAR 2k jump",
794 "Frame OOR", "BAR OOR", "No BA session",
795 "Frame SN equal SSN", "PN check fail", "2k err",
796 "PN err", "Desc blocked"};
797
798 char *buf;
799
800 buf = kzalloc(size, GFP_KERNEL);
801 if (!buf)
802 return -ENOMEM;
803
804 len += scnprintf(buf + len, size - len, "SOC RX STATS:\n\n");
805 len += scnprintf(buf + len, size - len, "err ring pkts: %u\n",
806 soc_stats->err_ring_pkts);
807 len += scnprintf(buf + len, size - len, "Invalid RBM: %u\n\n",
808 soc_stats->invalid_rbm);
809 len += scnprintf(buf + len, size - len, "RXDMA errors:\n");
810 for (i = 0; i < HAL_REO_ENTR_RING_RXDMA_ECODE_MAX; i++)
811 len += scnprintf(buf + len, size - len, "%s: %u\n",
812 rxdma_err[i], soc_stats->rxdma_error[i]);
813
814 len += scnprintf(buf + len, size - len, "\nREO errors:\n");
815 for (i = 0; i < HAL_REO_DEST_RING_ERROR_CODE_MAX; i++)
816 len += scnprintf(buf + len, size - len, "%s: %u\n",
817 reo_err[i], soc_stats->reo_error[i]);
818
819 len += scnprintf(buf + len, size - len, "\nHAL REO errors:\n");
820 len += scnprintf(buf + len, size - len,
821 "ring0: %u\nring1: %u\nring2: %u\nring3: %u\n",
822 soc_stats->hal_reo_error[0],
823 soc_stats->hal_reo_error[1],
824 soc_stats->hal_reo_error[2],
825 soc_stats->hal_reo_error[3]);
826
827 len += scnprintf(buf + len, size - len, "\nSOC TX STATS:\n");
828 len += scnprintf(buf + len, size - len, "\nTCL Ring Full Failures:\n");
829
830 for (i = 0; i < ab->hw_params.max_tx_ring; i++)
831 len += scnprintf(buf + len, size - len, "ring%d: %u\n",
832 i, soc_stats->tx_err.desc_na[i]);
833
834 len += scnprintf(buf + len, size - len,
835 "\nMisc Transmit Failures: %d\n",
836 atomic_read(&soc_stats->tx_err.misc_fail));
837
838 len += ath11k_debugfs_dump_soc_ring_bp_stats(ab, buf + len, size - len);
839
840 if (len > size)
841 len = size;
842 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
843 kfree(buf);
844
845 return retval;
846 }
847
848 static const struct file_operations fops_soc_dp_stats = {
849 .read = ath11k_debugfs_dump_soc_dp_stats,
850 .open = simple_open,
851 .owner = THIS_MODULE,
852 .llseek = default_llseek,
853 };
854
855 static ssize_t ath11k_write_fw_dbglog(struct file *file,
856 const char __user *user_buf,
857 size_t count, loff_t *ppos)
858 {
859 struct ath11k *ar = file->private_data;
860 char buf[128] = {0};
861 struct ath11k_fw_dbglog dbglog;
862 unsigned int param, mod_id_index, is_end;
863 u64 value;
864 int ret, num;
865
866 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
867 user_buf, count);
868 if (ret <= 0)
869 return ret;
870
871 num = sscanf(buf, "%u %llx %u %u", &param, &value, &mod_id_index, &is_end);
872
873 if (num < 2)
874 return -EINVAL;
875
876 mutex_lock(&ar->conf_mutex);
877 if (param == WMI_DEBUG_LOG_PARAM_MOD_ENABLE_BITMAP ||
878 param == WMI_DEBUG_LOG_PARAM_WOW_MOD_ENABLE_BITMAP) {
879 if (num != 4 || mod_id_index > (MAX_MODULE_ID_BITMAP_WORDS - 1)) {
880 ret = -EINVAL;
881 goto out;
882 }
883 ar->debug.module_id_bitmap[mod_id_index] = upper_32_bits(value);
884 if (!is_end) {
885 ret = count;
886 goto out;
887 }
888 } else {
889 if (num != 2) {
890 ret = -EINVAL;
891 goto out;
892 }
893 }
894
895 dbglog.param = param;
896 dbglog.value = lower_32_bits(value);
897 ret = ath11k_wmi_fw_dbglog_cfg(ar, ar->debug.module_id_bitmap, &dbglog);
898 if (ret) {
899 ath11k_warn(ar->ab, "fw dbglog config failed from debugfs: %d\n",
900 ret);
901 goto out;
902 }
903
904 ret = count;
905
906 out:
907 mutex_unlock(&ar->conf_mutex);
908 return ret;
909 }
910
911 static const struct file_operations fops_fw_dbglog = {
912 .write = ath11k_write_fw_dbglog,
913 .open = simple_open,
914 .owner = THIS_MODULE,
915 .llseek = default_llseek,
916 };
917
918 static int ath11k_open_sram_dump(struct inode *inode, struct file *file)
919 {
920 struct ath11k_base *ab = inode->i_private;
921 u8 *buf;
922 u32 start, end;
923 int ret;
924
925 start = ab->hw_params.sram_dump.start;
926 end = ab->hw_params.sram_dump.end;
927
928 buf = vmalloc(end - start + 1);
929 if (!buf)
930 return -ENOMEM;
931
932 ret = ath11k_hif_read(ab, buf, start, end);
933 if (ret) {
934 ath11k_warn(ab, "failed to dump sram: %d\n", ret);
935 vfree(buf);
936 return ret;
937 }
938
939 file->private_data = buf;
940 return 0;
941 }
942
943 static ssize_t ath11k_read_sram_dump(struct file *file,
944 char __user *user_buf,
945 size_t count, loff_t *ppos)
946 {
947 struct ath11k_base *ab = file->f_inode->i_private;
948 const char *buf = file->private_data;
949 int len;
950 u32 start, end;
951
952 start = ab->hw_params.sram_dump.start;
953 end = ab->hw_params.sram_dump.end;
954 len = end - start + 1;
955
956 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
957 }
958
959 static int ath11k_release_sram_dump(struct inode *inode, struct file *file)
960 {
961 vfree(file->private_data);
962 file->private_data = NULL;
963
964 return 0;
965 }
966
967 static const struct file_operations fops_sram_dump = {
968 .open = ath11k_open_sram_dump,
969 .read = ath11k_read_sram_dump,
970 .release = ath11k_release_sram_dump,
971 .owner = THIS_MODULE,
972 .llseek = default_llseek,
973 };
974
975 int ath11k_debugfs_pdev_create(struct ath11k_base *ab)
976 {
977 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags))
978 return 0;
979
980 debugfs_create_file("simulate_fw_crash", 0600, ab->debugfs_soc, ab,
981 &fops_simulate_fw_crash);
982
983 debugfs_create_file("soc_dp_stats", 0400, ab->debugfs_soc, ab,
984 &fops_soc_dp_stats);
985
986 if (ab->hw_params.sram_dump.start != 0)
987 debugfs_create_file("sram", 0400, ab->debugfs_soc, ab,
988 &fops_sram_dump);
989
990 return 0;
991 }
992
993 void ath11k_debugfs_pdev_destroy(struct ath11k_base *ab)
994 {
995 debugfs_remove_recursive(ab->debugfs_soc);
996 ab->debugfs_soc = NULL;
997 }
998
999 int ath11k_debugfs_soc_create(struct ath11k_base *ab)
1000 {
1001 struct dentry *root;
1002 bool dput_needed;
1003 char name[64];
1004 int ret;
1005
1006 root = debugfs_lookup("ath11k", NULL);
1007 if (!root) {
1008 root = debugfs_create_dir("ath11k", NULL);
1009 if (IS_ERR_OR_NULL(root))
1010 return PTR_ERR(root);
1011
1012 dput_needed = false;
1013 } else {
1014 /* a dentry from lookup() needs dput() after we don't use it */
1015 dput_needed = true;
1016 }
1017
1018 scnprintf(name, sizeof(name), "%s-%s", ath11k_bus_str(ab->hif.bus),
1019 dev_name(ab->dev));
1020
1021 ab->debugfs_soc = debugfs_create_dir(name, root);
1022 if (IS_ERR_OR_NULL(ab->debugfs_soc)) {
1023 ret = PTR_ERR(ab->debugfs_soc);
1024 goto out;
1025 }
1026
1027 ret = 0;
1028
1029 out:
1030 if (dput_needed)
1031 dput(root);
1032
1033 return ret;
1034 }
1035
1036 void ath11k_debugfs_soc_destroy(struct ath11k_base *ab)
1037 {
1038 debugfs_remove_recursive(ab->debugfs_soc);
1039 ab->debugfs_soc = NULL;
1040
1041 /* We are not removing ath11k directory on purpose, even if it
1042 * would be empty. This simplifies the directory handling and it's
1043 * a minor cosmetic issue to leave an empty ath11k directory to
1044 * debugfs.
1045 */
1046 }
1047 EXPORT_SYMBOL(ath11k_debugfs_soc_destroy);
1048
1049 void ath11k_debugfs_fw_stats_init(struct ath11k *ar)
1050 {
1051 struct dentry *fwstats_dir = debugfs_create_dir("fw_stats",
1052 ar->debug.debugfs_pdev);
1053
1054 ar->fw_stats.debugfs_fwstats = fwstats_dir;
1055
1056 /* all stats debugfs files created are under "fw_stats" directory
1057 * created per PDEV
1058 */
1059 debugfs_create_file("pdev_stats", 0600, fwstats_dir, ar,
1060 &fops_pdev_stats);
1061 debugfs_create_file("vdev_stats", 0600, fwstats_dir, ar,
1062 &fops_vdev_stats);
1063 debugfs_create_file("beacon_stats", 0600, fwstats_dir, ar,
1064 &fops_bcn_stats);
1065 }
1066
1067 static ssize_t ath11k_write_pktlog_filter(struct file *file,
1068 const char __user *ubuf,
1069 size_t count, loff_t *ppos)
1070 {
1071 struct ath11k *ar = file->private_data;
1072 struct ath11k_base *ab = ar->ab;
1073 struct htt_rx_ring_tlv_filter tlv_filter = {0};
1074 u32 rx_filter = 0, ring_id, filter, mode;
1075 u8 buf[128] = {0};
1076 int i, ret, rx_buf_sz = 0;
1077 ssize_t rc;
1078
1079 mutex_lock(&ar->conf_mutex);
1080 if (ar->state != ATH11K_STATE_ON) {
1081 ret = -ENETDOWN;
1082 goto out;
1083 }
1084
1085 rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count);
1086 if (rc < 0) {
1087 ret = rc;
1088 goto out;
1089 }
1090 buf[rc] = '\0';
1091
1092 ret = sscanf(buf, "0x%x %u", &filter, &mode);
1093 if (ret != 2) {
1094 ret = -EINVAL;
1095 goto out;
1096 }
1097
1098 if (filter) {
1099 ret = ath11k_wmi_pdev_pktlog_enable(ar, filter);
1100 if (ret) {
1101 ath11k_warn(ar->ab,
1102 "failed to enable pktlog filter %x: %d\n",
1103 ar->debug.pktlog_filter, ret);
1104 goto out;
1105 }
1106 } else {
1107 ret = ath11k_wmi_pdev_pktlog_disable(ar);
1108 if (ret) {
1109 ath11k_warn(ar->ab, "failed to disable pktlog: %d\n", ret);
1110 goto out;
1111 }
1112 }
1113
1114 /* Clear rx filter set for monitor mode and rx status */
1115 for (i = 0; i < ab->hw_params.num_rxdma_per_pdev; i++) {
1116 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
1117 ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, ar->dp.mac_id,
1118 HAL_RXDMA_MONITOR_STATUS,
1119 rx_buf_sz, &tlv_filter);
1120 if (ret) {
1121 ath11k_warn(ar->ab, "failed to set rx filter for monitor status ring\n");
1122 goto out;
1123 }
1124 }
1125 #define HTT_RX_FILTER_TLV_LITE_MODE \
1126 (HTT_RX_FILTER_TLV_FLAGS_PPDU_START | \
1127 HTT_RX_FILTER_TLV_FLAGS_PPDU_END | \
1128 HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS | \
1129 HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS_EXT | \
1130 HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE | \
1131 HTT_RX_FILTER_TLV_FLAGS_MPDU_START)
1132
1133 if (mode == ATH11K_PKTLOG_MODE_FULL) {
1134 rx_filter = HTT_RX_FILTER_TLV_LITE_MODE |
1135 HTT_RX_FILTER_TLV_FLAGS_MSDU_START |
1136 HTT_RX_FILTER_TLV_FLAGS_MSDU_END |
1137 HTT_RX_FILTER_TLV_FLAGS_MPDU_END |
1138 HTT_RX_FILTER_TLV_FLAGS_PACKET_HEADER |
1139 HTT_RX_FILTER_TLV_FLAGS_ATTENTION;
1140 rx_buf_sz = DP_RX_BUFFER_SIZE;
1141 } else if (mode == ATH11K_PKTLOG_MODE_LITE) {
1142 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
1143 HTT_PPDU_STATS_TAG_PKTLOG);
1144 if (ret) {
1145 ath11k_err(ar->ab, "failed to enable pktlog lite: %d\n", ret);
1146 goto out;
1147 }
1148
1149 rx_filter = HTT_RX_FILTER_TLV_LITE_MODE;
1150 rx_buf_sz = DP_RX_BUFFER_SIZE_LITE;
1151 } else {
1152 rx_buf_sz = DP_RX_BUFFER_SIZE;
1153 tlv_filter = ath11k_mac_mon_status_filter_default;
1154 rx_filter = tlv_filter.rx_filter;
1155
1156 ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar,
1157 HTT_PPDU_STATS_TAG_DEFAULT);
1158 if (ret) {
1159 ath11k_err(ar->ab, "failed to send htt ppdu stats req: %d\n",
1160 ret);
1161 goto out;
1162 }
1163 }
1164
1165 tlv_filter.rx_filter = rx_filter;
1166 if (rx_filter) {
1167 tlv_filter.pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0;
1168 tlv_filter.pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1;
1169 tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2;
1170 tlv_filter.pkt_filter_flags3 = HTT_RX_FP_CTRL_FILTER_FLASG3 |
1171 HTT_RX_FP_DATA_FILTER_FLASG3;
1172 }
1173
1174 for (i = 0; i < ab->hw_params.num_rxdma_per_pdev; i++) {
1175 ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id;
1176 ret = ath11k_dp_tx_htt_rx_filter_setup(ab, ring_id,
1177 ar->dp.mac_id + i,
1178 HAL_RXDMA_MONITOR_STATUS,
1179 rx_buf_sz, &tlv_filter);
1180
1181 if (ret) {
1182 ath11k_warn(ab, "failed to set rx filter for monitor status ring\n");
1183 goto out;
1184 }
1185 }
1186
1187 ath11k_info(ab, "pktlog mode %s\n",
1188 ((mode == ATH11K_PKTLOG_MODE_FULL) ? "full" : "lite"));
1189
1190 ar->debug.pktlog_filter = filter;
1191 ar->debug.pktlog_mode = mode;
1192 ret = count;
1193
1194 out:
1195 mutex_unlock(&ar->conf_mutex);
1196 return ret;
1197 }
1198
1199 static ssize_t ath11k_read_pktlog_filter(struct file *file,
1200 char __user *ubuf,
1201 size_t count, loff_t *ppos)
1202
1203 {
1204 char buf[32] = {0};
1205 struct ath11k *ar = file->private_data;
1206 int len = 0;
1207
1208 mutex_lock(&ar->conf_mutex);
1209 len = scnprintf(buf, sizeof(buf) - len, "%08x %08x\n",
1210 ar->debug.pktlog_filter,
1211 ar->debug.pktlog_mode);
1212 mutex_unlock(&ar->conf_mutex);
1213
1214 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
1215 }
1216
1217 static const struct file_operations fops_pktlog_filter = {
1218 .read = ath11k_read_pktlog_filter,
1219 .write = ath11k_write_pktlog_filter,
1220 .open = simple_open
1221 };
1222
1223 static ssize_t ath11k_write_simulate_radar(struct file *file,
1224 const char __user *user_buf,
1225 size_t count, loff_t *ppos)
1226 {
1227 struct ath11k *ar = file->private_data;
1228 int ret;
1229
1230 ret = ath11k_wmi_simulate_radar(ar);
1231 if (ret)
1232 return ret;
1233
1234 return count;
1235 }
1236
1237 static const struct file_operations fops_simulate_radar = {
1238 .write = ath11k_write_simulate_radar,
1239 .open = simple_open
1240 };
1241
1242 static ssize_t ath11k_debug_dump_dbr_entries(struct file *file,
1243 char __user *user_buf,
1244 size_t count, loff_t *ppos)
1245 {
1246 struct ath11k_dbg_dbr_data *dbr_dbg_data = file->private_data;
1247 static const char * const event_id_to_string[] = {"empty", "Rx", "Replenish"};
1248 int size = ATH11K_DEBUG_DBR_ENTRIES_MAX * 100;
1249 char *buf;
1250 int i, ret;
1251 int len = 0;
1252
1253 buf = kzalloc(size, GFP_KERNEL);
1254 if (!buf)
1255 return -ENOMEM;
1256
1257 len += scnprintf(buf + len, size - len,
1258 "-----------------------------------------\n");
1259 len += scnprintf(buf + len, size - len,
1260 "| idx | hp | tp | timestamp | event |\n");
1261 len += scnprintf(buf + len, size - len,
1262 "-----------------------------------------\n");
1263
1264 spin_lock_bh(&dbr_dbg_data->lock);
1265
1266 for (i = 0; i < dbr_dbg_data->num_ring_debug_entries; i++) {
1267 len += scnprintf(buf + len, size - len,
1268 "|%4u|%8u|%8u|%11llu|%8s|\n", i,
1269 dbr_dbg_data->entries[i].hp,
1270 dbr_dbg_data->entries[i].tp,
1271 dbr_dbg_data->entries[i].timestamp,
1272 event_id_to_string[dbr_dbg_data->entries[i].event]);
1273 }
1274
1275 spin_unlock_bh(&dbr_dbg_data->lock);
1276
1277 ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1278 kfree(buf);
1279
1280 return ret;
1281 }
1282
1283 static const struct file_operations fops_debug_dump_dbr_entries = {
1284 .read = ath11k_debug_dump_dbr_entries,
1285 .open = simple_open,
1286 .owner = THIS_MODULE,
1287 .llseek = default_llseek,
1288 };
1289
1290 static void ath11k_debugfs_dbr_dbg_destroy(struct ath11k *ar, int dbr_id)
1291 {
1292 struct ath11k_debug_dbr *dbr_debug;
1293 struct ath11k_dbg_dbr_data *dbr_dbg_data;
1294
1295 if (!ar->debug.dbr_debug[dbr_id])
1296 return;
1297
1298 dbr_debug = ar->debug.dbr_debug[dbr_id];
1299 dbr_dbg_data = &dbr_debug->dbr_dbg_data;
1300
1301 debugfs_remove_recursive(dbr_debug->dbr_debugfs);
1302 kfree(dbr_dbg_data->entries);
1303 kfree(dbr_debug);
1304 ar->debug.dbr_debug[dbr_id] = NULL;
1305 }
1306
1307 static int ath11k_debugfs_dbr_dbg_init(struct ath11k *ar, int dbr_id)
1308 {
1309 struct ath11k_debug_dbr *dbr_debug;
1310 struct ath11k_dbg_dbr_data *dbr_dbg_data;
1311 static const char * const dbr_id_to_str[] = {"spectral", "CFR"};
1312
1313 if (ar->debug.dbr_debug[dbr_id])
1314 return 0;
1315
1316 ar->debug.dbr_debug[dbr_id] = kzalloc(sizeof(*dbr_debug),
1317 GFP_KERNEL);
1318
1319 if (!ar->debug.dbr_debug[dbr_id])
1320 return -ENOMEM;
1321
1322 dbr_debug = ar->debug.dbr_debug[dbr_id];
1323 dbr_dbg_data = &dbr_debug->dbr_dbg_data;
1324
1325 if (dbr_debug->dbr_debugfs)
1326 return 0;
1327
1328 dbr_debug->dbr_debugfs = debugfs_create_dir(dbr_id_to_str[dbr_id],
1329 ar->debug.debugfs_pdev);
1330 if (IS_ERR_OR_NULL(dbr_debug->dbr_debugfs)) {
1331 if (IS_ERR(dbr_debug->dbr_debugfs))
1332 return PTR_ERR(dbr_debug->dbr_debugfs);
1333 return -ENOMEM;
1334 }
1335
1336 dbr_debug->dbr_debug_enabled = true;
1337 dbr_dbg_data->num_ring_debug_entries = ATH11K_DEBUG_DBR_ENTRIES_MAX;
1338 dbr_dbg_data->dbr_debug_idx = 0;
1339 dbr_dbg_data->entries = kcalloc(ATH11K_DEBUG_DBR_ENTRIES_MAX,
1340 sizeof(struct ath11k_dbg_dbr_entry),
1341 GFP_KERNEL);
1342 if (!dbr_dbg_data->entries)
1343 return -ENOMEM;
1344
1345 spin_lock_init(&dbr_dbg_data->lock);
1346
1347 debugfs_create_file("dump_dbr_debug", 0444, dbr_debug->dbr_debugfs,
1348 dbr_dbg_data, &fops_debug_dump_dbr_entries);
1349
1350 return 0;
1351 }
1352
1353 static ssize_t ath11k_debugfs_write_enable_dbr_dbg(struct file *file,
1354 const char __user *ubuf,
1355 size_t count, loff_t *ppos)
1356 {
1357 struct ath11k *ar = file->private_data;
1358 char buf[32] = {0};
1359 u32 dbr_id, enable;
1360 int ret;
1361
1362 mutex_lock(&ar->conf_mutex);
1363
1364 if (ar->state != ATH11K_STATE_ON) {
1365 ret = -ENETDOWN;
1366 goto out;
1367 }
1368
1369 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count);
1370 if (ret < 0)
1371 goto out;
1372
1373 buf[ret] = '\0';
1374 ret = sscanf(buf, "%u %u", &dbr_id, &enable);
1375 if (ret != 2 || dbr_id > 1 || enable > 1) {
1376 ret = -EINVAL;
1377 ath11k_warn(ar->ab, "usage: echo <dbr_id> <val> dbr_id:0-Spectral 1-CFR val:0-disable 1-enable\n");
1378 goto out;
1379 }
1380
1381 if (enable) {
1382 ret = ath11k_debugfs_dbr_dbg_init(ar, dbr_id);
1383 if (ret) {
1384 ath11k_warn(ar->ab, "db ring module debugfs init failed: %d\n",
1385 ret);
1386 goto out;
1387 }
1388 } else {
1389 ath11k_debugfs_dbr_dbg_destroy(ar, dbr_id);
1390 }
1391
1392 ret = count;
1393 out:
1394 mutex_unlock(&ar->conf_mutex);
1395 return ret;
1396 }
1397
1398 static const struct file_operations fops_dbr_debug = {
1399 .write = ath11k_debugfs_write_enable_dbr_dbg,
1400 .open = simple_open,
1401 .owner = THIS_MODULE,
1402 .llseek = default_llseek,
1403 };
1404
1405 static ssize_t ath11k_write_ps_timekeeper_enable(struct file *file,
1406 const char __user *user_buf,
1407 size_t count, loff_t *ppos)
1408 {
1409 struct ath11k *ar = file->private_data;
1410 ssize_t ret;
1411 u8 ps_timekeeper_enable;
1412
1413 if (kstrtou8_from_user(user_buf, count, 0, &ps_timekeeper_enable))
1414 return -EINVAL;
1415
1416 mutex_lock(&ar->conf_mutex);
1417
1418 if (ar->state != ATH11K_STATE_ON) {
1419 ret = -ENETDOWN;
1420 goto exit;
1421 }
1422
1423 if (!ar->ps_state_enable) {
1424 ret = -EINVAL;
1425 goto exit;
1426 }
1427
1428 ar->ps_timekeeper_enable = !!ps_timekeeper_enable;
1429 ret = count;
1430 exit:
1431 mutex_unlock(&ar->conf_mutex);
1432
1433 return ret;
1434 }
1435
1436 static ssize_t ath11k_read_ps_timekeeper_enable(struct file *file,
1437 char __user *user_buf,
1438 size_t count, loff_t *ppos)
1439 {
1440 struct ath11k *ar = file->private_data;
1441 char buf[32];
1442 int len;
1443
1444 mutex_lock(&ar->conf_mutex);
1445 len = scnprintf(buf, sizeof(buf), "%d\n", ar->ps_timekeeper_enable);
1446 mutex_unlock(&ar->conf_mutex);
1447
1448 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1449 }
1450
1451 static const struct file_operations fops_ps_timekeeper_enable = {
1452 .read = ath11k_read_ps_timekeeper_enable,
1453 .write = ath11k_write_ps_timekeeper_enable,
1454 .open = simple_open,
1455 .owner = THIS_MODULE,
1456 .llseek = default_llseek,
1457 };
1458
1459 static void ath11k_reset_peer_ps_duration(void *data,
1460 struct ieee80211_sta *sta)
1461 {
1462 struct ath11k *ar = data;
1463 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
1464
1465 spin_lock_bh(&ar->data_lock);
1466 arsta->ps_total_duration = 0;
1467 spin_unlock_bh(&ar->data_lock);
1468 }
1469
1470 static ssize_t ath11k_write_reset_ps_duration(struct file *file,
1471 const char __user *user_buf,
1472 size_t count, loff_t *ppos)
1473 {
1474 struct ath11k *ar = file->private_data;
1475 int ret;
1476 u8 reset_ps_duration;
1477
1478 if (kstrtou8_from_user(user_buf, count, 0, &reset_ps_duration))
1479 return -EINVAL;
1480
1481 mutex_lock(&ar->conf_mutex);
1482
1483 if (ar->state != ATH11K_STATE_ON) {
1484 ret = -ENETDOWN;
1485 goto exit;
1486 }
1487
1488 if (!ar->ps_state_enable) {
1489 ret = -EINVAL;
1490 goto exit;
1491 }
1492
1493 ieee80211_iterate_stations_atomic(ar->hw,
1494 ath11k_reset_peer_ps_duration,
1495 ar);
1496
1497 ret = count;
1498 exit:
1499 mutex_unlock(&ar->conf_mutex);
1500 return ret;
1501 }
1502
1503 static const struct file_operations fops_reset_ps_duration = {
1504 .write = ath11k_write_reset_ps_duration,
1505 .open = simple_open,
1506 .owner = THIS_MODULE,
1507 .llseek = default_llseek,
1508 };
1509
1510 static void ath11k_peer_ps_state_disable(void *data,
1511 struct ieee80211_sta *sta)
1512 {
1513 struct ath11k *ar = data;
1514 struct ath11k_sta *arsta = ath11k_sta_to_arsta(sta);
1515
1516 spin_lock_bh(&ar->data_lock);
1517 arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
1518 arsta->ps_start_time = 0;
1519 arsta->ps_total_duration = 0;
1520 spin_unlock_bh(&ar->data_lock);
1521 }
1522
1523 static ssize_t ath11k_write_ps_state_enable(struct file *file,
1524 const char __user *user_buf,
1525 size_t count, loff_t *ppos)
1526 {
1527 struct ath11k *ar = file->private_data;
1528 struct ath11k_pdev *pdev = ar->pdev;
1529 int ret;
1530 u32 param;
1531 u8 ps_state_enable;
1532
1533 if (kstrtou8_from_user(user_buf, count, 0, &ps_state_enable))
1534 return -EINVAL;
1535
1536 mutex_lock(&ar->conf_mutex);
1537
1538 ps_state_enable = !!ps_state_enable;
1539
1540 if (ar->ps_state_enable == ps_state_enable) {
1541 ret = count;
1542 goto exit;
1543 }
1544
1545 param = WMI_PDEV_PEER_STA_PS_STATECHG_ENABLE;
1546 ret = ath11k_wmi_pdev_set_param(ar, param, ps_state_enable, pdev->pdev_id);
1547 if (ret) {
1548 ath11k_warn(ar->ab, "failed to enable ps_state_enable: %d\n",
1549 ret);
1550 goto exit;
1551 }
1552 ar->ps_state_enable = ps_state_enable;
1553
1554 if (!ar->ps_state_enable) {
1555 ar->ps_timekeeper_enable = false;
1556 ieee80211_iterate_stations_atomic(ar->hw,
1557 ath11k_peer_ps_state_disable,
1558 ar);
1559 }
1560
1561 ret = count;
1562
1563 exit:
1564 mutex_unlock(&ar->conf_mutex);
1565
1566 return ret;
1567 }
1568
1569 static ssize_t ath11k_read_ps_state_enable(struct file *file,
1570 char __user *user_buf,
1571 size_t count, loff_t *ppos)
1572 {
1573 struct ath11k *ar = file->private_data;
1574 char buf[32];
1575 int len;
1576
1577 mutex_lock(&ar->conf_mutex);
1578 len = scnprintf(buf, sizeof(buf), "%d\n", ar->ps_state_enable);
1579 mutex_unlock(&ar->conf_mutex);
1580
1581 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1582 }
1583
1584 static const struct file_operations fops_ps_state_enable = {
1585 .read = ath11k_read_ps_state_enable,
1586 .write = ath11k_write_ps_state_enable,
1587 .open = simple_open,
1588 .owner = THIS_MODULE,
1589 .llseek = default_llseek,
1590 };
1591
1592 int ath11k_debugfs_register(struct ath11k *ar)
1593 {
1594 struct ath11k_base *ab = ar->ab;
1595 char pdev_name[10];
1596 char buf[100] = {0};
1597
1598 snprintf(pdev_name, sizeof(pdev_name), "%s%u", "mac", ar->pdev_idx);
1599
1600 ar->debug.debugfs_pdev = debugfs_create_dir(pdev_name, ab->debugfs_soc);
1601 if (IS_ERR(ar->debug.debugfs_pdev))
1602 return PTR_ERR(ar->debug.debugfs_pdev);
1603
1604 /* Create a symlink under ieee80211/phy* */
1605 snprintf(buf, 100, "../../ath11k/%pd2", ar->debug.debugfs_pdev);
1606 debugfs_create_symlink("ath11k", ar->hw->wiphy->debugfsdir, buf);
1607
1608 ath11k_debugfs_htt_stats_init(ar);
1609
1610 ath11k_debugfs_fw_stats_init(ar);
1611
1612 debugfs_create_file("ext_tx_stats", 0644,
1613 ar->debug.debugfs_pdev, ar,
1614 &fops_extd_tx_stats);
1615 debugfs_create_file("ext_rx_stats", 0644,
1616 ar->debug.debugfs_pdev, ar,
1617 &fops_extd_rx_stats);
1618 debugfs_create_file("pktlog_filter", 0644,
1619 ar->debug.debugfs_pdev, ar,
1620 &fops_pktlog_filter);
1621 debugfs_create_file("fw_dbglog_config", 0600,
1622 ar->debug.debugfs_pdev, ar,
1623 &fops_fw_dbglog);
1624
1625 if (ar->hw->wiphy->bands[NL80211_BAND_5GHZ]) {
1626 debugfs_create_file("dfs_simulate_radar", 0200,
1627 ar->debug.debugfs_pdev, ar,
1628 &fops_simulate_radar);
1629 debugfs_create_bool("dfs_block_radar_events", 0200,
1630 ar->debug.debugfs_pdev,
1631 &ar->dfs_block_radar_events);
1632 }
1633
1634 if (ab->hw_params.dbr_debug_support)
1635 debugfs_create_file("enable_dbr_debug", 0200, ar->debug.debugfs_pdev,
1636 ar, &fops_dbr_debug);
1637
1638 debugfs_create_file("ps_state_enable", 0600, ar->debug.debugfs_pdev, ar,
1639 &fops_ps_state_enable);
1640
1641 if (test_bit(WMI_TLV_SERVICE_PEER_POWER_SAVE_DURATION_SUPPORT,
1642 ar->ab->wmi_ab.svc_map)) {
1643 debugfs_create_file("ps_timekeeper_enable", 0600,
1644 ar->debug.debugfs_pdev, ar,
1645 &fops_ps_timekeeper_enable);
1646
1647 debugfs_create_file("reset_ps_duration", 0200,
1648 ar->debug.debugfs_pdev, ar,
1649 &fops_reset_ps_duration);
1650 }
1651
1652 return 0;
1653 }
1654
1655 void ath11k_debugfs_unregister(struct ath11k *ar)
1656 {
1657 struct ath11k_debug_dbr *dbr_debug;
1658 struct ath11k_dbg_dbr_data *dbr_dbg_data;
1659 int i;
1660
1661 for (i = 0; i < WMI_DIRECT_BUF_MAX; i++) {
1662 dbr_debug = ar->debug.dbr_debug[i];
1663 if (!dbr_debug)
1664 continue;
1665
1666 dbr_dbg_data = &dbr_debug->dbr_dbg_data;
1667 kfree(dbr_dbg_data->entries);
1668 debugfs_remove_recursive(dbr_debug->dbr_debugfs);
1669 kfree(dbr_debug);
1670 ar->debug.dbr_debug[i] = NULL;
1671 }
1672 }
1673
1674 static ssize_t ath11k_write_twt_add_dialog(struct file *file,
1675 const char __user *ubuf,
1676 size_t count, loff_t *ppos)
1677 {
1678 struct ath11k_vif *arvif = file->private_data;
1679 struct wmi_twt_add_dialog_params params = { 0 };
1680 struct wmi_twt_enable_params twt_params = {0};
1681 struct ath11k *ar = arvif->ar;
1682 u8 buf[128] = {0};
1683 int ret;
1684
1685 if (ar->twt_enabled == 0) {
1686 ath11k_err(ar->ab, "twt support is not enabled\n");
1687 return -EOPNOTSUPP;
1688 }
1689
1690 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count);
1691 if (ret < 0)
1692 return ret;
1693
1694 buf[ret] = '\0';
1695 ret = sscanf(buf,
1696 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx %u %u %u %u %u %hhu %hhu %hhu %hhu %hhu",
1697 &params.peer_macaddr[0],
1698 &params.peer_macaddr[1],
1699 &params.peer_macaddr[2],
1700 &params.peer_macaddr[3],
1701 &params.peer_macaddr[4],
1702 &params.peer_macaddr[5],
1703 &params.dialog_id,
1704 &params.wake_intvl_us,
1705 &params.wake_intvl_mantis,
1706 &params.wake_dura_us,
1707 &params.sp_offset_us,
1708 &params.twt_cmd,
1709 &params.flag_bcast,
1710 &params.flag_trigger,
1711 &params.flag_flow_type,
1712 &params.flag_protection);
1713 if (ret != 16)
1714 return -EINVAL;
1715
1716 /* In the case of station vif, TWT is entirely handled by
1717 * the firmware based on the input parameters in the TWT enable
1718 * WMI command that is sent to the target during assoc.
1719 * For manually testing the TWT feature, we need to first disable
1720 * TWT and send enable command again with TWT input parameter
1721 * sta_cong_timer_ms set to 0.
1722 */
1723 if (arvif->vif->type == NL80211_IFTYPE_STATION) {
1724 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
1725
1726 ath11k_wmi_fill_default_twt_params(&twt_params);
1727 twt_params.sta_cong_timer_ms = 0;
1728
1729 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id, &twt_params);
1730 }
1731
1732 params.vdev_id = arvif->vdev_id;
1733
1734 ret = ath11k_wmi_send_twt_add_dialog_cmd(arvif->ar, &params);
1735 if (ret)
1736 goto err_twt_add_dialog;
1737
1738 return count;
1739
1740 err_twt_add_dialog:
1741 if (arvif->vif->type == NL80211_IFTYPE_STATION) {
1742 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
1743 ath11k_wmi_fill_default_twt_params(&twt_params);
1744 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id, &twt_params);
1745 }
1746
1747 return ret;
1748 }
1749
1750 static ssize_t ath11k_write_twt_del_dialog(struct file *file,
1751 const char __user *ubuf,
1752 size_t count, loff_t *ppos)
1753 {
1754 struct ath11k_vif *arvif = file->private_data;
1755 struct wmi_twt_del_dialog_params params = { 0 };
1756 struct wmi_twt_enable_params twt_params = {0};
1757 struct ath11k *ar = arvif->ar;
1758 u8 buf[64] = {0};
1759 int ret;
1760
1761 if (ar->twt_enabled == 0) {
1762 ath11k_err(ar->ab, "twt support is not enabled\n");
1763 return -EOPNOTSUPP;
1764 }
1765
1766 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count);
1767 if (ret < 0)
1768 return ret;
1769
1770 buf[ret] = '\0';
1771 ret = sscanf(buf, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx %u",
1772 &params.peer_macaddr[0],
1773 &params.peer_macaddr[1],
1774 &params.peer_macaddr[2],
1775 &params.peer_macaddr[3],
1776 &params.peer_macaddr[4],
1777 &params.peer_macaddr[5],
1778 &params.dialog_id);
1779 if (ret != 7)
1780 return -EINVAL;
1781
1782 params.vdev_id = arvif->vdev_id;
1783
1784 ret = ath11k_wmi_send_twt_del_dialog_cmd(arvif->ar, &params);
1785 if (ret)
1786 return ret;
1787
1788 if (arvif->vif->type == NL80211_IFTYPE_STATION) {
1789 ath11k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id);
1790 ath11k_wmi_fill_default_twt_params(&twt_params);
1791 ath11k_wmi_send_twt_enable_cmd(ar, ar->pdev->pdev_id, &twt_params);
1792 }
1793
1794 return count;
1795 }
1796
1797 static ssize_t ath11k_write_twt_pause_dialog(struct file *file,
1798 const char __user *ubuf,
1799 size_t count, loff_t *ppos)
1800 {
1801 struct ath11k_vif *arvif = file->private_data;
1802 struct wmi_twt_pause_dialog_params params = { 0 };
1803 u8 buf[64] = {0};
1804 int ret;
1805
1806 if (arvif->ar->twt_enabled == 0) {
1807 ath11k_err(arvif->ar->ab, "twt support is not enabled\n");
1808 return -EOPNOTSUPP;
1809 }
1810
1811 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count);
1812 if (ret < 0)
1813 return ret;
1814
1815 buf[ret] = '\0';
1816 ret = sscanf(buf, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx %u",
1817 &params.peer_macaddr[0],
1818 &params.peer_macaddr[1],
1819 &params.peer_macaddr[2],
1820 &params.peer_macaddr[3],
1821 &params.peer_macaddr[4],
1822 &params.peer_macaddr[5],
1823 &params.dialog_id);
1824 if (ret != 7)
1825 return -EINVAL;
1826
1827 params.vdev_id = arvif->vdev_id;
1828
1829 ret = ath11k_wmi_send_twt_pause_dialog_cmd(arvif->ar, &params);
1830 if (ret)
1831 return ret;
1832
1833 return count;
1834 }
1835
1836 static ssize_t ath11k_write_twt_resume_dialog(struct file *file,
1837 const char __user *ubuf,
1838 size_t count, loff_t *ppos)
1839 {
1840 struct ath11k_vif *arvif = file->private_data;
1841 struct wmi_twt_resume_dialog_params params = { 0 };
1842 u8 buf[64] = {0};
1843 int ret;
1844
1845 if (arvif->ar->twt_enabled == 0) {
1846 ath11k_err(arvif->ar->ab, "twt support is not enabled\n");
1847 return -EOPNOTSUPP;
1848 }
1849
1850 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count);
1851 if (ret < 0)
1852 return ret;
1853
1854 buf[ret] = '\0';
1855 ret = sscanf(buf, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx %u %u %u",
1856 &params.peer_macaddr[0],
1857 &params.peer_macaddr[1],
1858 &params.peer_macaddr[2],
1859 &params.peer_macaddr[3],
1860 &params.peer_macaddr[4],
1861 &params.peer_macaddr[5],
1862 &params.dialog_id,
1863 &params.sp_offset_us,
1864 &params.next_twt_size);
1865 if (ret != 9)
1866 return -EINVAL;
1867
1868 params.vdev_id = arvif->vdev_id;
1869
1870 ret = ath11k_wmi_send_twt_resume_dialog_cmd(arvif->ar, &params);
1871 if (ret)
1872 return ret;
1873
1874 return count;
1875 }
1876
1877 static const struct file_operations ath11k_fops_twt_add_dialog = {
1878 .write = ath11k_write_twt_add_dialog,
1879 .open = simple_open
1880 };
1881
1882 static const struct file_operations ath11k_fops_twt_del_dialog = {
1883 .write = ath11k_write_twt_del_dialog,
1884 .open = simple_open
1885 };
1886
1887 static const struct file_operations ath11k_fops_twt_pause_dialog = {
1888 .write = ath11k_write_twt_pause_dialog,
1889 .open = simple_open
1890 };
1891
1892 static const struct file_operations ath11k_fops_twt_resume_dialog = {
1893 .write = ath11k_write_twt_resume_dialog,
1894 .open = simple_open
1895 };
1896
1897 void ath11k_debugfs_op_vif_add(struct ieee80211_hw *hw,
1898 struct ieee80211_vif *vif)
1899 {
1900 struct ath11k_vif *arvif = ath11k_vif_to_arvif(vif);
1901 struct ath11k_base *ab = arvif->ar->ab;
1902 struct dentry *debugfs_twt;
1903
1904 if (arvif->vif->type != NL80211_IFTYPE_AP &&
1905 !(arvif->vif->type == NL80211_IFTYPE_STATION &&
1906 test_bit(WMI_TLV_SERVICE_STA_TWT, ab->wmi_ab.svc_map)))
1907 return;
1908
1909 debugfs_twt = debugfs_create_dir("twt",
1910 arvif->vif->debugfs_dir);
1911 debugfs_create_file("add_dialog", 0200, debugfs_twt,
1912 arvif, &ath11k_fops_twt_add_dialog);
1913
1914 debugfs_create_file("del_dialog", 0200, debugfs_twt,
1915 arvif, &ath11k_fops_twt_del_dialog);
1916
1917 debugfs_create_file("pause_dialog", 0200, debugfs_twt,
1918 arvif, &ath11k_fops_twt_pause_dialog);
1919
1920 debugfs_create_file("resume_dialog", 0200, debugfs_twt,
1921 arvif, &ath11k_fops_twt_resume_dialog);
1922 }
1923
Kernel DRM miscellaneous fixes and cross-tree changes