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