projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ath10k: add more wmi fw stat defines
[deliverable/linux.git] / drivers / net / wireless / ath / ath10k / debug.c
1 /*
2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include <linux/module.h>
19 #include <linux/debugfs.h>
20 #include <linux/vmalloc.h>
21 #include <linux/utsname.h>
22
23 #include "core.h"
24 #include "debug.h"
25 #include "hif.h"
26 #include "wmi-ops.h"
27
28 /* ms */
29 #define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
30
31 #define ATH10K_FW_CRASH_DUMP_VERSION 1
32
33 /**
34 * enum ath10k_fw_crash_dump_type - types of data in the dump file
35 * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
36 */
37 enum ath10k_fw_crash_dump_type {
38 ATH10K_FW_CRASH_DUMP_REGISTERS = 0,
39
40 ATH10K_FW_CRASH_DUMP_MAX,
41 };
42
43 struct ath10k_tlv_dump_data {
44 /* see ath10k_fw_crash_dump_type above */
45 __le32 type;
46
47 /* in bytes */
48 __le32 tlv_len;
49
50 /* pad to 32-bit boundaries as needed */
51 u8 tlv_data[];
52 } __packed;
53
54 struct ath10k_dump_file_data {
55 /* dump file information */
56
57 /* "ATH10K-FW-DUMP" */
58 char df_magic[16];
59
60 __le32 len;
61
62 /* file dump version */
63 __le32 version;
64
65 /* some info we can get from ath10k struct that might help */
66
67 u8 uuid[16];
68
69 __le32 chip_id;
70
71 /* 0 for now, in place for later hardware */
72 __le32 bus_type;
73
74 __le32 target_version;
75 __le32 fw_version_major;
76 __le32 fw_version_minor;
77 __le32 fw_version_release;
78 __le32 fw_version_build;
79 __le32 phy_capability;
80 __le32 hw_min_tx_power;
81 __le32 hw_max_tx_power;
82 __le32 ht_cap_info;
83 __le32 vht_cap_info;
84 __le32 num_rf_chains;
85
86 /* firmware version string */
87 char fw_ver[ETHTOOL_FWVERS_LEN];
88
89 /* Kernel related information */
90
91 /* time-of-day stamp */
92 __le64 tv_sec;
93
94 /* time-of-day stamp, nano-seconds */
95 __le64 tv_nsec;
96
97 /* LINUX_VERSION_CODE */
98 __le32 kernel_ver_code;
99
100 /* VERMAGIC_STRING */
101 char kernel_ver[64];
102
103 /* room for growth w/out changing binary format */
104 u8 unused[128];
105
106 /* struct ath10k_tlv_dump_data + more */
107 u8 data[0];
108 } __packed;
109
110 void ath10k_info(struct ath10k *ar, const char *fmt, ...)
111 {
112 struct va_format vaf = {
113 .fmt = fmt,
114 };
115 va_list args;
116
117 va_start(args, fmt);
118 vaf.va = &args;
119 dev_info(ar->dev, "%pV", &vaf);
120 trace_ath10k_log_info(ar, &vaf);
121 va_end(args);
122 }
123 EXPORT_SYMBOL(ath10k_info);
124
125 void ath10k_print_driver_info(struct ath10k *ar)
126 {
127 ath10k_info(ar, "%s (0x%08x, 0x%08x) fw %s api %d htt %d.%d wmi %d cal %s max_sta %d\n",
128 ar->hw_params.name,
129 ar->target_version,
130 ar->chip_id,
131 ar->hw->wiphy->fw_version,
132 ar->fw_api,
133 ar->htt.target_version_major,
134 ar->htt.target_version_minor,
135 ar->wmi.op_version,
136 ath10k_cal_mode_str(ar->cal_mode),
137 ar->max_num_stations);
138 ath10k_info(ar, "debug %d debugfs %d tracing %d dfs %d testmode %d\n",
139 config_enabled(CONFIG_ATH10K_DEBUG),
140 config_enabled(CONFIG_ATH10K_DEBUGFS),
141 config_enabled(CONFIG_ATH10K_TRACING),
142 config_enabled(CONFIG_ATH10K_DFS_CERTIFIED),
143 config_enabled(CONFIG_NL80211_TESTMODE));
144 }
145 EXPORT_SYMBOL(ath10k_print_driver_info);
146
147 void ath10k_err(struct ath10k *ar, const char *fmt, ...)
148 {
149 struct va_format vaf = {
150 .fmt = fmt,
151 };
152 va_list args;
153
154 va_start(args, fmt);
155 vaf.va = &args;
156 dev_err(ar->dev, "%pV", &vaf);
157 trace_ath10k_log_err(ar, &vaf);
158 va_end(args);
159 }
160 EXPORT_SYMBOL(ath10k_err);
161
162 void ath10k_warn(struct ath10k *ar, const char *fmt, ...)
163 {
164 struct va_format vaf = {
165 .fmt = fmt,
166 };
167 va_list args;
168
169 va_start(args, fmt);
170 vaf.va = &args;
171 dev_warn_ratelimited(ar->dev, "%pV", &vaf);
172 trace_ath10k_log_warn(ar, &vaf);
173
174 va_end(args);
175 }
176 EXPORT_SYMBOL(ath10k_warn);
177
178 #ifdef CONFIG_ATH10K_DEBUGFS
179
180 static ssize_t ath10k_read_wmi_services(struct file *file,
181 char __user *user_buf,
182 size_t count, loff_t *ppos)
183 {
184 struct ath10k *ar = file->private_data;
185 char *buf;
186 unsigned int len = 0, buf_len = 4096;
187 const char *name;
188 ssize_t ret_cnt;
189 bool enabled;
190 int i;
191
192 buf = kzalloc(buf_len, GFP_KERNEL);
193 if (!buf)
194 return -ENOMEM;
195
196 mutex_lock(&ar->conf_mutex);
197
198 if (len > buf_len)
199 len = buf_len;
200
201 spin_lock_bh(&ar->data_lock);
202 for (i = 0; i < WMI_SERVICE_MAX; i++) {
203 enabled = test_bit(i, ar->wmi.svc_map);
204 name = wmi_service_name(i);
205
206 if (!name) {
207 if (enabled)
208 len += scnprintf(buf + len, buf_len - len,
209 "%-40s %s (bit %d)\n",
210 "unknown", "enabled", i);
211
212 continue;
213 }
214
215 len += scnprintf(buf + len, buf_len - len,
216 "%-40s %s\n",
217 name, enabled ? "enabled" : "-");
218 }
219 spin_unlock_bh(&ar->data_lock);
220
221 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
222
223 mutex_unlock(&ar->conf_mutex);
224
225 kfree(buf);
226 return ret_cnt;
227 }
228
229 static const struct file_operations fops_wmi_services = {
230 .read = ath10k_read_wmi_services,
231 .open = simple_open,
232 .owner = THIS_MODULE,
233 .llseek = default_llseek,
234 };
235
236 static void ath10k_debug_fw_stats_pdevs_free(struct list_head *head)
237 {
238 struct ath10k_fw_stats_pdev *i, *tmp;
239
240 list_for_each_entry_safe(i, tmp, head, list) {
241 list_del(&i->list);
242 kfree(i);
243 }
244 }
245
246 static void ath10k_debug_fw_stats_vdevs_free(struct list_head *head)
247 {
248 struct ath10k_fw_stats_vdev *i, *tmp;
249
250 list_for_each_entry_safe(i, tmp, head, list) {
251 list_del(&i->list);
252 kfree(i);
253 }
254 }
255
256 static void ath10k_debug_fw_stats_peers_free(struct list_head *head)
257 {
258 struct ath10k_fw_stats_peer *i, *tmp;
259
260 list_for_each_entry_safe(i, tmp, head, list) {
261 list_del(&i->list);
262 kfree(i);
263 }
264 }
265
266 static void ath10k_debug_fw_stats_reset(struct ath10k *ar)
267 {
268 spin_lock_bh(&ar->data_lock);
269 ar->debug.fw_stats_done = false;
270 ath10k_debug_fw_stats_pdevs_free(&ar->debug.fw_stats.pdevs);
271 ath10k_debug_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
272 ath10k_debug_fw_stats_peers_free(&ar->debug.fw_stats.peers);
273 spin_unlock_bh(&ar->data_lock);
274 }
275
276 static size_t ath10k_debug_fw_stats_num_peers(struct list_head *head)
277 {
278 struct ath10k_fw_stats_peer *i;
279 size_t num = 0;
280
281 list_for_each_entry(i, head, list)
282 ++num;
283
284 return num;
285 }
286
287 static size_t ath10k_debug_fw_stats_num_vdevs(struct list_head *head)
288 {
289 struct ath10k_fw_stats_vdev *i;
290 size_t num = 0;
291
292 list_for_each_entry(i, head, list)
293 ++num;
294
295 return num;
296 }
297
298 void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
299 {
300 struct ath10k_fw_stats stats = {};
301 bool is_start, is_started, is_end;
302 size_t num_peers;
303 size_t num_vdevs;
304 int ret;
305
306 INIT_LIST_HEAD(&stats.pdevs);
307 INIT_LIST_HEAD(&stats.vdevs);
308 INIT_LIST_HEAD(&stats.peers);
309
310 spin_lock_bh(&ar->data_lock);
311 ret = ath10k_wmi_pull_fw_stats(ar, skb, &stats);
312 if (ret) {
313 ath10k_warn(ar, "failed to pull fw stats: %d\n", ret);
314 goto unlock;
315 }
316
317 /* Stat data may exceed htc-wmi buffer limit. In such case firmware
318 * splits the stats data and delivers it in a ping-pong fashion of
319 * request cmd-update event.
320 *
321 * However there is no explicit end-of-data. Instead start-of-data is
322 * used as an implicit one. This works as follows:
323 * a) discard stat update events until one with pdev stats is
324 * delivered - this skips session started at end of (b)
325 * b) consume stat update events until another one with pdev stats is
326 * delivered which is treated as end-of-data and is itself discarded
327 */
328
329 if (ar->debug.fw_stats_done) {
330 ath10k_warn(ar, "received unsolicited stats update event\n");
331 goto free;
332 }
333
334 num_peers = ath10k_debug_fw_stats_num_peers(&ar->debug.fw_stats.peers);
335 num_vdevs = ath10k_debug_fw_stats_num_vdevs(&ar->debug.fw_stats.vdevs);
336 is_start = (list_empty(&ar->debug.fw_stats.pdevs) &&
337 !list_empty(&stats.pdevs));
338 is_end = (!list_empty(&ar->debug.fw_stats.pdevs) &&
339 !list_empty(&stats.pdevs));
340
341 if (is_start)
342 list_splice_tail_init(&stats.pdevs, &ar->debug.fw_stats.pdevs);
343
344 if (is_end)
345 ar->debug.fw_stats_done = true;
346
347 is_started = !list_empty(&ar->debug.fw_stats.pdevs);
348
349 if (is_started && !is_end) {
350 if (num_peers >= ATH10K_MAX_NUM_PEER_IDS) {
351 /* Although this is unlikely impose a sane limit to
352 * prevent firmware from DoS-ing the host.
353 */
354 ath10k_warn(ar, "dropping fw peer stats\n");
355 goto free;
356 }
357
358 if (num_vdevs >= BITS_PER_LONG) {
359 ath10k_warn(ar, "dropping fw vdev stats\n");
360 goto free;
361 }
362
363 list_splice_tail_init(&stats.peers, &ar->debug.fw_stats.peers);
364 list_splice_tail_init(&stats.vdevs, &ar->debug.fw_stats.vdevs);
365 }
366
367 complete(&ar->debug.fw_stats_complete);
368
369 free:
370 /* In some cases lists have been spliced and cleared. Free up
371 * resources if that is not the case.
372 */
373 ath10k_debug_fw_stats_pdevs_free(&stats.pdevs);
374 ath10k_debug_fw_stats_vdevs_free(&stats.vdevs);
375 ath10k_debug_fw_stats_peers_free(&stats.peers);
376
377 unlock:
378 spin_unlock_bh(&ar->data_lock);
379 }
380
381 static int ath10k_debug_fw_stats_request(struct ath10k *ar)
382 {
383 unsigned long timeout;
384 int ret;
385
386 lockdep_assert_held(&ar->conf_mutex);
387
388 timeout = jiffies + msecs_to_jiffies(1*HZ);
389
390 ath10k_debug_fw_stats_reset(ar);
391
392 for (;;) {
393 if (time_after(jiffies, timeout))
394 return -ETIMEDOUT;
395
396 reinit_completion(&ar->debug.fw_stats_complete);
397
398 ret = ath10k_wmi_request_stats(ar, WMI_STAT_PEER);
399 if (ret) {
400 ath10k_warn(ar, "could not request stats (%d)\n", ret);
401 return ret;
402 }
403
404 ret = wait_for_completion_timeout(&ar->debug.fw_stats_complete,
405 1*HZ);
406 if (ret == 0)
407 return -ETIMEDOUT;
408
409 spin_lock_bh(&ar->data_lock);
410 if (ar->debug.fw_stats_done) {
411 spin_unlock_bh(&ar->data_lock);
412 break;
413 }
414 spin_unlock_bh(&ar->data_lock);
415 }
416
417 return 0;
418 }
419
420 /* FIXME: How to calculate the buffer size sanely? */
421 #define ATH10K_FW_STATS_BUF_SIZE (1024*1024)
422
423 static void ath10k_fw_stats_fill(struct ath10k *ar,
424 struct ath10k_fw_stats *fw_stats,
425 char *buf)
426 {
427 unsigned int len = 0;
428 unsigned int buf_len = ATH10K_FW_STATS_BUF_SIZE;
429 const struct ath10k_fw_stats_pdev *pdev;
430 const struct ath10k_fw_stats_vdev *vdev;
431 const struct ath10k_fw_stats_peer *peer;
432 size_t num_peers;
433 size_t num_vdevs;
434 int i;
435
436 spin_lock_bh(&ar->data_lock);
437
438 pdev = list_first_entry_or_null(&fw_stats->pdevs,
439 struct ath10k_fw_stats_pdev, list);
440 if (!pdev) {
441 ath10k_warn(ar, "failed to get pdev stats\n");
442 goto unlock;
443 }
444
445 num_peers = ath10k_debug_fw_stats_num_peers(&fw_stats->peers);
446 num_vdevs = ath10k_debug_fw_stats_num_vdevs(&fw_stats->vdevs);
447
448 len += scnprintf(buf + len, buf_len - len, "\n");
449 len += scnprintf(buf + len, buf_len - len, "%30s\n",
450 "ath10k PDEV stats");
451 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
452 "=================");
453
454 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
455 "Channel noise floor", pdev->ch_noise_floor);
456 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
457 "Channel TX power", pdev->chan_tx_power);
458 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
459 "TX frame count", pdev->tx_frame_count);
460 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
461 "RX frame count", pdev->rx_frame_count);
462 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
463 "RX clear count", pdev->rx_clear_count);
464 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
465 "Cycle count", pdev->cycle_count);
466 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
467 "PHY error count", pdev->phy_err_count);
468 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
469 "RTS bad count", pdev->rts_bad);
470 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
471 "RTS good count", pdev->rts_good);
472 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
473 "FCS bad count", pdev->fcs_bad);
474 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
475 "No beacon count", pdev->no_beacons);
476 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
477 "MIB int count", pdev->mib_int_count);
478
479 len += scnprintf(buf + len, buf_len - len, "\n");
480 len += scnprintf(buf + len, buf_len - len, "%30s\n",
481 "ath10k PDEV TX stats");
482 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
483 "=================");
484
485 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
486 "HTT cookies queued", pdev->comp_queued);
487 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
488 "HTT cookies disp.", pdev->comp_delivered);
489 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
490 "MSDU queued", pdev->msdu_enqued);
491 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
492 "MPDU queued", pdev->mpdu_enqued);
493 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
494 "MSDUs dropped", pdev->wmm_drop);
495 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
496 "Local enqued", pdev->local_enqued);
497 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
498 "Local freed", pdev->local_freed);
499 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
500 "HW queued", pdev->hw_queued);
501 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
502 "PPDUs reaped", pdev->hw_reaped);
503 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
504 "Num underruns", pdev->underrun);
505 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
506 "PPDUs cleaned", pdev->tx_abort);
507 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
508 "MPDUs requed", pdev->mpdus_requed);
509 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
510 "Excessive retries", pdev->tx_ko);
511 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
512 "HW rate", pdev->data_rc);
513 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
514 "Sched self tiggers", pdev->self_triggers);
515 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
516 "Dropped due to SW retries",
517 pdev->sw_retry_failure);
518 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
519 "Illegal rate phy errors",
520 pdev->illgl_rate_phy_err);
521 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
522 "Pdev continous xretry", pdev->pdev_cont_xretry);
523 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
524 "TX timeout", pdev->pdev_tx_timeout);
525 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
526 "PDEV resets", pdev->pdev_resets);
527 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
528 "PHY underrun", pdev->phy_underrun);
529 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
530 "MPDU is more than txop limit", pdev->txop_ovf);
531
532 len += scnprintf(buf + len, buf_len - len, "\n");
533 len += scnprintf(buf + len, buf_len - len, "%30s\n",
534 "ath10k PDEV RX stats");
535 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
536 "=================");
537
538 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
539 "Mid PPDU route change",
540 pdev->mid_ppdu_route_change);
541 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
542 "Tot. number of statuses", pdev->status_rcvd);
543 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
544 "Extra frags on rings 0", pdev->r0_frags);
545 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
546 "Extra frags on rings 1", pdev->r1_frags);
547 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
548 "Extra frags on rings 2", pdev->r2_frags);
549 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
550 "Extra frags on rings 3", pdev->r3_frags);
551 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
552 "MSDUs delivered to HTT", pdev->htt_msdus);
553 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
554 "MPDUs delivered to HTT", pdev->htt_mpdus);
555 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
556 "MSDUs delivered to stack", pdev->loc_msdus);
557 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
558 "MPDUs delivered to stack", pdev->loc_mpdus);
559 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
560 "Oversized AMSUs", pdev->oversize_amsdu);
561 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
562 "PHY errors", pdev->phy_errs);
563 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
564 "PHY errors drops", pdev->phy_err_drop);
565 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
566 "MPDU errors (FCS, MIC, ENC)", pdev->mpdu_errs);
567
568 len += scnprintf(buf + len, buf_len - len, "\n");
569 len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
570 "ath10k VDEV stats", num_vdevs);
571 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
572 "=================");
573
574 list_for_each_entry(vdev, &fw_stats->vdevs, list) {
575 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
576 "vdev id", vdev->vdev_id);
577 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
578 "beacon snr", vdev->beacon_snr);
579 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
580 "data snr", vdev->data_snr);
581 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
582 "num rx frames", vdev->num_rx_frames);
583 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
584 "num rts fail", vdev->num_rts_fail);
585 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
586 "num rts success", vdev->num_rts_success);
587 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
588 "num rx err", vdev->num_rx_err);
589 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
590 "num rx discard", vdev->num_rx_discard);
591 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
592 "num tx not acked", vdev->num_tx_not_acked);
593
594 for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames); i++)
595 len += scnprintf(buf + len, buf_len - len,
596 "%25s [%02d] %u\n",
597 "num tx frames", i,
598 vdev->num_tx_frames[i]);
599
600 for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_retries); i++)
601 len += scnprintf(buf + len, buf_len - len,
602 "%25s [%02d] %u\n",
603 "num tx frames retries", i,
604 vdev->num_tx_frames_retries[i]);
605
606 for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_failures); i++)
607 len += scnprintf(buf + len, buf_len - len,
608 "%25s [%02d] %u\n",
609 "num tx frames failures", i,
610 vdev->num_tx_frames_failures[i]);
611
612 for (i = 0 ; i < ARRAY_SIZE(vdev->tx_rate_history); i++)
613 len += scnprintf(buf + len, buf_len - len,
614 "%25s [%02d] 0x%08x\n",
615 "tx rate history", i,
616 vdev->tx_rate_history[i]);
617
618 for (i = 0 ; i < ARRAY_SIZE(vdev->beacon_rssi_history); i++)
619 len += scnprintf(buf + len, buf_len - len,
620 "%25s [%02d] %u\n",
621 "beacon rssi history", i,
622 vdev->beacon_rssi_history[i]);
623
624 len += scnprintf(buf + len, buf_len - len, "\n");
625 }
626
627 len += scnprintf(buf + len, buf_len - len, "\n");
628 len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
629 "ath10k PEER stats", num_peers);
630 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
631 "=================");
632
633 list_for_each_entry(peer, &fw_stats->peers, list) {
634 len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
635 "Peer MAC address", peer->peer_macaddr);
636 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
637 "Peer RSSI", peer->peer_rssi);
638 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
639 "Peer TX rate", peer->peer_tx_rate);
640 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
641 "Peer RX rate", peer->peer_rx_rate);
642 len += scnprintf(buf + len, buf_len - len, "\n");
643 }
644
645 unlock:
646 spin_unlock_bh(&ar->data_lock);
647
648 if (len >= buf_len)
649 buf[len - 1] = 0;
650 else
651 buf[len] = 0;
652 }
653
654 static int ath10k_fw_stats_open(struct inode *inode, struct file *file)
655 {
656 struct ath10k *ar = inode->i_private;
657 void *buf = NULL;
658 int ret;
659
660 mutex_lock(&ar->conf_mutex);
661
662 if (ar->state != ATH10K_STATE_ON) {
663 ret = -ENETDOWN;
664 goto err_unlock;
665 }
666
667 buf = vmalloc(ATH10K_FW_STATS_BUF_SIZE);
668 if (!buf) {
669 ret = -ENOMEM;
670 goto err_unlock;
671 }
672
673 ret = ath10k_debug_fw_stats_request(ar);
674 if (ret) {
675 ath10k_warn(ar, "failed to request fw stats: %d\n", ret);
676 goto err_free;
677 }
678
679 ath10k_fw_stats_fill(ar, &ar->debug.fw_stats, buf);
680 file->private_data = buf;
681
682 mutex_unlock(&ar->conf_mutex);
683 return 0;
684
685 err_free:
686 vfree(buf);
687
688 err_unlock:
689 mutex_unlock(&ar->conf_mutex);
690 return ret;
691 }
692
693 static int ath10k_fw_stats_release(struct inode *inode, struct file *file)
694 {
695 vfree(file->private_data);
696
697 return 0;
698 }
699
700 static ssize_t ath10k_fw_stats_read(struct file *file, char __user *user_buf,
701 size_t count, loff_t *ppos)
702 {
703 const char *buf = file->private_data;
704 unsigned int len = strlen(buf);
705
706 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
707 }
708
709 static const struct file_operations fops_fw_stats = {
710 .open = ath10k_fw_stats_open,
711 .release = ath10k_fw_stats_release,
712 .read = ath10k_fw_stats_read,
713 .owner = THIS_MODULE,
714 .llseek = default_llseek,
715 };
716
717 static ssize_t ath10k_debug_fw_reset_stats_read(struct file *file,
718 char __user *user_buf,
719 size_t count, loff_t *ppos)
720 {
721 struct ath10k *ar = file->private_data;
722 int ret, len, buf_len;
723 char *buf;
724
725 buf_len = 500;
726 buf = kmalloc(buf_len, GFP_KERNEL);
727 if (!buf)
728 return -ENOMEM;
729
730 spin_lock_bh(&ar->data_lock);
731
732 len = 0;
733 len += scnprintf(buf + len, buf_len - len,
734 "fw_crash_counter\t\t%d\n", ar->stats.fw_crash_counter);
735 len += scnprintf(buf + len, buf_len - len,
736 "fw_warm_reset_counter\t\t%d\n",
737 ar->stats.fw_warm_reset_counter);
738 len += scnprintf(buf + len, buf_len - len,
739 "fw_cold_reset_counter\t\t%d\n",
740 ar->stats.fw_cold_reset_counter);
741
742 spin_unlock_bh(&ar->data_lock);
743
744 ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
745
746 kfree(buf);
747
748 return ret;
749 }
750
751 static const struct file_operations fops_fw_reset_stats = {
752 .open = simple_open,
753 .read = ath10k_debug_fw_reset_stats_read,
754 .owner = THIS_MODULE,
755 .llseek = default_llseek,
756 };
757
758 /* This is a clean assert crash in firmware. */
759 static int ath10k_debug_fw_assert(struct ath10k *ar)
760 {
761 struct wmi_vdev_install_key_cmd *cmd;
762 struct sk_buff *skb;
763
764 skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd) + 16);
765 if (!skb)
766 return -ENOMEM;
767
768 cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
769 memset(cmd, 0, sizeof(*cmd));
770
771 /* big enough number so that firmware asserts */
772 cmd->vdev_id = __cpu_to_le32(0x7ffe);
773
774 return ath10k_wmi_cmd_send(ar, skb,
775 ar->wmi.cmd->vdev_install_key_cmdid);
776 }
777
778 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
779 char __user *user_buf,
780 size_t count, loff_t *ppos)
781 {
782 const char buf[] =
783 "To simulate firmware crash write one of the keywords to this file:\n"
784 "`soft` - this will send WMI_FORCE_FW_HANG_ASSERT to firmware if FW supports that command.\n"
785 "`hard` - this will send to firmware command with illegal parameters causing firmware crash.\n"
786 "`assert` - this will send special illegal parameter to firmware to cause assert failure and crash.\n"
787 "`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n";
788
789 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
790 }
791
792 /* Simulate firmware crash:
793 * 'soft': Call wmi command causing firmware hang. This firmware hang is
794 * recoverable by warm firmware reset.
795 * 'hard': Force firmware crash by setting any vdev parameter for not allowed
796 * vdev id. This is hard firmware crash because it is recoverable only by cold
797 * firmware reset.
798 */
799 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
800 const char __user *user_buf,
801 size_t count, loff_t *ppos)
802 {
803 struct ath10k *ar = file->private_data;
804 char buf[32];
805 int ret;
806
807 mutex_lock(&ar->conf_mutex);
808
809 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
810
811 /* make sure that buf is null terminated */
812 buf[sizeof(buf) - 1] = 0;
813
814 if (ar->state != ATH10K_STATE_ON &&
815 ar->state != ATH10K_STATE_RESTARTED) {
816 ret = -ENETDOWN;
817 goto exit;
818 }
819
820 /* drop the possible '\n' from the end */
821 if (buf[count - 1] == '\n') {
822 buf[count - 1] = 0;
823 count--;
824 }
825
826 if (!strcmp(buf, "soft")) {
827 ath10k_info(ar, "simulating soft firmware crash\n");
828 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
829 } else if (!strcmp(buf, "hard")) {
830 ath10k_info(ar, "simulating hard firmware crash\n");
831 /* 0x7fff is vdev id, and it is always out of range for all
832 * firmware variants in order to force a firmware crash.
833 */
834 ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
835 ar->wmi.vdev_param->rts_threshold,
836 0);
837 } else if (!strcmp(buf, "assert")) {
838 ath10k_info(ar, "simulating firmware assert crash\n");
839 ret = ath10k_debug_fw_assert(ar);
840 } else if (!strcmp(buf, "hw-restart")) {
841 ath10k_info(ar, "user requested hw restart\n");
842 queue_work(ar->workqueue, &ar->restart_work);
843 ret = 0;
844 } else {
845 ret = -EINVAL;
846 goto exit;
847 }
848
849 if (ret) {
850 ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
851 goto exit;
852 }
853
854 ret = count;
855
856 exit:
857 mutex_unlock(&ar->conf_mutex);
858 return ret;
859 }
860
861 static const struct file_operations fops_simulate_fw_crash = {
862 .read = ath10k_read_simulate_fw_crash,
863 .write = ath10k_write_simulate_fw_crash,
864 .open = simple_open,
865 .owner = THIS_MODULE,
866 .llseek = default_llseek,
867 };
868
869 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
870 size_t count, loff_t *ppos)
871 {
872 struct ath10k *ar = file->private_data;
873 unsigned int len;
874 char buf[50];
875
876 len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->chip_id);
877
878 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
879 }
880
881 static const struct file_operations fops_chip_id = {
882 .read = ath10k_read_chip_id,
883 .open = simple_open,
884 .owner = THIS_MODULE,
885 .llseek = default_llseek,
886 };
887
888 struct ath10k_fw_crash_data *
889 ath10k_debug_get_new_fw_crash_data(struct ath10k *ar)
890 {
891 struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
892
893 lockdep_assert_held(&ar->data_lock);
894
895 crash_data->crashed_since_read = true;
896 uuid_le_gen(&crash_data->uuid);
897 getnstimeofday(&crash_data->timestamp);
898
899 return crash_data;
900 }
901 EXPORT_SYMBOL(ath10k_debug_get_new_fw_crash_data);
902
903 static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
904 {
905 struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
906 struct ath10k_dump_file_data *dump_data;
907 struct ath10k_tlv_dump_data *dump_tlv;
908 int hdr_len = sizeof(*dump_data);
909 unsigned int len, sofar = 0;
910 unsigned char *buf;
911
912 len = hdr_len;
913 len += sizeof(*dump_tlv) + sizeof(crash_data->registers);
914
915 sofar += hdr_len;
916
917 /* This is going to get big when we start dumping FW RAM and such,
918 * so go ahead and use vmalloc.
919 */
920 buf = vzalloc(len);
921 if (!buf)
922 return NULL;
923
924 spin_lock_bh(&ar->data_lock);
925
926 if (!crash_data->crashed_since_read) {
927 spin_unlock_bh(&ar->data_lock);
928 vfree(buf);
929 return NULL;
930 }
931
932 dump_data = (struct ath10k_dump_file_data *)(buf);
933 strlcpy(dump_data->df_magic, "ATH10K-FW-DUMP",
934 sizeof(dump_data->df_magic));
935 dump_data->len = cpu_to_le32(len);
936
937 dump_data->version = cpu_to_le32(ATH10K_FW_CRASH_DUMP_VERSION);
938
939 memcpy(dump_data->uuid, &crash_data->uuid, sizeof(dump_data->uuid));
940 dump_data->chip_id = cpu_to_le32(ar->chip_id);
941 dump_data->bus_type = cpu_to_le32(0);
942 dump_data->target_version = cpu_to_le32(ar->target_version);
943 dump_data->fw_version_major = cpu_to_le32(ar->fw_version_major);
944 dump_data->fw_version_minor = cpu_to_le32(ar->fw_version_minor);
945 dump_data->fw_version_release = cpu_to_le32(ar->fw_version_release);
946 dump_data->fw_version_build = cpu_to_le32(ar->fw_version_build);
947 dump_data->phy_capability = cpu_to_le32(ar->phy_capability);
948 dump_data->hw_min_tx_power = cpu_to_le32(ar->hw_min_tx_power);
949 dump_data->hw_max_tx_power = cpu_to_le32(ar->hw_max_tx_power);
950 dump_data->ht_cap_info = cpu_to_le32(ar->ht_cap_info);
951 dump_data->vht_cap_info = cpu_to_le32(ar->vht_cap_info);
952 dump_data->num_rf_chains = cpu_to_le32(ar->num_rf_chains);
953
954 strlcpy(dump_data->fw_ver, ar->hw->wiphy->fw_version,
955 sizeof(dump_data->fw_ver));
956
957 dump_data->kernel_ver_code = 0;
958 strlcpy(dump_data->kernel_ver, init_utsname()->release,
959 sizeof(dump_data->kernel_ver));
960
961 dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
962 dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
963
964 /* Gather crash-dump */
965 dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
966 dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGISTERS);
967 dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->registers));
968 memcpy(dump_tlv->tlv_data, &crash_data->registers,
969 sizeof(crash_data->registers));
970 sofar += sizeof(*dump_tlv) + sizeof(crash_data->registers);
971
972 ar->debug.fw_crash_data->crashed_since_read = false;
973
974 spin_unlock_bh(&ar->data_lock);
975
976 return dump_data;
977 }
978
979 static int ath10k_fw_crash_dump_open(struct inode *inode, struct file *file)
980 {
981 struct ath10k *ar = inode->i_private;
982 struct ath10k_dump_file_data *dump;
983
984 dump = ath10k_build_dump_file(ar);
985 if (!dump)
986 return -ENODATA;
987
988 file->private_data = dump;
989
990 return 0;
991 }
992
993 static ssize_t ath10k_fw_crash_dump_read(struct file *file,
994 char __user *user_buf,
995 size_t count, loff_t *ppos)
996 {
997 struct ath10k_dump_file_data *dump_file = file->private_data;
998
999 return simple_read_from_buffer(user_buf, count, ppos,
1000 dump_file,
1001 le32_to_cpu(dump_file->len));
1002 }
1003
1004 static int ath10k_fw_crash_dump_release(struct inode *inode,
1005 struct file *file)
1006 {
1007 vfree(file->private_data);
1008
1009 return 0;
1010 }
1011
1012 static const struct file_operations fops_fw_crash_dump = {
1013 .open = ath10k_fw_crash_dump_open,
1014 .read = ath10k_fw_crash_dump_read,
1015 .release = ath10k_fw_crash_dump_release,
1016 .owner = THIS_MODULE,
1017 .llseek = default_llseek,
1018 };
1019
1020 static ssize_t ath10k_reg_addr_read(struct file *file,
1021 char __user *user_buf,
1022 size_t count, loff_t *ppos)
1023 {
1024 struct ath10k *ar = file->private_data;
1025 u8 buf[32];
1026 unsigned int len = 0;
1027 u32 reg_addr;
1028
1029 mutex_lock(&ar->conf_mutex);
1030 reg_addr = ar->debug.reg_addr;
1031 mutex_unlock(&ar->conf_mutex);
1032
1033 len += scnprintf(buf + len, sizeof(buf) - len, "0x%x\n", reg_addr);
1034
1035 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1036 }
1037
1038 static ssize_t ath10k_reg_addr_write(struct file *file,
1039 const char __user *user_buf,
1040 size_t count, loff_t *ppos)
1041 {
1042 struct ath10k *ar = file->private_data;
1043 u32 reg_addr;
1044 int ret;
1045
1046 ret = kstrtou32_from_user(user_buf, count, 0, &reg_addr);
1047 if (ret)
1048 return ret;
1049
1050 if (!IS_ALIGNED(reg_addr, 4))
1051 return -EFAULT;
1052
1053 mutex_lock(&ar->conf_mutex);
1054 ar->debug.reg_addr = reg_addr;
1055 mutex_unlock(&ar->conf_mutex);
1056
1057 return count;
1058 }
1059
1060 static const struct file_operations fops_reg_addr = {
1061 .read = ath10k_reg_addr_read,
1062 .write = ath10k_reg_addr_write,
1063 .open = simple_open,
1064 .owner = THIS_MODULE,
1065 .llseek = default_llseek,
1066 };
1067
1068 static ssize_t ath10k_reg_value_read(struct file *file,
1069 char __user *user_buf,
1070 size_t count, loff_t *ppos)
1071 {
1072 struct ath10k *ar = file->private_data;
1073 u8 buf[48];
1074 unsigned int len;
1075 u32 reg_addr, reg_val;
1076 int ret;
1077
1078 mutex_lock(&ar->conf_mutex);
1079
1080 if (ar->state != ATH10K_STATE_ON &&
1081 ar->state != ATH10K_STATE_UTF) {
1082 ret = -ENETDOWN;
1083 goto exit;
1084 }
1085
1086 reg_addr = ar->debug.reg_addr;
1087
1088 reg_val = ath10k_hif_read32(ar, reg_addr);
1089 len = scnprintf(buf, sizeof(buf), "0x%08x:0x%08x\n", reg_addr, reg_val);
1090
1091 ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1092
1093 exit:
1094 mutex_unlock(&ar->conf_mutex);
1095
1096 return ret;
1097 }
1098
1099 static ssize_t ath10k_reg_value_write(struct file *file,
1100 const char __user *user_buf,
1101 size_t count, loff_t *ppos)
1102 {
1103 struct ath10k *ar = file->private_data;
1104 u32 reg_addr, reg_val;
1105 int ret;
1106
1107 mutex_lock(&ar->conf_mutex);
1108
1109 if (ar->state != ATH10K_STATE_ON &&
1110 ar->state != ATH10K_STATE_UTF) {
1111 ret = -ENETDOWN;
1112 goto exit;
1113 }
1114
1115 reg_addr = ar->debug.reg_addr;
1116
1117 ret = kstrtou32_from_user(user_buf, count, 0, &reg_val);
1118 if (ret)
1119 goto exit;
1120
1121 ath10k_hif_write32(ar, reg_addr, reg_val);
1122
1123 ret = count;
1124
1125 exit:
1126 mutex_unlock(&ar->conf_mutex);
1127
1128 return ret;
1129 }
1130
1131 static const struct file_operations fops_reg_value = {
1132 .read = ath10k_reg_value_read,
1133 .write = ath10k_reg_value_write,
1134 .open = simple_open,
1135 .owner = THIS_MODULE,
1136 .llseek = default_llseek,
1137 };
1138
1139 static ssize_t ath10k_mem_value_read(struct file *file,
1140 char __user *user_buf,
1141 size_t count, loff_t *ppos)
1142 {
1143 struct ath10k *ar = file->private_data;
1144 u8 *buf;
1145 int ret;
1146
1147 if (*ppos < 0)
1148 return -EINVAL;
1149
1150 if (!count)
1151 return 0;
1152
1153 mutex_lock(&ar->conf_mutex);
1154
1155 buf = vmalloc(count);
1156 if (!buf) {
1157 ret = -ENOMEM;
1158 goto exit;
1159 }
1160
1161 if (ar->state != ATH10K_STATE_ON &&
1162 ar->state != ATH10K_STATE_UTF) {
1163 ret = -ENETDOWN;
1164 goto exit;
1165 }
1166
1167 ret = ath10k_hif_diag_read(ar, *ppos, buf, count);
1168 if (ret) {
1169 ath10k_warn(ar, "failed to read address 0x%08x via diagnose window fnrom debugfs: %d\n",
1170 (u32)(*ppos), ret);
1171 goto exit;
1172 }
1173
1174 ret = copy_to_user(user_buf, buf, count);
1175 if (ret) {
1176 ret = -EFAULT;
1177 goto exit;
1178 }
1179
1180 count -= ret;
1181 *ppos += count;
1182 ret = count;
1183
1184 exit:
1185 vfree(buf);
1186 mutex_unlock(&ar->conf_mutex);
1187
1188 return ret;
1189 }
1190
1191 static ssize_t ath10k_mem_value_write(struct file *file,
1192 const char __user *user_buf,
1193 size_t count, loff_t *ppos)
1194 {
1195 struct ath10k *ar = file->private_data;
1196 u8 *buf;
1197 int ret;
1198
1199 if (*ppos < 0)
1200 return -EINVAL;
1201
1202 if (!count)
1203 return 0;
1204
1205 mutex_lock(&ar->conf_mutex);
1206
1207 buf = vmalloc(count);
1208 if (!buf) {
1209 ret = -ENOMEM;
1210 goto exit;
1211 }
1212
1213 if (ar->state != ATH10K_STATE_ON &&
1214 ar->state != ATH10K_STATE_UTF) {
1215 ret = -ENETDOWN;
1216 goto exit;
1217 }
1218
1219 ret = copy_from_user(buf, user_buf, count);
1220 if (ret) {
1221 ret = -EFAULT;
1222 goto exit;
1223 }
1224
1225 ret = ath10k_hif_diag_write(ar, *ppos, buf, count);
1226 if (ret) {
1227 ath10k_warn(ar, "failed to write address 0x%08x via diagnose window from debugfs: %d\n",
1228 (u32)(*ppos), ret);
1229 goto exit;
1230 }
1231
1232 *ppos += count;
1233 ret = count;
1234
1235 exit:
1236 vfree(buf);
1237 mutex_unlock(&ar->conf_mutex);
1238
1239 return ret;
1240 }
1241
1242 static const struct file_operations fops_mem_value = {
1243 .read = ath10k_mem_value_read,
1244 .write = ath10k_mem_value_write,
1245 .open = simple_open,
1246 .owner = THIS_MODULE,
1247 .llseek = default_llseek,
1248 };
1249
1250 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
1251 {
1252 u64 cookie;
1253 int ret;
1254
1255 lockdep_assert_held(&ar->conf_mutex);
1256
1257 if (ar->debug.htt_stats_mask == 0)
1258 /* htt stats are disabled */
1259 return 0;
1260
1261 if (ar->state != ATH10K_STATE_ON)
1262 return 0;
1263
1264 cookie = get_jiffies_64();
1265
1266 ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
1267 cookie);
1268 if (ret) {
1269 ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
1270 return ret;
1271 }
1272
1273 queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
1274 msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
1275
1276 return 0;
1277 }
1278
1279 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
1280 {
1281 struct ath10k *ar = container_of(work, struct ath10k,
1282 debug.htt_stats_dwork.work);
1283
1284 mutex_lock(&ar->conf_mutex);
1285
1286 ath10k_debug_htt_stats_req(ar);
1287
1288 mutex_unlock(&ar->conf_mutex);
1289 }
1290
1291 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
1292 char __user *user_buf,
1293 size_t count, loff_t *ppos)
1294 {
1295 struct ath10k *ar = file->private_data;
1296 char buf[32];
1297 unsigned int len;
1298
1299 len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
1300
1301 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1302 }
1303
1304 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
1305 const char __user *user_buf,
1306 size_t count, loff_t *ppos)
1307 {
1308 struct ath10k *ar = file->private_data;
1309 unsigned long mask;
1310 int ret;
1311
1312 ret = kstrtoul_from_user(user_buf, count, 0, &mask);
1313 if (ret)
1314 return ret;
1315
1316 /* max 8 bit masks (for now) */
1317 if (mask > 0xff)
1318 return -E2BIG;
1319
1320 mutex_lock(&ar->conf_mutex);
1321
1322 ar->debug.htt_stats_mask = mask;
1323
1324 ret = ath10k_debug_htt_stats_req(ar);
1325 if (ret)
1326 goto out;
1327
1328 ret = count;
1329
1330 out:
1331 mutex_unlock(&ar->conf_mutex);
1332
1333 return ret;
1334 }
1335
1336 static const struct file_operations fops_htt_stats_mask = {
1337 .read = ath10k_read_htt_stats_mask,
1338 .write = ath10k_write_htt_stats_mask,
1339 .open = simple_open,
1340 .owner = THIS_MODULE,
1341 .llseek = default_llseek,
1342 };
1343
1344 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
1345 char __user *user_buf,
1346 size_t count, loff_t *ppos)
1347 {
1348 struct ath10k *ar = file->private_data;
1349 char buf[64];
1350 u8 amsdu = 3, ampdu = 64;
1351 unsigned int len;
1352
1353 mutex_lock(&ar->conf_mutex);
1354
1355 if (ar->debug.htt_max_amsdu)
1356 amsdu = ar->debug.htt_max_amsdu;
1357
1358 if (ar->debug.htt_max_ampdu)
1359 ampdu = ar->debug.htt_max_ampdu;
1360
1361 mutex_unlock(&ar->conf_mutex);
1362
1363 len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
1364
1365 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1366 }
1367
1368 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
1369 const char __user *user_buf,
1370 size_t count, loff_t *ppos)
1371 {
1372 struct ath10k *ar = file->private_data;
1373 int res;
1374 char buf[64];
1375 unsigned int amsdu, ampdu;
1376
1377 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
1378
1379 /* make sure that buf is null terminated */
1380 buf[sizeof(buf) - 1] = 0;
1381
1382 res = sscanf(buf, "%u %u", &amsdu, &ampdu);
1383
1384 if (res != 2)
1385 return -EINVAL;
1386
1387 mutex_lock(&ar->conf_mutex);
1388
1389 res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
1390 if (res)
1391 goto out;
1392
1393 res = count;
1394 ar->debug.htt_max_amsdu = amsdu;
1395 ar->debug.htt_max_ampdu = ampdu;
1396
1397 out:
1398 mutex_unlock(&ar->conf_mutex);
1399 return res;
1400 }
1401
1402 static const struct file_operations fops_htt_max_amsdu_ampdu = {
1403 .read = ath10k_read_htt_max_amsdu_ampdu,
1404 .write = ath10k_write_htt_max_amsdu_ampdu,
1405 .open = simple_open,
1406 .owner = THIS_MODULE,
1407 .llseek = default_llseek,
1408 };
1409
1410 static ssize_t ath10k_read_fw_dbglog(struct file *file,
1411 char __user *user_buf,
1412 size_t count, loff_t *ppos)
1413 {
1414 struct ath10k *ar = file->private_data;
1415 unsigned int len;
1416 char buf[64];
1417
1418 len = scnprintf(buf, sizeof(buf), "0x%08x %u\n",
1419 ar->debug.fw_dbglog_mask, ar->debug.fw_dbglog_level);
1420
1421 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1422 }
1423
1424 static ssize_t ath10k_write_fw_dbglog(struct file *file,
1425 const char __user *user_buf,
1426 size_t count, loff_t *ppos)
1427 {
1428 struct ath10k *ar = file->private_data;
1429 int ret;
1430 char buf[64];
1431 unsigned int log_level, mask;
1432
1433 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
1434
1435 /* make sure that buf is null terminated */
1436 buf[sizeof(buf) - 1] = 0;
1437
1438 ret = sscanf(buf, "%x %u", &mask, &log_level);
1439
1440 if (!ret)
1441 return -EINVAL;
1442
1443 if (ret == 1)
1444 /* default if user did not specify */
1445 log_level = ATH10K_DBGLOG_LEVEL_WARN;
1446
1447 mutex_lock(&ar->conf_mutex);
1448
1449 ar->debug.fw_dbglog_mask = mask;
1450 ar->debug.fw_dbglog_level = log_level;
1451
1452 if (ar->state == ATH10K_STATE_ON) {
1453 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1454 ar->debug.fw_dbglog_level);
1455 if (ret) {
1456 ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1457 ret);
1458 goto exit;
1459 }
1460 }
1461
1462 ret = count;
1463
1464 exit:
1465 mutex_unlock(&ar->conf_mutex);
1466
1467 return ret;
1468 }
1469
1470 /* TODO: Would be nice to always support ethtool stats, would need to
1471 * move the stats storage out of ath10k_debug, or always have ath10k_debug
1472 * struct available..
1473 */
1474
1475 /* This generally cooresponds to the debugfs fw_stats file */
1476 static const char ath10k_gstrings_stats[][ETH_GSTRING_LEN] = {
1477 "tx_pkts_nic",
1478 "tx_bytes_nic",
1479 "rx_pkts_nic",
1480 "rx_bytes_nic",
1481 "d_noise_floor",
1482 "d_cycle_count",
1483 "d_phy_error",
1484 "d_rts_bad",
1485 "d_rts_good",
1486 "d_tx_power", /* in .5 dbM I think */
1487 "d_rx_crc_err", /* fcs_bad */
1488 "d_no_beacon",
1489 "d_tx_mpdus_queued",
1490 "d_tx_msdu_queued",
1491 "d_tx_msdu_dropped",
1492 "d_local_enqued",
1493 "d_local_freed",
1494 "d_tx_ppdu_hw_queued",
1495 "d_tx_ppdu_reaped",
1496 "d_tx_fifo_underrun",
1497 "d_tx_ppdu_abort",
1498 "d_tx_mpdu_requed",
1499 "d_tx_excessive_retries",
1500 "d_tx_hw_rate",
1501 "d_tx_dropped_sw_retries",
1502 "d_tx_illegal_rate",
1503 "d_tx_continuous_xretries",
1504 "d_tx_timeout",
1505 "d_tx_mpdu_txop_limit",
1506 "d_pdev_resets",
1507 "d_rx_mid_ppdu_route_change",
1508 "d_rx_status",
1509 "d_rx_extra_frags_ring0",
1510 "d_rx_extra_frags_ring1",
1511 "d_rx_extra_frags_ring2",
1512 "d_rx_extra_frags_ring3",
1513 "d_rx_msdu_htt",
1514 "d_rx_mpdu_htt",
1515 "d_rx_msdu_stack",
1516 "d_rx_mpdu_stack",
1517 "d_rx_phy_err",
1518 "d_rx_phy_err_drops",
1519 "d_rx_mpdu_errors", /* FCS, MIC, ENC */
1520 "d_fw_crash_count",
1521 "d_fw_warm_reset_count",
1522 "d_fw_cold_reset_count",
1523 };
1524
1525 #define ATH10K_SSTATS_LEN ARRAY_SIZE(ath10k_gstrings_stats)
1526
1527 void ath10k_debug_get_et_strings(struct ieee80211_hw *hw,
1528 struct ieee80211_vif *vif,
1529 u32 sset, u8 *data)
1530 {
1531 if (sset == ETH_SS_STATS)
1532 memcpy(data, *ath10k_gstrings_stats,
1533 sizeof(ath10k_gstrings_stats));
1534 }
1535
1536 int ath10k_debug_get_et_sset_count(struct ieee80211_hw *hw,
1537 struct ieee80211_vif *vif, int sset)
1538 {
1539 if (sset == ETH_SS_STATS)
1540 return ATH10K_SSTATS_LEN;
1541
1542 return 0;
1543 }
1544
1545 void ath10k_debug_get_et_stats(struct ieee80211_hw *hw,
1546 struct ieee80211_vif *vif,
1547 struct ethtool_stats *stats, u64 *data)
1548 {
1549 struct ath10k *ar = hw->priv;
1550 static const struct ath10k_fw_stats_pdev zero_stats = {};
1551 const struct ath10k_fw_stats_pdev *pdev_stats;
1552 int i = 0, ret;
1553
1554 mutex_lock(&ar->conf_mutex);
1555
1556 if (ar->state == ATH10K_STATE_ON) {
1557 ret = ath10k_debug_fw_stats_request(ar);
1558 if (ret) {
1559 /* just print a warning and try to use older results */
1560 ath10k_warn(ar,
1561 "failed to get fw stats for ethtool: %d\n",
1562 ret);
1563 }
1564 }
1565
1566 pdev_stats = list_first_entry_or_null(&ar->debug.fw_stats.pdevs,
1567 struct ath10k_fw_stats_pdev,
1568 list);
1569 if (!pdev_stats) {
1570 /* no results available so just return zeroes */
1571 pdev_stats = &zero_stats;
1572 }
1573
1574 spin_lock_bh(&ar->data_lock);
1575
1576 data[i++] = pdev_stats->hw_reaped; /* ppdu reaped */
1577 data[i++] = 0; /* tx bytes */
1578 data[i++] = pdev_stats->htt_mpdus;
1579 data[i++] = 0; /* rx bytes */
1580 data[i++] = pdev_stats->ch_noise_floor;
1581 data[i++] = pdev_stats->cycle_count;
1582 data[i++] = pdev_stats->phy_err_count;
1583 data[i++] = pdev_stats->rts_bad;
1584 data[i++] = pdev_stats->rts_good;
1585 data[i++] = pdev_stats->chan_tx_power;
1586 data[i++] = pdev_stats->fcs_bad;
1587 data[i++] = pdev_stats->no_beacons;
1588 data[i++] = pdev_stats->mpdu_enqued;
1589 data[i++] = pdev_stats->msdu_enqued;
1590 data[i++] = pdev_stats->wmm_drop;
1591 data[i++] = pdev_stats->local_enqued;
1592 data[i++] = pdev_stats->local_freed;
1593 data[i++] = pdev_stats->hw_queued;
1594 data[i++] = pdev_stats->hw_reaped;
1595 data[i++] = pdev_stats->underrun;
1596 data[i++] = pdev_stats->tx_abort;
1597 data[i++] = pdev_stats->mpdus_requed;
1598 data[i++] = pdev_stats->tx_ko;
1599 data[i++] = pdev_stats->data_rc;
1600 data[i++] = pdev_stats->sw_retry_failure;
1601 data[i++] = pdev_stats->illgl_rate_phy_err;
1602 data[i++] = pdev_stats->pdev_cont_xretry;
1603 data[i++] = pdev_stats->pdev_tx_timeout;
1604 data[i++] = pdev_stats->txop_ovf;
1605 data[i++] = pdev_stats->pdev_resets;
1606 data[i++] = pdev_stats->mid_ppdu_route_change;
1607 data[i++] = pdev_stats->status_rcvd;
1608 data[i++] = pdev_stats->r0_frags;
1609 data[i++] = pdev_stats->r1_frags;
1610 data[i++] = pdev_stats->r2_frags;
1611 data[i++] = pdev_stats->r3_frags;
1612 data[i++] = pdev_stats->htt_msdus;
1613 data[i++] = pdev_stats->htt_mpdus;
1614 data[i++] = pdev_stats->loc_msdus;
1615 data[i++] = pdev_stats->loc_mpdus;
1616 data[i++] = pdev_stats->phy_errs;
1617 data[i++] = pdev_stats->phy_err_drop;
1618 data[i++] = pdev_stats->mpdu_errs;
1619 data[i++] = ar->stats.fw_crash_counter;
1620 data[i++] = ar->stats.fw_warm_reset_counter;
1621 data[i++] = ar->stats.fw_cold_reset_counter;
1622
1623 spin_unlock_bh(&ar->data_lock);
1624
1625 mutex_unlock(&ar->conf_mutex);
1626
1627 WARN_ON(i != ATH10K_SSTATS_LEN);
1628 }
1629
1630 static const struct file_operations fops_fw_dbglog = {
1631 .read = ath10k_read_fw_dbglog,
1632 .write = ath10k_write_fw_dbglog,
1633 .open = simple_open,
1634 .owner = THIS_MODULE,
1635 .llseek = default_llseek,
1636 };
1637
1638 static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
1639 {
1640 struct ath10k *ar = inode->i_private;
1641 void *buf;
1642 u32 hi_addr;
1643 __le32 addr;
1644 int ret;
1645
1646 mutex_lock(&ar->conf_mutex);
1647
1648 if (ar->state != ATH10K_STATE_ON &&
1649 ar->state != ATH10K_STATE_UTF) {
1650 ret = -ENETDOWN;
1651 goto err;
1652 }
1653
1654 buf = vmalloc(QCA988X_CAL_DATA_LEN);
1655 if (!buf) {
1656 ret = -ENOMEM;
1657 goto err;
1658 }
1659
1660 hi_addr = host_interest_item_address(HI_ITEM(hi_board_data));
1661
1662 ret = ath10k_hif_diag_read(ar, hi_addr, &addr, sizeof(addr));
1663 if (ret) {
1664 ath10k_warn(ar, "failed to read hi_board_data address: %d\n", ret);
1665 goto err_vfree;
1666 }
1667
1668 ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), buf,
1669 QCA988X_CAL_DATA_LEN);
1670 if (ret) {
1671 ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
1672 goto err_vfree;
1673 }
1674
1675 file->private_data = buf;
1676
1677 mutex_unlock(&ar->conf_mutex);
1678
1679 return 0;
1680
1681 err_vfree:
1682 vfree(buf);
1683
1684 err:
1685 mutex_unlock(&ar->conf_mutex);
1686
1687 return ret;
1688 }
1689
1690 static ssize_t ath10k_debug_cal_data_read(struct file *file,
1691 char __user *user_buf,
1692 size_t count, loff_t *ppos)
1693 {
1694 void *buf = file->private_data;
1695
1696 return simple_read_from_buffer(user_buf, count, ppos,
1697 buf, QCA988X_CAL_DATA_LEN);
1698 }
1699
1700 static int ath10k_debug_cal_data_release(struct inode *inode,
1701 struct file *file)
1702 {
1703 vfree(file->private_data);
1704
1705 return 0;
1706 }
1707
1708 static const struct file_operations fops_cal_data = {
1709 .open = ath10k_debug_cal_data_open,
1710 .read = ath10k_debug_cal_data_read,
1711 .release = ath10k_debug_cal_data_release,
1712 .owner = THIS_MODULE,
1713 .llseek = default_llseek,
1714 };
1715
1716 static ssize_t ath10k_read_nf_cal_period(struct file *file,
1717 char __user *user_buf,
1718 size_t count, loff_t *ppos)
1719 {
1720 struct ath10k *ar = file->private_data;
1721 unsigned int len;
1722 char buf[32];
1723
1724 len = scnprintf(buf, sizeof(buf), "%d\n",
1725 ar->debug.nf_cal_period);
1726
1727 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1728 }
1729
1730 static ssize_t ath10k_write_nf_cal_period(struct file *file,
1731 const char __user *user_buf,
1732 size_t count, loff_t *ppos)
1733 {
1734 struct ath10k *ar = file->private_data;
1735 unsigned long period;
1736 int ret;
1737
1738 ret = kstrtoul_from_user(user_buf, count, 0, &period);
1739 if (ret)
1740 return ret;
1741
1742 if (period > WMI_PDEV_PARAM_CAL_PERIOD_MAX)
1743 return -EINVAL;
1744
1745 /* there's no way to switch back to the firmware default */
1746 if (period == 0)
1747 return -EINVAL;
1748
1749 mutex_lock(&ar->conf_mutex);
1750
1751 ar->debug.nf_cal_period = period;
1752
1753 if (ar->state != ATH10K_STATE_ON) {
1754 /* firmware is not running, nothing else to do */
1755 ret = count;
1756 goto exit;
1757 }
1758
1759 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->cal_period,
1760 ar->debug.nf_cal_period);
1761 if (ret) {
1762 ath10k_warn(ar, "cal period cfg failed from debugfs: %d\n",
1763 ret);
1764 goto exit;
1765 }
1766
1767 ret = count;
1768
1769 exit:
1770 mutex_unlock(&ar->conf_mutex);
1771
1772 return ret;
1773 }
1774
1775 static const struct file_operations fops_nf_cal_period = {
1776 .read = ath10k_read_nf_cal_period,
1777 .write = ath10k_write_nf_cal_period,
1778 .open = simple_open,
1779 .owner = THIS_MODULE,
1780 .llseek = default_llseek,
1781 };
1782
1783 int ath10k_debug_start(struct ath10k *ar)
1784 {
1785 int ret;
1786
1787 lockdep_assert_held(&ar->conf_mutex);
1788
1789 ret = ath10k_debug_htt_stats_req(ar);
1790 if (ret)
1791 /* continue normally anyway, this isn't serious */
1792 ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1793 ret);
1794
1795 if (ar->debug.fw_dbglog_mask) {
1796 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1797 ATH10K_DBGLOG_LEVEL_WARN);
1798 if (ret)
1799 /* not serious */
1800 ath10k_warn(ar, "failed to enable dbglog during start: %d",
1801 ret);
1802 }
1803
1804 if (ar->debug.pktlog_filter) {
1805 ret = ath10k_wmi_pdev_pktlog_enable(ar,
1806 ar->debug.pktlog_filter);
1807 if (ret)
1808 /* not serious */
1809 ath10k_warn(ar,
1810 "failed to enable pktlog filter %x: %d\n",
1811 ar->debug.pktlog_filter, ret);
1812 } else {
1813 ret = ath10k_wmi_pdev_pktlog_disable(ar);
1814 if (ret)
1815 /* not serious */
1816 ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1817 }
1818
1819 if (ar->debug.nf_cal_period) {
1820 ret = ath10k_wmi_pdev_set_param(ar,
1821 ar->wmi.pdev_param->cal_period,
1822 ar->debug.nf_cal_period);
1823 if (ret)
1824 /* not serious */
1825 ath10k_warn(ar, "cal period cfg failed from debug start: %d\n",
1826 ret);
1827 }
1828
1829 return ret;
1830 }
1831
1832 void ath10k_debug_stop(struct ath10k *ar)
1833 {
1834 lockdep_assert_held(&ar->conf_mutex);
1835
1836 /* Must not use _sync to avoid deadlock, we do that in
1837 * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1838 * warning from del_timer(). */
1839 if (ar->debug.htt_stats_mask != 0)
1840 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1841
1842 ar->debug.htt_max_amsdu = 0;
1843 ar->debug.htt_max_ampdu = 0;
1844
1845 ath10k_wmi_pdev_pktlog_disable(ar);
1846 }
1847
1848 static ssize_t ath10k_write_simulate_radar(struct file *file,
1849 const char __user *user_buf,
1850 size_t count, loff_t *ppos)
1851 {
1852 struct ath10k *ar = file->private_data;
1853
1854 ieee80211_radar_detected(ar->hw);
1855
1856 return count;
1857 }
1858
1859 static const struct file_operations fops_simulate_radar = {
1860 .write = ath10k_write_simulate_radar,
1861 .open = simple_open,
1862 .owner = THIS_MODULE,
1863 .llseek = default_llseek,
1864 };
1865
1866 #define ATH10K_DFS_STAT(s, p) (\
1867 len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1868 ar->debug.dfs_stats.p))
1869
1870 #define ATH10K_DFS_POOL_STAT(s, p) (\
1871 len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1872 ar->debug.dfs_pool_stats.p))
1873
1874 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1875 size_t count, loff_t *ppos)
1876 {
1877 int retval = 0, len = 0;
1878 const int size = 8000;
1879 struct ath10k *ar = file->private_data;
1880 char *buf;
1881
1882 buf = kzalloc(size, GFP_KERNEL);
1883 if (buf == NULL)
1884 return -ENOMEM;
1885
1886 if (!ar->dfs_detector) {
1887 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1888 goto exit;
1889 }
1890
1891 ar->debug.dfs_pool_stats =
1892 ar->dfs_detector->get_stats(ar->dfs_detector);
1893
1894 len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1895
1896 ATH10K_DFS_STAT("reported phy errors", phy_errors);
1897 ATH10K_DFS_STAT("pulse events reported", pulses_total);
1898 ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1899 ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1900 ATH10K_DFS_STAT("Radars detected", radar_detected);
1901
1902 len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1903 ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1904 ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1905 ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1906 ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1907 ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1908 ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1909 ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1910
1911 exit:
1912 if (len > size)
1913 len = size;
1914
1915 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1916 kfree(buf);
1917
1918 return retval;
1919 }
1920
1921 static const struct file_operations fops_dfs_stats = {
1922 .read = ath10k_read_dfs_stats,
1923 .open = simple_open,
1924 .owner = THIS_MODULE,
1925 .llseek = default_llseek,
1926 };
1927
1928 static ssize_t ath10k_write_pktlog_filter(struct file *file,
1929 const char __user *ubuf,
1930 size_t count, loff_t *ppos)
1931 {
1932 struct ath10k *ar = file->private_data;
1933 u32 filter;
1934 int ret;
1935
1936 if (kstrtouint_from_user(ubuf, count, 0, &filter))
1937 return -EINVAL;
1938
1939 mutex_lock(&ar->conf_mutex);
1940
1941 if (ar->state != ATH10K_STATE_ON) {
1942 ar->debug.pktlog_filter = filter;
1943 ret = count;
1944 goto out;
1945 }
1946
1947 if (filter && (filter != ar->debug.pktlog_filter)) {
1948 ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
1949 if (ret) {
1950 ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
1951 ar->debug.pktlog_filter, ret);
1952 goto out;
1953 }
1954 } else {
1955 ret = ath10k_wmi_pdev_pktlog_disable(ar);
1956 if (ret) {
1957 ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1958 goto out;
1959 }
1960 }
1961
1962 ar->debug.pktlog_filter = filter;
1963 ret = count;
1964
1965 out:
1966 mutex_unlock(&ar->conf_mutex);
1967 return ret;
1968 }
1969
1970 static ssize_t ath10k_read_pktlog_filter(struct file *file, char __user *ubuf,
1971 size_t count, loff_t *ppos)
1972 {
1973 char buf[32];
1974 struct ath10k *ar = file->private_data;
1975 int len = 0;
1976
1977 mutex_lock(&ar->conf_mutex);
1978 len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
1979 ar->debug.pktlog_filter);
1980 mutex_unlock(&ar->conf_mutex);
1981
1982 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
1983 }
1984
1985 static const struct file_operations fops_pktlog_filter = {
1986 .read = ath10k_read_pktlog_filter,
1987 .write = ath10k_write_pktlog_filter,
1988 .open = simple_open
1989 };
1990
1991 int ath10k_debug_create(struct ath10k *ar)
1992 {
1993 ar->debug.fw_crash_data = vzalloc(sizeof(*ar->debug.fw_crash_data));
1994 if (!ar->debug.fw_crash_data)
1995 return -ENOMEM;
1996
1997 INIT_LIST_HEAD(&ar->debug.fw_stats.pdevs);
1998 INIT_LIST_HEAD(&ar->debug.fw_stats.vdevs);
1999 INIT_LIST_HEAD(&ar->debug.fw_stats.peers);
2000
2001 return 0;
2002 }
2003
2004 void ath10k_debug_destroy(struct ath10k *ar)
2005 {
2006 vfree(ar->debug.fw_crash_data);
2007 ar->debug.fw_crash_data = NULL;
2008
2009 ath10k_debug_fw_stats_reset(ar);
2010 }
2011
2012 int ath10k_debug_register(struct ath10k *ar)
2013 {
2014 ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
2015 ar->hw->wiphy->debugfsdir);
2016 if (IS_ERR_OR_NULL(ar->debug.debugfs_phy)) {
2017 if (IS_ERR(ar->debug.debugfs_phy))
2018 return PTR_ERR(ar->debug.debugfs_phy);
2019
2020 return -ENOMEM;
2021 }
2022
2023 INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
2024 ath10k_debug_htt_stats_dwork);
2025
2026 init_completion(&ar->debug.fw_stats_complete);
2027
2028 debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
2029 &fops_fw_stats);
2030
2031 debugfs_create_file("fw_reset_stats", S_IRUSR, ar->debug.debugfs_phy,
2032 ar, &fops_fw_reset_stats);
2033
2034 debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
2035 &fops_wmi_services);
2036
2037 debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy,
2038 ar, &fops_simulate_fw_crash);
2039
2040 debugfs_create_file("fw_crash_dump", S_IRUSR, ar->debug.debugfs_phy,
2041 ar, &fops_fw_crash_dump);
2042
2043 debugfs_create_file("reg_addr", S_IRUSR | S_IWUSR,
2044 ar->debug.debugfs_phy, ar, &fops_reg_addr);
2045
2046 debugfs_create_file("reg_value", S_IRUSR | S_IWUSR,
2047 ar->debug.debugfs_phy, ar, &fops_reg_value);
2048
2049 debugfs_create_file("mem_value", S_IRUSR | S_IWUSR,
2050 ar->debug.debugfs_phy, ar, &fops_mem_value);
2051
2052 debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
2053 ar, &fops_chip_id);
2054
2055 debugfs_create_file("htt_stats_mask", S_IRUSR, ar->debug.debugfs_phy,
2056 ar, &fops_htt_stats_mask);
2057
2058 debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
2059 ar->debug.debugfs_phy, ar,
2060 &fops_htt_max_amsdu_ampdu);
2061
2062 debugfs_create_file("fw_dbglog", S_IRUSR, ar->debug.debugfs_phy,
2063 ar, &fops_fw_dbglog);
2064
2065 debugfs_create_file("cal_data", S_IRUSR, ar->debug.debugfs_phy,
2066 ar, &fops_cal_data);
2067
2068 debugfs_create_file("nf_cal_period", S_IRUSR | S_IWUSR,
2069 ar->debug.debugfs_phy, ar, &fops_nf_cal_period);
2070
2071 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
2072 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
2073 ar->debug.debugfs_phy, ar,
2074 &fops_simulate_radar);
2075
2076 debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
2077 ar->debug.debugfs_phy,
2078 &ar->dfs_block_radar_events);
2079
2080 debugfs_create_file("dfs_stats", S_IRUSR,
2081 ar->debug.debugfs_phy, ar,
2082 &fops_dfs_stats);
2083 }
2084
2085 debugfs_create_file("pktlog_filter", S_IRUGO | S_IWUSR,
2086 ar->debug.debugfs_phy, ar, &fops_pktlog_filter);
2087
2088 return 0;
2089 }
2090
2091 void ath10k_debug_unregister(struct ath10k *ar)
2092 {
2093 cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
2094 }
2095
2096 #endif /* CONFIG_ATH10K_DEBUGFS */
2097
2098 #ifdef CONFIG_ATH10K_DEBUG
2099 void ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
2100 const char *fmt, ...)
2101 {
2102 struct va_format vaf;
2103 va_list args;
2104
2105 va_start(args, fmt);
2106
2107 vaf.fmt = fmt;
2108 vaf.va = &args;
2109
2110 if (ath10k_debug_mask & mask)
2111 dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
2112
2113 trace_ath10k_log_dbg(ar, mask, &vaf);
2114
2115 va_end(args);
2116 }
2117 EXPORT_SYMBOL(ath10k_dbg);
2118
2119 void ath10k_dbg_dump(struct ath10k *ar,
2120 enum ath10k_debug_mask mask,
2121 const char *msg, const char *prefix,
2122 const void *buf, size_t len)
2123 {
2124 char linebuf[256];
2125 unsigned int linebuflen;
2126 const void *ptr;
2127
2128 if (ath10k_debug_mask & mask) {
2129 if (msg)
2130 ath10k_dbg(ar, mask, "%s\n", msg);
2131
2132 for (ptr = buf; (ptr - buf) < len; ptr += 16) {
2133 linebuflen = 0;
2134 linebuflen += scnprintf(linebuf + linebuflen,
2135 sizeof(linebuf) - linebuflen,
2136 "%s%08x: ",
2137 (prefix ? prefix : ""),
2138 (unsigned int)(ptr - buf));
2139 hex_dump_to_buffer(ptr, len - (ptr - buf), 16, 1,
2140 linebuf + linebuflen,
2141 sizeof(linebuf) - linebuflen, true);
2142 dev_printk(KERN_DEBUG, ar->dev, "%s\n", linebuf);
2143 }
2144 }
2145
2146 /* tracing code doesn't like null strings :/ */
2147 trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
2148 buf, len);
2149 }
2150 EXPORT_SYMBOL(ath10k_dbg_dump);
2151
2152 #endif /* CONFIG_ATH10K_DEBUG */
Linux kernel - Deliverables
This page took 0.10972 seconds and 5 git commands to generate.