2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
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.
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.
18 #include <linux/module.h>
19 #include <linux/debugfs.h>
20 #include <linux/version.h>
21 #include <linux/vermagic.h>
22 #include <linux/vmalloc.h>
28 #define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
30 #define ATH10K_FW_CRASH_DUMP_VERSION 1
33 * enum ath10k_fw_crash_dump_type - types of data in the dump file
34 * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
36 enum ath10k_fw_crash_dump_type {
37 ATH10K_FW_CRASH_DUMP_REGISTERS = 0,
39 ATH10K_FW_CRASH_DUMP_MAX,
42 struct ath10k_tlv_dump_data {
43 /* see ath10k_fw_crash_dump_type above */
49 /* pad to 32-bit boundaries as needed */
53 struct ath10k_dump_file_data {
54 /* dump file information */
56 /* "ATH10K-FW-DUMP" */
61 /* file dump version */
64 /* some info we can get from ath10k struct that might help */
70 /* 0 for now, in place for later hardware */
73 __le32 target_version;
74 __le32 fw_version_major;
75 __le32 fw_version_minor;
76 __le32 fw_version_release;
77 __le32 fw_version_build;
78 __le32 phy_capability;
79 __le32 hw_min_tx_power;
80 __le32 hw_max_tx_power;
85 /* firmware version string */
86 char fw_ver[ETHTOOL_FWVERS_LEN];
88 /* Kernel related information */
90 /* time-of-day stamp */
93 /* time-of-day stamp, nano-seconds */
96 /* LINUX_VERSION_CODE */
97 __le32 kernel_ver_code;
102 /* room for growth w/out changing binary format */
105 /* struct ath10k_tlv_dump_data + more */
109 static int ath10k_printk(const char *level, const char *fmt, ...)
111 struct va_format vaf;
120 rtn = printk("%sath10k: %pV", level, &vaf);
127 int ath10k_info(const char *fmt, ...)
129 struct va_format vaf = {
137 ret = ath10k_printk(KERN_INFO, "%pV", &vaf);
138 trace_ath10k_log_info(&vaf);
143 EXPORT_SYMBOL(ath10k_info);
145 void ath10k_print_driver_info(struct ath10k *ar)
147 ath10k_info("%s (0x%08x, 0x%08x) fw %s api %d htt %d.%d\n",
151 ar->hw->wiphy->fw_version,
153 ar->htt.target_version_major,
154 ar->htt.target_version_minor);
155 ath10k_info("debug %d debugfs %d tracing %d dfs %d\n",
156 config_enabled(CONFIG_ATH10K_DEBUG),
157 config_enabled(CONFIG_ATH10K_DEBUGFS),
158 config_enabled(CONFIG_ATH10K_TRACING),
159 config_enabled(CONFIG_ATH10K_DFS_CERTIFIED));
161 EXPORT_SYMBOL(ath10k_print_driver_info);
163 int ath10k_err(const char *fmt, ...)
165 struct va_format vaf = {
173 ret = ath10k_printk(KERN_ERR, "%pV", &vaf);
174 trace_ath10k_log_err(&vaf);
179 EXPORT_SYMBOL(ath10k_err);
181 int ath10k_warn(const char *fmt, ...)
183 struct va_format vaf = {
193 ret = ath10k_printk(KERN_WARNING, "%pV", &vaf);
195 trace_ath10k_log_warn(&vaf);
201 EXPORT_SYMBOL(ath10k_warn);
203 #ifdef CONFIG_ATH10K_DEBUGFS
205 void ath10k_debug_read_service_map(struct ath10k *ar,
209 memcpy(ar->debug.wmi_service_bitmap, service_map, map_size);
212 static ssize_t ath10k_read_wmi_services(struct file *file,
213 char __user *user_buf,
214 size_t count, loff_t *ppos)
216 struct ath10k *ar = file->private_data;
218 unsigned int len = 0, buf_len = 4096;
224 buf = kzalloc(buf_len, GFP_KERNEL);
228 mutex_lock(&ar->conf_mutex);
233 for (i = 0; i < WMI_MAX_SERVICE; i++) {
234 enabled = test_bit(i, ar->debug.wmi_service_bitmap);
235 name = wmi_service_name(i);
239 len += scnprintf(buf + len, buf_len - len,
240 "%-40s %s (bit %d)\n",
241 "unknown", "enabled", i);
246 len += scnprintf(buf + len, buf_len - len,
248 name, enabled ? "enabled" : "-");
251 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
253 mutex_unlock(&ar->conf_mutex);
259 static const struct file_operations fops_wmi_services = {
260 .read = ath10k_read_wmi_services,
262 .owner = THIS_MODULE,
263 .llseek = default_llseek,
266 void ath10k_debug_read_target_stats(struct ath10k *ar,
267 struct wmi_stats_event *ev)
270 struct ath10k_target_stats *stats;
271 int num_pdev_stats, num_vdev_stats, num_peer_stats;
272 struct wmi_pdev_stats_10x *ps;
275 spin_lock_bh(&ar->data_lock);
277 stats = &ar->debug.target_stats;
279 num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats); /* 0 or 1 */
280 num_vdev_stats = __le32_to_cpu(ev->num_vdev_stats); /* 0 or max vdevs */
281 num_peer_stats = __le32_to_cpu(ev->num_peer_stats); /* 0 or max peers */
283 if (num_pdev_stats) {
284 ps = (struct wmi_pdev_stats_10x *)tmp;
286 stats->ch_noise_floor = __le32_to_cpu(ps->chan_nf);
287 stats->tx_frame_count = __le32_to_cpu(ps->tx_frame_count);
288 stats->rx_frame_count = __le32_to_cpu(ps->rx_frame_count);
289 stats->rx_clear_count = __le32_to_cpu(ps->rx_clear_count);
290 stats->cycle_count = __le32_to_cpu(ps->cycle_count);
291 stats->phy_err_count = __le32_to_cpu(ps->phy_err_count);
292 stats->chan_tx_power = __le32_to_cpu(ps->chan_tx_pwr);
294 stats->comp_queued = __le32_to_cpu(ps->wal.tx.comp_queued);
295 stats->comp_delivered =
296 __le32_to_cpu(ps->wal.tx.comp_delivered);
297 stats->msdu_enqued = __le32_to_cpu(ps->wal.tx.msdu_enqued);
298 stats->mpdu_enqued = __le32_to_cpu(ps->wal.tx.mpdu_enqued);
299 stats->wmm_drop = __le32_to_cpu(ps->wal.tx.wmm_drop);
300 stats->local_enqued = __le32_to_cpu(ps->wal.tx.local_enqued);
301 stats->local_freed = __le32_to_cpu(ps->wal.tx.local_freed);
302 stats->hw_queued = __le32_to_cpu(ps->wal.tx.hw_queued);
303 stats->hw_reaped = __le32_to_cpu(ps->wal.tx.hw_reaped);
304 stats->underrun = __le32_to_cpu(ps->wal.tx.underrun);
305 stats->tx_abort = __le32_to_cpu(ps->wal.tx.tx_abort);
306 stats->mpdus_requed = __le32_to_cpu(ps->wal.tx.mpdus_requed);
307 stats->tx_ko = __le32_to_cpu(ps->wal.tx.tx_ko);
308 stats->data_rc = __le32_to_cpu(ps->wal.tx.data_rc);
309 stats->self_triggers = __le32_to_cpu(ps->wal.tx.self_triggers);
310 stats->sw_retry_failure =
311 __le32_to_cpu(ps->wal.tx.sw_retry_failure);
312 stats->illgl_rate_phy_err =
313 __le32_to_cpu(ps->wal.tx.illgl_rate_phy_err);
314 stats->pdev_cont_xretry =
315 __le32_to_cpu(ps->wal.tx.pdev_cont_xretry);
316 stats->pdev_tx_timeout =
317 __le32_to_cpu(ps->wal.tx.pdev_tx_timeout);
318 stats->pdev_resets = __le32_to_cpu(ps->wal.tx.pdev_resets);
319 stats->phy_underrun = __le32_to_cpu(ps->wal.tx.phy_underrun);
320 stats->txop_ovf = __le32_to_cpu(ps->wal.tx.txop_ovf);
322 stats->mid_ppdu_route_change =
323 __le32_to_cpu(ps->wal.rx.mid_ppdu_route_change);
324 stats->status_rcvd = __le32_to_cpu(ps->wal.rx.status_rcvd);
325 stats->r0_frags = __le32_to_cpu(ps->wal.rx.r0_frags);
326 stats->r1_frags = __le32_to_cpu(ps->wal.rx.r1_frags);
327 stats->r2_frags = __le32_to_cpu(ps->wal.rx.r2_frags);
328 stats->r3_frags = __le32_to_cpu(ps->wal.rx.r3_frags);
329 stats->htt_msdus = __le32_to_cpu(ps->wal.rx.htt_msdus);
330 stats->htt_mpdus = __le32_to_cpu(ps->wal.rx.htt_mpdus);
331 stats->loc_msdus = __le32_to_cpu(ps->wal.rx.loc_msdus);
332 stats->loc_mpdus = __le32_to_cpu(ps->wal.rx.loc_mpdus);
333 stats->oversize_amsdu =
334 __le32_to_cpu(ps->wal.rx.oversize_amsdu);
335 stats->phy_errs = __le32_to_cpu(ps->wal.rx.phy_errs);
336 stats->phy_err_drop = __le32_to_cpu(ps->wal.rx.phy_err_drop);
337 stats->mpdu_errs = __le32_to_cpu(ps->wal.rx.mpdu_errs);
339 if (test_bit(ATH10K_FW_FEATURE_WMI_10X,
341 stats->ack_rx_bad = __le32_to_cpu(ps->ack_rx_bad);
342 stats->rts_bad = __le32_to_cpu(ps->rts_bad);
343 stats->rts_good = __le32_to_cpu(ps->rts_good);
344 stats->fcs_bad = __le32_to_cpu(ps->fcs_bad);
345 stats->no_beacons = __le32_to_cpu(ps->no_beacons);
346 stats->mib_int_count = __le32_to_cpu(ps->mib_int_count);
347 tmp += sizeof(struct wmi_pdev_stats_10x);
349 tmp += sizeof(struct wmi_pdev_stats_old);
354 /* Currently firmware does not support VDEV stats */
355 if (num_vdev_stats) {
356 struct wmi_vdev_stats *vdev_stats;
358 for (i = 0; i < num_vdev_stats; i++) {
359 vdev_stats = (struct wmi_vdev_stats *)tmp;
360 tmp += sizeof(struct wmi_vdev_stats);
364 if (num_peer_stats) {
365 struct wmi_peer_stats_10x *peer_stats;
366 struct ath10k_peer_stat *s;
368 stats->peers = num_peer_stats;
370 for (i = 0; i < num_peer_stats; i++) {
371 peer_stats = (struct wmi_peer_stats_10x *)tmp;
372 s = &stats->peer_stat[i];
374 memcpy(s->peer_macaddr, &peer_stats->peer_macaddr.addr,
376 s->peer_rssi = __le32_to_cpu(peer_stats->peer_rssi);
378 __le32_to_cpu(peer_stats->peer_tx_rate);
379 if (test_bit(ATH10K_FW_FEATURE_WMI_10X,
382 __le32_to_cpu(peer_stats->peer_rx_rate);
383 tmp += sizeof(struct wmi_peer_stats_10x);
386 tmp += sizeof(struct wmi_peer_stats_old);
391 spin_unlock_bh(&ar->data_lock);
392 complete(&ar->debug.event_stats_compl);
395 static ssize_t ath10k_read_fw_stats(struct file *file, char __user *user_buf,
396 size_t count, loff_t *ppos)
398 struct ath10k *ar = file->private_data;
399 struct ath10k_target_stats *fw_stats;
401 unsigned int len = 0, buf_len = 8000;
407 fw_stats = &ar->debug.target_stats;
409 mutex_lock(&ar->conf_mutex);
411 if (ar->state != ATH10K_STATE_ON)
414 buf = kzalloc(buf_len, GFP_KERNEL);
418 ret = ath10k_wmi_request_stats(ar, WMI_REQUEST_PEER_STAT);
420 ath10k_warn("could not request stats (%d)\n", ret);
424 left = wait_for_completion_timeout(&ar->debug.event_stats_compl, 1*HZ);
428 spin_lock_bh(&ar->data_lock);
429 len += scnprintf(buf + len, buf_len - len, "\n");
430 len += scnprintf(buf + len, buf_len - len, "%30s\n",
431 "ath10k PDEV stats");
432 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
433 "=================");
435 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
436 "Channel noise floor", fw_stats->ch_noise_floor);
437 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
438 "Channel TX power", fw_stats->chan_tx_power);
439 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
440 "TX frame count", fw_stats->tx_frame_count);
441 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
442 "RX frame count", fw_stats->rx_frame_count);
443 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
444 "RX clear count", fw_stats->rx_clear_count);
445 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
446 "Cycle count", fw_stats->cycle_count);
447 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
448 "PHY error count", fw_stats->phy_err_count);
449 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
450 "RTS bad count", fw_stats->rts_bad);
451 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
452 "RTS good count", fw_stats->rts_good);
453 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
454 "FCS bad count", fw_stats->fcs_bad);
455 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
456 "No beacon count", fw_stats->no_beacons);
457 len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
458 "MIB int count", fw_stats->mib_int_count);
460 len += scnprintf(buf + len, buf_len - len, "\n");
461 len += scnprintf(buf + len, buf_len - len, "%30s\n",
462 "ath10k PDEV TX stats");
463 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
464 "=================");
466 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
467 "HTT cookies queued", fw_stats->comp_queued);
468 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
469 "HTT cookies disp.", fw_stats->comp_delivered);
470 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
471 "MSDU queued", fw_stats->msdu_enqued);
472 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
473 "MPDU queued", fw_stats->mpdu_enqued);
474 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
475 "MSDUs dropped", fw_stats->wmm_drop);
476 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
477 "Local enqued", fw_stats->local_enqued);
478 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
479 "Local freed", fw_stats->local_freed);
480 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
481 "HW queued", fw_stats->hw_queued);
482 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
483 "PPDUs reaped", fw_stats->hw_reaped);
484 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
485 "Num underruns", fw_stats->underrun);
486 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
487 "PPDUs cleaned", fw_stats->tx_abort);
488 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
489 "MPDUs requed", fw_stats->mpdus_requed);
490 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
491 "Excessive retries", fw_stats->tx_ko);
492 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
493 "HW rate", fw_stats->data_rc);
494 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
495 "Sched self tiggers", fw_stats->self_triggers);
496 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
497 "Dropped due to SW retries",
498 fw_stats->sw_retry_failure);
499 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
500 "Illegal rate phy errors",
501 fw_stats->illgl_rate_phy_err);
502 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
503 "Pdev continous xretry", fw_stats->pdev_cont_xretry);
504 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
505 "TX timeout", fw_stats->pdev_tx_timeout);
506 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
507 "PDEV resets", fw_stats->pdev_resets);
508 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
509 "PHY underrun", fw_stats->phy_underrun);
510 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
511 "MPDU is more than txop limit", fw_stats->txop_ovf);
513 len += scnprintf(buf + len, buf_len - len, "\n");
514 len += scnprintf(buf + len, buf_len - len, "%30s\n",
515 "ath10k PDEV RX stats");
516 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
517 "=================");
519 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
520 "Mid PPDU route change",
521 fw_stats->mid_ppdu_route_change);
522 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
523 "Tot. number of statuses", fw_stats->status_rcvd);
524 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
525 "Extra frags on rings 0", fw_stats->r0_frags);
526 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
527 "Extra frags on rings 1", fw_stats->r1_frags);
528 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
529 "Extra frags on rings 2", fw_stats->r2_frags);
530 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
531 "Extra frags on rings 3", fw_stats->r3_frags);
532 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
533 "MSDUs delivered to HTT", fw_stats->htt_msdus);
534 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
535 "MPDUs delivered to HTT", fw_stats->htt_mpdus);
536 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
537 "MSDUs delivered to stack", fw_stats->loc_msdus);
538 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
539 "MPDUs delivered to stack", fw_stats->loc_mpdus);
540 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
541 "Oversized AMSUs", fw_stats->oversize_amsdu);
542 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
543 "PHY errors", fw_stats->phy_errs);
544 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
545 "PHY errors drops", fw_stats->phy_err_drop);
546 len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
547 "MPDU errors (FCS, MIC, ENC)", fw_stats->mpdu_errs);
549 len += scnprintf(buf + len, buf_len - len, "\n");
550 len += scnprintf(buf + len, buf_len - len, "%30s (%d)\n",
551 "ath10k PEER stats", fw_stats->peers);
552 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
553 "=================");
555 for (i = 0; i < fw_stats->peers; i++) {
556 len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
558 fw_stats->peer_stat[i].peer_macaddr);
559 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
560 "Peer RSSI", fw_stats->peer_stat[i].peer_rssi);
561 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
563 fw_stats->peer_stat[i].peer_tx_rate);
564 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
566 fw_stats->peer_stat[i].peer_rx_rate);
567 len += scnprintf(buf + len, buf_len - len, "\n");
569 spin_unlock_bh(&ar->data_lock);
574 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
577 mutex_unlock(&ar->conf_mutex);
582 static const struct file_operations fops_fw_stats = {
583 .read = ath10k_read_fw_stats,
585 .owner = THIS_MODULE,
586 .llseek = default_llseek,
589 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
590 char __user *user_buf,
591 size_t count, loff_t *ppos)
593 const char buf[] = "To simulate firmware crash write one of the"
594 " keywords to this file:\n `soft` - this will send"
595 " WMI_FORCE_FW_HANG_ASSERT to firmware if FW"
596 " supports that command.\n `hard` - this will send"
597 " to firmware command with illegal parameters"
598 " causing firmware crash.\n";
600 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
603 /* Simulate firmware crash:
604 * 'soft': Call wmi command causing firmware hang. This firmware hang is
605 * recoverable by warm firmware reset.
606 * 'hard': Force firmware crash by setting any vdev parameter for not allowed
607 * vdev id. This is hard firmware crash because it is recoverable only by cold
610 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
611 const char __user *user_buf,
612 size_t count, loff_t *ppos)
614 struct ath10k *ar = file->private_data;
618 mutex_lock(&ar->conf_mutex);
620 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
622 /* make sure that buf is null terminated */
623 buf[sizeof(buf) - 1] = 0;
625 if (ar->state != ATH10K_STATE_ON &&
626 ar->state != ATH10K_STATE_RESTARTED) {
631 /* drop the possible '\n' from the end */
632 if (buf[count - 1] == '\n') {
637 if (!strcmp(buf, "soft")) {
638 ath10k_info("simulating soft firmware crash\n");
639 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
640 } else if (!strcmp(buf, "hard")) {
641 ath10k_info("simulating hard firmware crash\n");
642 /* 0x7fff is vdev id, and it is always out of range for all
643 * firmware variants in order to force a firmware crash.
645 ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
646 ar->wmi.vdev_param->rts_threshold, 0);
653 ath10k_warn("failed to simulate firmware crash: %d\n", ret);
660 mutex_unlock(&ar->conf_mutex);
664 static const struct file_operations fops_simulate_fw_crash = {
665 .read = ath10k_read_simulate_fw_crash,
666 .write = ath10k_write_simulate_fw_crash,
668 .owner = THIS_MODULE,
669 .llseek = default_llseek,
672 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
673 size_t count, loff_t *ppos)
675 struct ath10k *ar = file->private_data;
679 len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->chip_id);
681 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
684 static const struct file_operations fops_chip_id = {
685 .read = ath10k_read_chip_id,
687 .owner = THIS_MODULE,
688 .llseek = default_llseek,
691 struct ath10k_fw_crash_data *
692 ath10k_debug_get_new_fw_crash_data(struct ath10k *ar)
694 struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
696 lockdep_assert_held(&ar->data_lock);
698 crash_data->crashed_since_read = true;
699 uuid_le_gen(&crash_data->uuid);
700 getnstimeofday(&crash_data->timestamp);
704 EXPORT_SYMBOL(ath10k_debug_get_new_fw_crash_data);
706 static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
708 struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
709 struct ath10k_dump_file_data *dump_data;
710 struct ath10k_tlv_dump_data *dump_tlv;
711 int hdr_len = sizeof(*dump_data);
712 unsigned int len, sofar = 0;
716 len += sizeof(*dump_tlv) + sizeof(crash_data->registers);
720 /* This is going to get big when we start dumping FW RAM and such,
721 * so go ahead and use vmalloc.
727 spin_lock_bh(&ar->data_lock);
729 if (!crash_data->crashed_since_read) {
730 spin_unlock_bh(&ar->data_lock);
735 dump_data = (struct ath10k_dump_file_data *)(buf);
736 strlcpy(dump_data->df_magic, "ATH10K-FW-DUMP",
737 sizeof(dump_data->df_magic));
738 dump_data->len = cpu_to_le32(len);
740 dump_data->version = cpu_to_le32(ATH10K_FW_CRASH_DUMP_VERSION);
742 memcpy(dump_data->uuid, &crash_data->uuid, sizeof(dump_data->uuid));
743 dump_data->chip_id = cpu_to_le32(ar->chip_id);
744 dump_data->bus_type = cpu_to_le32(0);
745 dump_data->target_version = cpu_to_le32(ar->target_version);
746 dump_data->fw_version_major = cpu_to_le32(ar->fw_version_major);
747 dump_data->fw_version_minor = cpu_to_le32(ar->fw_version_minor);
748 dump_data->fw_version_release = cpu_to_le32(ar->fw_version_release);
749 dump_data->fw_version_build = cpu_to_le32(ar->fw_version_build);
750 dump_data->phy_capability = cpu_to_le32(ar->phy_capability);
751 dump_data->hw_min_tx_power = cpu_to_le32(ar->hw_min_tx_power);
752 dump_data->hw_max_tx_power = cpu_to_le32(ar->hw_max_tx_power);
753 dump_data->ht_cap_info = cpu_to_le32(ar->ht_cap_info);
754 dump_data->vht_cap_info = cpu_to_le32(ar->vht_cap_info);
755 dump_data->num_rf_chains = cpu_to_le32(ar->num_rf_chains);
757 strlcpy(dump_data->fw_ver, ar->hw->wiphy->fw_version,
758 sizeof(dump_data->fw_ver));
760 dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
761 strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
762 sizeof(dump_data->kernel_ver));
764 dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
765 dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
767 /* Gather crash-dump */
768 dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
769 dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGISTERS);
770 dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->registers));
771 memcpy(dump_tlv->tlv_data, &crash_data->registers,
772 sizeof(crash_data->registers));
773 sofar += sizeof(*dump_tlv) + sizeof(crash_data->registers);
775 ar->debug.fw_crash_data->crashed_since_read = false;
777 spin_unlock_bh(&ar->data_lock);
782 static int ath10k_fw_crash_dump_open(struct inode *inode, struct file *file)
784 struct ath10k *ar = inode->i_private;
785 struct ath10k_dump_file_data *dump;
787 dump = ath10k_build_dump_file(ar);
791 file->private_data = dump;
796 static ssize_t ath10k_fw_crash_dump_read(struct file *file,
797 char __user *user_buf,
798 size_t count, loff_t *ppos)
800 struct ath10k_dump_file_data *dump_file = file->private_data;
802 return simple_read_from_buffer(user_buf, count, ppos,
804 le32_to_cpu(dump_file->len));
807 static int ath10k_fw_crash_dump_release(struct inode *inode,
810 vfree(file->private_data);
815 static const struct file_operations fops_fw_crash_dump = {
816 .open = ath10k_fw_crash_dump_open,
817 .read = ath10k_fw_crash_dump_read,
818 .release = ath10k_fw_crash_dump_release,
819 .owner = THIS_MODULE,
820 .llseek = default_llseek,
823 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
828 lockdep_assert_held(&ar->conf_mutex);
830 if (ar->debug.htt_stats_mask == 0)
831 /* htt stats are disabled */
834 if (ar->state != ATH10K_STATE_ON)
837 cookie = get_jiffies_64();
839 ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
842 ath10k_warn("failed to send htt stats request: %d\n", ret);
846 queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
847 msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
852 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
854 struct ath10k *ar = container_of(work, struct ath10k,
855 debug.htt_stats_dwork.work);
857 mutex_lock(&ar->conf_mutex);
859 ath10k_debug_htt_stats_req(ar);
861 mutex_unlock(&ar->conf_mutex);
864 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
865 char __user *user_buf,
866 size_t count, loff_t *ppos)
868 struct ath10k *ar = file->private_data;
872 len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
874 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
877 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
878 const char __user *user_buf,
879 size_t count, loff_t *ppos)
881 struct ath10k *ar = file->private_data;
885 ret = kstrtoul_from_user(user_buf, count, 0, &mask);
889 /* max 8 bit masks (for now) */
893 mutex_lock(&ar->conf_mutex);
895 ar->debug.htt_stats_mask = mask;
897 ret = ath10k_debug_htt_stats_req(ar);
904 mutex_unlock(&ar->conf_mutex);
909 static const struct file_operations fops_htt_stats_mask = {
910 .read = ath10k_read_htt_stats_mask,
911 .write = ath10k_write_htt_stats_mask,
913 .owner = THIS_MODULE,
914 .llseek = default_llseek,
917 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
918 char __user *user_buf,
919 size_t count, loff_t *ppos)
921 struct ath10k *ar = file->private_data;
923 u8 amsdu = 3, ampdu = 64;
926 mutex_lock(&ar->conf_mutex);
928 if (ar->debug.htt_max_amsdu)
929 amsdu = ar->debug.htt_max_amsdu;
931 if (ar->debug.htt_max_ampdu)
932 ampdu = ar->debug.htt_max_ampdu;
934 mutex_unlock(&ar->conf_mutex);
936 len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
938 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
941 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
942 const char __user *user_buf,
943 size_t count, loff_t *ppos)
945 struct ath10k *ar = file->private_data;
948 unsigned int amsdu, ampdu;
950 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
952 /* make sure that buf is null terminated */
953 buf[sizeof(buf) - 1] = 0;
955 res = sscanf(buf, "%u %u", &amsdu, &du);
960 mutex_lock(&ar->conf_mutex);
962 res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
967 ar->debug.htt_max_amsdu = amsdu;
968 ar->debug.htt_max_ampdu = ampdu;
971 mutex_unlock(&ar->conf_mutex);
975 static const struct file_operations fops_htt_max_amsdu_ampdu = {
976 .read = ath10k_read_htt_max_amsdu_ampdu,
977 .write = ath10k_write_htt_max_amsdu_ampdu,
979 .owner = THIS_MODULE,
980 .llseek = default_llseek,
983 static ssize_t ath10k_read_fw_dbglog(struct file *file,
984 char __user *user_buf,
985 size_t count, loff_t *ppos)
987 struct ath10k *ar = file->private_data;
991 len = scnprintf(buf, sizeof(buf), "0x%08x\n",
992 ar->debug.fw_dbglog_mask);
994 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
997 static ssize_t ath10k_write_fw_dbglog(struct file *file,
998 const char __user *user_buf,
999 size_t count, loff_t *ppos)
1001 struct ath10k *ar = file->private_data;
1005 ret = kstrtoul_from_user(user_buf, count, 0, &mask);
1009 mutex_lock(&ar->conf_mutex);
1011 ar->debug.fw_dbglog_mask = mask;
1013 if (ar->state == ATH10K_STATE_ON) {
1014 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask);
1016 ath10k_warn("dbglog cfg failed from debugfs: %d\n",
1025 mutex_unlock(&ar->conf_mutex);
1030 static const struct file_operations fops_fw_dbglog = {
1031 .read = ath10k_read_fw_dbglog,
1032 .write = ath10k_write_fw_dbglog,
1033 .open = simple_open,
1034 .owner = THIS_MODULE,
1035 .llseek = default_llseek,
1038 int ath10k_debug_start(struct ath10k *ar)
1042 lockdep_assert_held(&ar->conf_mutex);
1044 ret = ath10k_debug_htt_stats_req(ar);
1046 /* continue normally anyway, this isn't serious */
1047 ath10k_warn("failed to start htt stats workqueue: %d\n", ret);
1049 if (ar->debug.fw_dbglog_mask) {
1050 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask);
1053 ath10k_warn("failed to enable dbglog during start: %d",
1060 void ath10k_debug_stop(struct ath10k *ar)
1062 lockdep_assert_held(&ar->conf_mutex);
1064 /* Must not use _sync to avoid deadlock, we do that in
1065 * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1066 * warning from del_timer(). */
1067 if (ar->debug.htt_stats_mask != 0)
1068 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1070 ar->debug.htt_max_amsdu = 0;
1071 ar->debug.htt_max_ampdu = 0;
1074 static ssize_t ath10k_write_simulate_radar(struct file *file,
1075 const char __user *user_buf,
1076 size_t count, loff_t *ppos)
1078 struct ath10k *ar = file->private_data;
1080 ieee80211_radar_detected(ar->hw);
1085 static const struct file_operations fops_simulate_radar = {
1086 .write = ath10k_write_simulate_radar,
1087 .open = simple_open,
1088 .owner = THIS_MODULE,
1089 .llseek = default_llseek,
1092 #define ATH10K_DFS_STAT(s, p) (\
1093 len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1094 ar->debug.dfs_stats.p))
1096 #define ATH10K_DFS_POOL_STAT(s, p) (\
1097 len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1098 ar->debug.dfs_pool_stats.p))
1100 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1101 size_t count, loff_t *ppos)
1103 int retval = 0, len = 0;
1104 const int size = 8000;
1105 struct ath10k *ar = file->private_data;
1108 buf = kzalloc(size, GFP_KERNEL);
1112 if (!ar->dfs_detector) {
1113 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1117 ar->debug.dfs_pool_stats =
1118 ar->dfs_detector->get_stats(ar->dfs_detector);
1120 len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1122 ATH10K_DFS_STAT("reported phy errors", phy_errors);
1123 ATH10K_DFS_STAT("pulse events reported", pulses_total);
1124 ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1125 ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1126 ATH10K_DFS_STAT("Radars detected", radar_detected);
1128 len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1129 ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1130 ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1131 ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1132 ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1133 ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1134 ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1135 ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1141 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1147 static const struct file_operations fops_dfs_stats = {
1148 .read = ath10k_read_dfs_stats,
1149 .open = simple_open,
1150 .owner = THIS_MODULE,
1151 .llseek = default_llseek,
1154 int ath10k_debug_create(struct ath10k *ar)
1158 ar->debug.fw_crash_data = vzalloc(sizeof(*ar->debug.fw_crash_data));
1159 if (!ar->debug.fw_crash_data) {
1164 ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
1165 ar->hw->wiphy->debugfsdir);
1166 if (!ar->debug.debugfs_phy) {
1168 goto err_free_fw_crash_data;
1171 INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
1172 ath10k_debug_htt_stats_dwork);
1174 init_completion(&ar->debug.event_stats_compl);
1176 debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
1179 debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
1180 &fops_wmi_services);
1182 debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy,
1183 ar, &fops_simulate_fw_crash);
1185 debugfs_create_file("fw_crash_dump", S_IRUSR, ar->debug.debugfs_phy,
1186 ar, &fops_fw_crash_dump);
1188 debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
1191 debugfs_create_file("htt_stats_mask", S_IRUSR, ar->debug.debugfs_phy,
1192 ar, &fops_htt_stats_mask);
1194 debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
1195 ar->debug.debugfs_phy, ar,
1196 &fops_htt_max_amsdu_ampdu);
1198 debugfs_create_file("fw_dbglog", S_IRUSR, ar->debug.debugfs_phy,
1199 ar, &fops_fw_dbglog);
1201 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
1202 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
1203 ar->debug.debugfs_phy, ar,
1204 &fops_simulate_radar);
1206 debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
1207 ar->debug.debugfs_phy,
1208 &ar->dfs_block_radar_events);
1210 debugfs_create_file("dfs_stats", S_IRUSR,
1211 ar->debug.debugfs_phy, ar,
1217 err_free_fw_crash_data:
1218 vfree(ar->debug.fw_crash_data);
1224 void ath10k_debug_destroy(struct ath10k *ar)
1226 vfree(ar->debug.fw_crash_data);
1227 cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
1230 #endif /* CONFIG_ATH10K_DEBUGFS */
1232 #ifdef CONFIG_ATH10K_DEBUG
1233 void ath10k_dbg(enum ath10k_debug_mask mask, const char *fmt, ...)
1235 struct va_format vaf;
1238 va_start(args, fmt);
1243 if (ath10k_debug_mask & mask)
1244 ath10k_printk(KERN_DEBUG, "%pV", &vaf);
1246 trace_ath10k_log_dbg(mask, &vaf);
1250 EXPORT_SYMBOL(ath10k_dbg);
1252 void ath10k_dbg_dump(enum ath10k_debug_mask mask,
1253 const char *msg, const char *prefix,
1254 const void *buf, size_t len)
1256 if (ath10k_debug_mask & mask) {
1258 ath10k_dbg(mask, "%s\n", msg);
1260 print_hex_dump_bytes(prefix, DUMP_PREFIX_OFFSET, buf, len);
1263 /* tracing code doesn't like null strings :/ */
1264 trace_ath10k_log_dbg_dump(msg ? msg : "", prefix ? prefix : "",
1267 EXPORT_SYMBOL(ath10k_dbg_dump);
1269 #endif /* CONFIG_ATH10K_DEBUG */