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/vmalloc.h>
21 #include <linux/utsname.h>
22 #include <linux/crc32.h>
23 #include <linux/firmware.h>
31 #define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
33 #define ATH10K_FW_CRASH_DUMP_VERSION 1
36 * enum ath10k_fw_crash_dump_type - types of data in the dump file
37 * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
39 enum ath10k_fw_crash_dump_type {
40 ATH10K_FW_CRASH_DUMP_REGISTERS = 0,
42 ATH10K_FW_CRASH_DUMP_MAX,
45 struct ath10k_tlv_dump_data {
46 /* see ath10k_fw_crash_dump_type above */
52 /* pad to 32-bit boundaries as needed */
56 struct ath10k_dump_file_data {
57 /* dump file information */
59 /* "ATH10K-FW-DUMP" */
64 /* file dump version */
67 /* some info we can get from ath10k struct that might help */
73 /* 0 for now, in place for later hardware */
76 __le32 target_version;
77 __le32 fw_version_major;
78 __le32 fw_version_minor;
79 __le32 fw_version_release;
80 __le32 fw_version_build;
81 __le32 phy_capability;
82 __le32 hw_min_tx_power;
83 __le32 hw_max_tx_power;
88 /* firmware version string */
89 char fw_ver[ETHTOOL_FWVERS_LEN];
91 /* Kernel related information */
93 /* time-of-day stamp */
96 /* time-of-day stamp, nano-seconds */
99 /* LINUX_VERSION_CODE */
100 __le32 kernel_ver_code;
102 /* VERMAGIC_STRING */
105 /* room for growth w/out changing binary format */
108 /* struct ath10k_tlv_dump_data + more */
112 void ath10k_info(struct ath10k *ar, const char *fmt, ...)
114 struct va_format vaf = {
121 dev_info(ar->dev, "%pV", &vaf);
122 trace_ath10k_log_info(ar, &vaf);
125 EXPORT_SYMBOL(ath10k_info);
127 void ath10k_debug_print_hwfw_info(struct ath10k *ar)
129 const struct firmware *firmware;
130 char fw_features[128] = {};
133 ath10k_core_get_fw_features_str(ar, fw_features, sizeof(fw_features));
135 ath10k_info(ar, "%s target 0x%08x chip_id 0x%08x sub %04x:%04x",
139 ar->id.subsystem_vendor, ar->id.subsystem_device);
141 ath10k_info(ar, "kconfig debug %d debugfs %d tracing %d dfs %d testmode %d\n",
142 config_enabled(CONFIG_ATH10K_DEBUG),
143 config_enabled(CONFIG_ATH10K_DEBUGFS),
144 config_enabled(CONFIG_ATH10K_TRACING),
145 config_enabled(CONFIG_ATH10K_DFS_CERTIFIED),
146 config_enabled(CONFIG_NL80211_TESTMODE));
148 firmware = ar->normal_mode_fw.fw_file.firmware;
150 crc = crc32_le(0, firmware->data, firmware->size);
152 ath10k_info(ar, "firmware ver %s api %d features %s crc32 %08x\n",
153 ar->hw->wiphy->fw_version,
159 void ath10k_debug_print_board_info(struct ath10k *ar)
163 if (ar->id.bmi_ids_valid)
164 scnprintf(boardinfo, sizeof(boardinfo), "%d:%d",
165 ar->id.bmi_chip_id, ar->id.bmi_board_id);
167 scnprintf(boardinfo, sizeof(boardinfo), "N/A");
169 ath10k_info(ar, "board_file api %d bmi_id %s crc32 %08x",
172 crc32_le(0, ar->normal_mode_fw.board->data,
173 ar->normal_mode_fw.board->size));
176 void ath10k_debug_print_boot_info(struct ath10k *ar)
178 ath10k_info(ar, "htt-ver %d.%d wmi-op %d htt-op %d cal %s max-sta %d raw %d hwcrypto %d\n",
179 ar->htt.target_version_major,
180 ar->htt.target_version_minor,
183 ath10k_cal_mode_str(ar->cal_mode),
184 ar->max_num_stations,
185 test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags),
186 !test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags));
189 void ath10k_print_driver_info(struct ath10k *ar)
191 ath10k_debug_print_hwfw_info(ar);
192 ath10k_debug_print_board_info(ar);
193 ath10k_debug_print_boot_info(ar);
195 EXPORT_SYMBOL(ath10k_print_driver_info);
197 void ath10k_err(struct ath10k *ar, const char *fmt, ...)
199 struct va_format vaf = {
206 dev_err(ar->dev, "%pV", &vaf);
207 trace_ath10k_log_err(ar, &vaf);
210 EXPORT_SYMBOL(ath10k_err);
212 void ath10k_warn(struct ath10k *ar, const char *fmt, ...)
214 struct va_format vaf = {
221 dev_warn_ratelimited(ar->dev, "%pV", &vaf);
222 trace_ath10k_log_warn(ar, &vaf);
226 EXPORT_SYMBOL(ath10k_warn);
228 #ifdef CONFIG_ATH10K_DEBUGFS
230 static ssize_t ath10k_read_wmi_services(struct file *file,
231 char __user *user_buf,
232 size_t count, loff_t *ppos)
234 struct ath10k *ar = file->private_data;
236 unsigned int len = 0, buf_len = 4096;
242 buf = kzalloc(buf_len, GFP_KERNEL);
246 mutex_lock(&ar->conf_mutex);
251 spin_lock_bh(&ar->data_lock);
252 for (i = 0; i < WMI_SERVICE_MAX; i++) {
253 enabled = test_bit(i, ar->wmi.svc_map);
254 name = wmi_service_name(i);
258 len += scnprintf(buf + len, buf_len - len,
259 "%-40s %s (bit %d)\n",
260 "unknown", "enabled", i);
265 len += scnprintf(buf + len, buf_len - len,
267 name, enabled ? "enabled" : "-");
269 spin_unlock_bh(&ar->data_lock);
271 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
273 mutex_unlock(&ar->conf_mutex);
279 static const struct file_operations fops_wmi_services = {
280 .read = ath10k_read_wmi_services,
282 .owner = THIS_MODULE,
283 .llseek = default_llseek,
286 static void ath10k_fw_stats_pdevs_free(struct list_head *head)
288 struct ath10k_fw_stats_pdev *i, *tmp;
290 list_for_each_entry_safe(i, tmp, head, list) {
296 static void ath10k_fw_stats_vdevs_free(struct list_head *head)
298 struct ath10k_fw_stats_vdev *i, *tmp;
300 list_for_each_entry_safe(i, tmp, head, list) {
306 static void ath10k_fw_stats_peers_free(struct list_head *head)
308 struct ath10k_fw_stats_peer *i, *tmp;
310 list_for_each_entry_safe(i, tmp, head, list) {
316 static void ath10k_debug_fw_stats_reset(struct ath10k *ar)
318 spin_lock_bh(&ar->data_lock);
319 ar->debug.fw_stats_done = false;
320 ath10k_fw_stats_pdevs_free(&ar->debug.fw_stats.pdevs);
321 ath10k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
322 ath10k_fw_stats_peers_free(&ar->debug.fw_stats.peers);
323 spin_unlock_bh(&ar->data_lock);
326 void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
328 struct ath10k_fw_stats stats = {};
329 bool is_start, is_started, is_end;
334 INIT_LIST_HEAD(&stats.pdevs);
335 INIT_LIST_HEAD(&stats.vdevs);
336 INIT_LIST_HEAD(&stats.peers);
338 spin_lock_bh(&ar->data_lock);
339 ret = ath10k_wmi_pull_fw_stats(ar, skb, &stats);
341 ath10k_warn(ar, "failed to pull fw stats: %d\n", ret);
345 /* Stat data may exceed htc-wmi buffer limit. In such case firmware
346 * splits the stats data and delivers it in a ping-pong fashion of
347 * request cmd-update event.
349 * However there is no explicit end-of-data. Instead start-of-data is
350 * used as an implicit one. This works as follows:
351 * a) discard stat update events until one with pdev stats is
352 * delivered - this skips session started at end of (b)
353 * b) consume stat update events until another one with pdev stats is
354 * delivered which is treated as end-of-data and is itself discarded
356 if (ath10k_peer_stats_enabled(ar))
357 ath10k_sta_update_rx_duration(ar, &stats.peers);
359 if (ar->debug.fw_stats_done) {
360 if (!ath10k_peer_stats_enabled(ar))
361 ath10k_warn(ar, "received unsolicited stats update event\n");
366 num_peers = ath10k_wmi_fw_stats_num_peers(&ar->debug.fw_stats.peers);
367 num_vdevs = ath10k_wmi_fw_stats_num_vdevs(&ar->debug.fw_stats.vdevs);
368 is_start = (list_empty(&ar->debug.fw_stats.pdevs) &&
369 !list_empty(&stats.pdevs));
370 is_end = (!list_empty(&ar->debug.fw_stats.pdevs) &&
371 !list_empty(&stats.pdevs));
374 list_splice_tail_init(&stats.pdevs, &ar->debug.fw_stats.pdevs);
377 ar->debug.fw_stats_done = true;
379 is_started = !list_empty(&ar->debug.fw_stats.pdevs);
381 if (is_started && !is_end) {
382 if (num_peers >= ATH10K_MAX_NUM_PEER_IDS) {
383 /* Although this is unlikely impose a sane limit to
384 * prevent firmware from DoS-ing the host.
386 ath10k_fw_stats_peers_free(&ar->debug.fw_stats.peers);
387 ath10k_warn(ar, "dropping fw peer stats\n");
391 if (num_vdevs >= BITS_PER_LONG) {
392 ath10k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
393 ath10k_warn(ar, "dropping fw vdev stats\n");
397 list_splice_tail_init(&stats.peers, &ar->debug.fw_stats.peers);
398 list_splice_tail_init(&stats.vdevs, &ar->debug.fw_stats.vdevs);
401 complete(&ar->debug.fw_stats_complete);
404 /* In some cases lists have been spliced and cleared. Free up
405 * resources if that is not the case.
407 ath10k_fw_stats_pdevs_free(&stats.pdevs);
408 ath10k_fw_stats_vdevs_free(&stats.vdevs);
409 ath10k_fw_stats_peers_free(&stats.peers);
411 spin_unlock_bh(&ar->data_lock);
414 static int ath10k_debug_fw_stats_request(struct ath10k *ar)
416 unsigned long timeout, time_left;
419 lockdep_assert_held(&ar->conf_mutex);
421 timeout = jiffies + msecs_to_jiffies(1 * HZ);
423 ath10k_debug_fw_stats_reset(ar);
426 if (time_after(jiffies, timeout))
429 reinit_completion(&ar->debug.fw_stats_complete);
431 ret = ath10k_wmi_request_stats(ar, ar->fw_stats_req_mask);
433 ath10k_warn(ar, "could not request stats (%d)\n", ret);
438 wait_for_completion_timeout(&ar->debug.fw_stats_complete,
443 spin_lock_bh(&ar->data_lock);
444 if (ar->debug.fw_stats_done) {
445 spin_unlock_bh(&ar->data_lock);
448 spin_unlock_bh(&ar->data_lock);
454 static int ath10k_fw_stats_open(struct inode *inode, struct file *file)
456 struct ath10k *ar = inode->i_private;
460 mutex_lock(&ar->conf_mutex);
462 if (ar->state != ATH10K_STATE_ON) {
467 buf = vmalloc(ATH10K_FW_STATS_BUF_SIZE);
473 ret = ath10k_debug_fw_stats_request(ar);
475 ath10k_warn(ar, "failed to request fw stats: %d\n", ret);
479 ret = ath10k_wmi_fw_stats_fill(ar, &ar->debug.fw_stats, buf);
481 ath10k_warn(ar, "failed to fill fw stats: %d\n", ret);
485 file->private_data = buf;
487 mutex_unlock(&ar->conf_mutex);
494 mutex_unlock(&ar->conf_mutex);
498 static int ath10k_fw_stats_release(struct inode *inode, struct file *file)
500 vfree(file->private_data);
505 static ssize_t ath10k_fw_stats_read(struct file *file, char __user *user_buf,
506 size_t count, loff_t *ppos)
508 const char *buf = file->private_data;
509 unsigned int len = strlen(buf);
511 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
514 static const struct file_operations fops_fw_stats = {
515 .open = ath10k_fw_stats_open,
516 .release = ath10k_fw_stats_release,
517 .read = ath10k_fw_stats_read,
518 .owner = THIS_MODULE,
519 .llseek = default_llseek,
522 static ssize_t ath10k_debug_fw_reset_stats_read(struct file *file,
523 char __user *user_buf,
524 size_t count, loff_t *ppos)
526 struct ath10k *ar = file->private_data;
527 int ret, len, buf_len;
531 buf = kmalloc(buf_len, GFP_KERNEL);
535 spin_lock_bh(&ar->data_lock);
538 len += scnprintf(buf + len, buf_len - len,
539 "fw_crash_counter\t\t%d\n", ar->stats.fw_crash_counter);
540 len += scnprintf(buf + len, buf_len - len,
541 "fw_warm_reset_counter\t\t%d\n",
542 ar->stats.fw_warm_reset_counter);
543 len += scnprintf(buf + len, buf_len - len,
544 "fw_cold_reset_counter\t\t%d\n",
545 ar->stats.fw_cold_reset_counter);
547 spin_unlock_bh(&ar->data_lock);
549 ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
556 static const struct file_operations fops_fw_reset_stats = {
558 .read = ath10k_debug_fw_reset_stats_read,
559 .owner = THIS_MODULE,
560 .llseek = default_llseek,
563 /* This is a clean assert crash in firmware. */
564 static int ath10k_debug_fw_assert(struct ath10k *ar)
566 struct wmi_vdev_install_key_cmd *cmd;
569 skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd) + 16);
573 cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
574 memset(cmd, 0, sizeof(*cmd));
576 /* big enough number so that firmware asserts */
577 cmd->vdev_id = __cpu_to_le32(0x7ffe);
579 return ath10k_wmi_cmd_send(ar, skb,
580 ar->wmi.cmd->vdev_install_key_cmdid);
583 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
584 char __user *user_buf,
585 size_t count, loff_t *ppos)
588 "To simulate firmware crash write one of the keywords to this file:\n"
589 "`soft` - this will send WMI_FORCE_FW_HANG_ASSERT to firmware if FW supports that command.\n"
590 "`hard` - this will send to firmware command with illegal parameters causing firmware crash.\n"
591 "`assert` - this will send special illegal parameter to firmware to cause assert failure and crash.\n"
592 "`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n";
594 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
597 /* Simulate firmware crash:
598 * 'soft': Call wmi command causing firmware hang. This firmware hang is
599 * recoverable by warm firmware reset.
600 * 'hard': Force firmware crash by setting any vdev parameter for not allowed
601 * vdev id. This is hard firmware crash because it is recoverable only by cold
604 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
605 const char __user *user_buf,
606 size_t count, loff_t *ppos)
608 struct ath10k *ar = file->private_data;
612 mutex_lock(&ar->conf_mutex);
614 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
616 /* make sure that buf is null terminated */
617 buf[sizeof(buf) - 1] = 0;
619 if (ar->state != ATH10K_STATE_ON &&
620 ar->state != ATH10K_STATE_RESTARTED) {
625 /* drop the possible '\n' from the end */
626 if (buf[count - 1] == '\n') {
631 if (!strcmp(buf, "soft")) {
632 ath10k_info(ar, "simulating soft firmware crash\n");
633 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
634 } else if (!strcmp(buf, "hard")) {
635 ath10k_info(ar, "simulating hard firmware crash\n");
636 /* 0x7fff is vdev id, and it is always out of range for all
637 * firmware variants in order to force a firmware crash.
639 ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
640 ar->wmi.vdev_param->rts_threshold,
642 } else if (!strcmp(buf, "assert")) {
643 ath10k_info(ar, "simulating firmware assert crash\n");
644 ret = ath10k_debug_fw_assert(ar);
645 } else if (!strcmp(buf, "hw-restart")) {
646 ath10k_info(ar, "user requested hw restart\n");
647 queue_work(ar->workqueue, &ar->restart_work);
655 ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
662 mutex_unlock(&ar->conf_mutex);
666 static const struct file_operations fops_simulate_fw_crash = {
667 .read = ath10k_read_simulate_fw_crash,
668 .write = ath10k_write_simulate_fw_crash,
670 .owner = THIS_MODULE,
671 .llseek = default_llseek,
674 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
675 size_t count, loff_t *ppos)
677 struct ath10k *ar = file->private_data;
681 len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->chip_id);
683 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
686 static const struct file_operations fops_chip_id = {
687 .read = ath10k_read_chip_id,
689 .owner = THIS_MODULE,
690 .llseek = default_llseek,
693 struct ath10k_fw_crash_data *
694 ath10k_debug_get_new_fw_crash_data(struct ath10k *ar)
696 struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
698 lockdep_assert_held(&ar->data_lock);
700 crash_data->crashed_since_read = true;
701 uuid_le_gen(&crash_data->uuid);
702 getnstimeofday(&crash_data->timestamp);
706 EXPORT_SYMBOL(ath10k_debug_get_new_fw_crash_data);
708 static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
710 struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
711 struct ath10k_dump_file_data *dump_data;
712 struct ath10k_tlv_dump_data *dump_tlv;
713 int hdr_len = sizeof(*dump_data);
714 unsigned int len, sofar = 0;
718 len += sizeof(*dump_tlv) + sizeof(crash_data->registers);
722 /* This is going to get big when we start dumping FW RAM and such,
723 * so go ahead and use vmalloc.
729 spin_lock_bh(&ar->data_lock);
731 if (!crash_data->crashed_since_read) {
732 spin_unlock_bh(&ar->data_lock);
737 dump_data = (struct ath10k_dump_file_data *)(buf);
738 strlcpy(dump_data->df_magic, "ATH10K-FW-DUMP",
739 sizeof(dump_data->df_magic));
740 dump_data->len = cpu_to_le32(len);
742 dump_data->version = cpu_to_le32(ATH10K_FW_CRASH_DUMP_VERSION);
744 memcpy(dump_data->uuid, &crash_data->uuid, sizeof(dump_data->uuid));
745 dump_data->chip_id = cpu_to_le32(ar->chip_id);
746 dump_data->bus_type = cpu_to_le32(0);
747 dump_data->target_version = cpu_to_le32(ar->target_version);
748 dump_data->fw_version_major = cpu_to_le32(ar->fw_version_major);
749 dump_data->fw_version_minor = cpu_to_le32(ar->fw_version_minor);
750 dump_data->fw_version_release = cpu_to_le32(ar->fw_version_release);
751 dump_data->fw_version_build = cpu_to_le32(ar->fw_version_build);
752 dump_data->phy_capability = cpu_to_le32(ar->phy_capability);
753 dump_data->hw_min_tx_power = cpu_to_le32(ar->hw_min_tx_power);
754 dump_data->hw_max_tx_power = cpu_to_le32(ar->hw_max_tx_power);
755 dump_data->ht_cap_info = cpu_to_le32(ar->ht_cap_info);
756 dump_data->vht_cap_info = cpu_to_le32(ar->vht_cap_info);
757 dump_data->num_rf_chains = cpu_to_le32(ar->num_rf_chains);
759 strlcpy(dump_data->fw_ver, ar->hw->wiphy->fw_version,
760 sizeof(dump_data->fw_ver));
762 dump_data->kernel_ver_code = 0;
763 strlcpy(dump_data->kernel_ver, init_utsname()->release,
764 sizeof(dump_data->kernel_ver));
766 dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
767 dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
769 /* Gather crash-dump */
770 dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
771 dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGISTERS);
772 dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->registers));
773 memcpy(dump_tlv->tlv_data, &crash_data->registers,
774 sizeof(crash_data->registers));
775 sofar += sizeof(*dump_tlv) + sizeof(crash_data->registers);
777 ar->debug.fw_crash_data->crashed_since_read = false;
779 spin_unlock_bh(&ar->data_lock);
784 static int ath10k_fw_crash_dump_open(struct inode *inode, struct file *file)
786 struct ath10k *ar = inode->i_private;
787 struct ath10k_dump_file_data *dump;
789 dump = ath10k_build_dump_file(ar);
793 file->private_data = dump;
798 static ssize_t ath10k_fw_crash_dump_read(struct file *file,
799 char __user *user_buf,
800 size_t count, loff_t *ppos)
802 struct ath10k_dump_file_data *dump_file = file->private_data;
804 return simple_read_from_buffer(user_buf, count, ppos,
806 le32_to_cpu(dump_file->len));
809 static int ath10k_fw_crash_dump_release(struct inode *inode,
812 vfree(file->private_data);
817 static const struct file_operations fops_fw_crash_dump = {
818 .open = ath10k_fw_crash_dump_open,
819 .read = ath10k_fw_crash_dump_read,
820 .release = ath10k_fw_crash_dump_release,
821 .owner = THIS_MODULE,
822 .llseek = default_llseek,
825 static ssize_t ath10k_reg_addr_read(struct file *file,
826 char __user *user_buf,
827 size_t count, loff_t *ppos)
829 struct ath10k *ar = file->private_data;
831 unsigned int len = 0;
834 mutex_lock(&ar->conf_mutex);
835 reg_addr = ar->debug.reg_addr;
836 mutex_unlock(&ar->conf_mutex);
838 len += scnprintf(buf + len, sizeof(buf) - len, "0x%x\n", reg_addr);
840 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
843 static ssize_t ath10k_reg_addr_write(struct file *file,
844 const char __user *user_buf,
845 size_t count, loff_t *ppos)
847 struct ath10k *ar = file->private_data;
851 ret = kstrtou32_from_user(user_buf, count, 0, ®_addr);
855 if (!IS_ALIGNED(reg_addr, 4))
858 mutex_lock(&ar->conf_mutex);
859 ar->debug.reg_addr = reg_addr;
860 mutex_unlock(&ar->conf_mutex);
865 static const struct file_operations fops_reg_addr = {
866 .read = ath10k_reg_addr_read,
867 .write = ath10k_reg_addr_write,
869 .owner = THIS_MODULE,
870 .llseek = default_llseek,
873 static ssize_t ath10k_reg_value_read(struct file *file,
874 char __user *user_buf,
875 size_t count, loff_t *ppos)
877 struct ath10k *ar = file->private_data;
880 u32 reg_addr, reg_val;
883 mutex_lock(&ar->conf_mutex);
885 if (ar->state != ATH10K_STATE_ON &&
886 ar->state != ATH10K_STATE_UTF) {
891 reg_addr = ar->debug.reg_addr;
893 reg_val = ath10k_hif_read32(ar, reg_addr);
894 len = scnprintf(buf, sizeof(buf), "0x%08x:0x%08x\n", reg_addr, reg_val);
896 ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
899 mutex_unlock(&ar->conf_mutex);
904 static ssize_t ath10k_reg_value_write(struct file *file,
905 const char __user *user_buf,
906 size_t count, loff_t *ppos)
908 struct ath10k *ar = file->private_data;
909 u32 reg_addr, reg_val;
912 mutex_lock(&ar->conf_mutex);
914 if (ar->state != ATH10K_STATE_ON &&
915 ar->state != ATH10K_STATE_UTF) {
920 reg_addr = ar->debug.reg_addr;
922 ret = kstrtou32_from_user(user_buf, count, 0, ®_val);
926 ath10k_hif_write32(ar, reg_addr, reg_val);
931 mutex_unlock(&ar->conf_mutex);
936 static const struct file_operations fops_reg_value = {
937 .read = ath10k_reg_value_read,
938 .write = ath10k_reg_value_write,
940 .owner = THIS_MODULE,
941 .llseek = default_llseek,
944 static ssize_t ath10k_mem_value_read(struct file *file,
945 char __user *user_buf,
946 size_t count, loff_t *ppos)
948 struct ath10k *ar = file->private_data;
958 mutex_lock(&ar->conf_mutex);
960 buf = vmalloc(count);
966 if (ar->state != ATH10K_STATE_ON &&
967 ar->state != ATH10K_STATE_UTF) {
972 ret = ath10k_hif_diag_read(ar, *ppos, buf, count);
974 ath10k_warn(ar, "failed to read address 0x%08x via diagnose window fnrom debugfs: %d\n",
979 ret = copy_to_user(user_buf, buf, count);
991 mutex_unlock(&ar->conf_mutex);
996 static ssize_t ath10k_mem_value_write(struct file *file,
997 const char __user *user_buf,
998 size_t count, loff_t *ppos)
1000 struct ath10k *ar = file->private_data;
1010 mutex_lock(&ar->conf_mutex);
1012 buf = vmalloc(count);
1018 if (ar->state != ATH10K_STATE_ON &&
1019 ar->state != ATH10K_STATE_UTF) {
1024 ret = copy_from_user(buf, user_buf, count);
1030 ret = ath10k_hif_diag_write(ar, *ppos, buf, count);
1032 ath10k_warn(ar, "failed to write address 0x%08x via diagnose window from debugfs: %d\n",
1042 mutex_unlock(&ar->conf_mutex);
1047 static const struct file_operations fops_mem_value = {
1048 .read = ath10k_mem_value_read,
1049 .write = ath10k_mem_value_write,
1050 .open = simple_open,
1051 .owner = THIS_MODULE,
1052 .llseek = default_llseek,
1055 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
1060 lockdep_assert_held(&ar->conf_mutex);
1062 if (ar->debug.htt_stats_mask == 0)
1063 /* htt stats are disabled */
1066 if (ar->state != ATH10K_STATE_ON)
1069 cookie = get_jiffies_64();
1071 ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
1074 ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
1078 queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
1079 msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
1084 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
1086 struct ath10k *ar = container_of(work, struct ath10k,
1087 debug.htt_stats_dwork.work);
1089 mutex_lock(&ar->conf_mutex);
1091 ath10k_debug_htt_stats_req(ar);
1093 mutex_unlock(&ar->conf_mutex);
1096 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
1097 char __user *user_buf,
1098 size_t count, loff_t *ppos)
1100 struct ath10k *ar = file->private_data;
1104 len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
1106 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1109 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
1110 const char __user *user_buf,
1111 size_t count, loff_t *ppos)
1113 struct ath10k *ar = file->private_data;
1117 ret = kstrtoul_from_user(user_buf, count, 0, &mask);
1121 /* max 8 bit masks (for now) */
1125 mutex_lock(&ar->conf_mutex);
1127 ar->debug.htt_stats_mask = mask;
1129 ret = ath10k_debug_htt_stats_req(ar);
1136 mutex_unlock(&ar->conf_mutex);
1141 static const struct file_operations fops_htt_stats_mask = {
1142 .read = ath10k_read_htt_stats_mask,
1143 .write = ath10k_write_htt_stats_mask,
1144 .open = simple_open,
1145 .owner = THIS_MODULE,
1146 .llseek = default_llseek,
1149 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
1150 char __user *user_buf,
1151 size_t count, loff_t *ppos)
1153 struct ath10k *ar = file->private_data;
1158 mutex_lock(&ar->conf_mutex);
1160 amsdu = ar->htt.max_num_amsdu;
1161 ampdu = ar->htt.max_num_ampdu;
1162 mutex_unlock(&ar->conf_mutex);
1164 len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
1166 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1169 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
1170 const char __user *user_buf,
1171 size_t count, loff_t *ppos)
1173 struct ath10k *ar = file->private_data;
1176 unsigned int amsdu, ampdu;
1178 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
1180 /* make sure that buf is null terminated */
1181 buf[sizeof(buf) - 1] = 0;
1183 res = sscanf(buf, "%u %u", &amsdu, &du);
1188 mutex_lock(&ar->conf_mutex);
1190 res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
1195 ar->htt.max_num_amsdu = amsdu;
1196 ar->htt.max_num_ampdu = ampdu;
1199 mutex_unlock(&ar->conf_mutex);
1203 static const struct file_operations fops_htt_max_amsdu_ampdu = {
1204 .read = ath10k_read_htt_max_amsdu_ampdu,
1205 .write = ath10k_write_htt_max_amsdu_ampdu,
1206 .open = simple_open,
1207 .owner = THIS_MODULE,
1208 .llseek = default_llseek,
1211 static ssize_t ath10k_read_fw_dbglog(struct file *file,
1212 char __user *user_buf,
1213 size_t count, loff_t *ppos)
1215 struct ath10k *ar = file->private_data;
1219 len = scnprintf(buf, sizeof(buf), "0x%08x %u\n",
1220 ar->debug.fw_dbglog_mask, ar->debug.fw_dbglog_level);
1222 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1225 static ssize_t ath10k_write_fw_dbglog(struct file *file,
1226 const char __user *user_buf,
1227 size_t count, loff_t *ppos)
1229 struct ath10k *ar = file->private_data;
1232 unsigned int log_level, mask;
1234 simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
1236 /* make sure that buf is null terminated */
1237 buf[sizeof(buf) - 1] = 0;
1239 ret = sscanf(buf, "%x %u", &mask, &log_level);
1245 /* default if user did not specify */
1246 log_level = ATH10K_DBGLOG_LEVEL_WARN;
1248 mutex_lock(&ar->conf_mutex);
1250 ar->debug.fw_dbglog_mask = mask;
1251 ar->debug.fw_dbglog_level = log_level;
1253 if (ar->state == ATH10K_STATE_ON) {
1254 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1255 ar->debug.fw_dbglog_level);
1257 ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1266 mutex_unlock(&ar->conf_mutex);
1271 /* TODO: Would be nice to always support ethtool stats, would need to
1272 * move the stats storage out of ath10k_debug, or always have ath10k_debug
1273 * struct available..
1276 /* This generally cooresponds to the debugfs fw_stats file */
1277 static const char ath10k_gstrings_stats[][ETH_GSTRING_LEN] = {
1287 "d_tx_power", /* in .5 dbM I think */
1288 "d_rx_crc_err", /* fcs_bad */
1290 "d_tx_mpdus_queued",
1292 "d_tx_msdu_dropped",
1295 "d_tx_ppdu_hw_queued",
1297 "d_tx_fifo_underrun",
1300 "d_tx_excessive_retries",
1302 "d_tx_dropped_sw_retries",
1303 "d_tx_illegal_rate",
1304 "d_tx_continuous_xretries",
1306 "d_tx_mpdu_txop_limit",
1308 "d_rx_mid_ppdu_route_change",
1310 "d_rx_extra_frags_ring0",
1311 "d_rx_extra_frags_ring1",
1312 "d_rx_extra_frags_ring2",
1313 "d_rx_extra_frags_ring3",
1319 "d_rx_phy_err_drops",
1320 "d_rx_mpdu_errors", /* FCS, MIC, ENC */
1322 "d_fw_warm_reset_count",
1323 "d_fw_cold_reset_count",
1326 #define ATH10K_SSTATS_LEN ARRAY_SIZE(ath10k_gstrings_stats)
1328 void ath10k_debug_get_et_strings(struct ieee80211_hw *hw,
1329 struct ieee80211_vif *vif,
1332 if (sset == ETH_SS_STATS)
1333 memcpy(data, *ath10k_gstrings_stats,
1334 sizeof(ath10k_gstrings_stats));
1337 int ath10k_debug_get_et_sset_count(struct ieee80211_hw *hw,
1338 struct ieee80211_vif *vif, int sset)
1340 if (sset == ETH_SS_STATS)
1341 return ATH10K_SSTATS_LEN;
1346 void ath10k_debug_get_et_stats(struct ieee80211_hw *hw,
1347 struct ieee80211_vif *vif,
1348 struct ethtool_stats *stats, u64 *data)
1350 struct ath10k *ar = hw->priv;
1351 static const struct ath10k_fw_stats_pdev zero_stats = {};
1352 const struct ath10k_fw_stats_pdev *pdev_stats;
1355 mutex_lock(&ar->conf_mutex);
1357 if (ar->state == ATH10K_STATE_ON) {
1358 ret = ath10k_debug_fw_stats_request(ar);
1360 /* just print a warning and try to use older results */
1362 "failed to get fw stats for ethtool: %d\n",
1367 pdev_stats = list_first_entry_or_null(&ar->debug.fw_stats.pdevs,
1368 struct ath10k_fw_stats_pdev,
1371 /* no results available so just return zeroes */
1372 pdev_stats = &zero_stats;
1375 spin_lock_bh(&ar->data_lock);
1377 data[i++] = pdev_stats->hw_reaped; /* ppdu reaped */
1378 data[i++] = 0; /* tx bytes */
1379 data[i++] = pdev_stats->htt_mpdus;
1380 data[i++] = 0; /* rx bytes */
1381 data[i++] = pdev_stats->ch_noise_floor;
1382 data[i++] = pdev_stats->cycle_count;
1383 data[i++] = pdev_stats->phy_err_count;
1384 data[i++] = pdev_stats->rts_bad;
1385 data[i++] = pdev_stats->rts_good;
1386 data[i++] = pdev_stats->chan_tx_power;
1387 data[i++] = pdev_stats->fcs_bad;
1388 data[i++] = pdev_stats->no_beacons;
1389 data[i++] = pdev_stats->mpdu_enqued;
1390 data[i++] = pdev_stats->msdu_enqued;
1391 data[i++] = pdev_stats->wmm_drop;
1392 data[i++] = pdev_stats->local_enqued;
1393 data[i++] = pdev_stats->local_freed;
1394 data[i++] = pdev_stats->hw_queued;
1395 data[i++] = pdev_stats->hw_reaped;
1396 data[i++] = pdev_stats->underrun;
1397 data[i++] = pdev_stats->tx_abort;
1398 data[i++] = pdev_stats->mpdus_requed;
1399 data[i++] = pdev_stats->tx_ko;
1400 data[i++] = pdev_stats->data_rc;
1401 data[i++] = pdev_stats->sw_retry_failure;
1402 data[i++] = pdev_stats->illgl_rate_phy_err;
1403 data[i++] = pdev_stats->pdev_cont_xretry;
1404 data[i++] = pdev_stats->pdev_tx_timeout;
1405 data[i++] = pdev_stats->txop_ovf;
1406 data[i++] = pdev_stats->pdev_resets;
1407 data[i++] = pdev_stats->mid_ppdu_route_change;
1408 data[i++] = pdev_stats->status_rcvd;
1409 data[i++] = pdev_stats->r0_frags;
1410 data[i++] = pdev_stats->r1_frags;
1411 data[i++] = pdev_stats->r2_frags;
1412 data[i++] = pdev_stats->r3_frags;
1413 data[i++] = pdev_stats->htt_msdus;
1414 data[i++] = pdev_stats->htt_mpdus;
1415 data[i++] = pdev_stats->loc_msdus;
1416 data[i++] = pdev_stats->loc_mpdus;
1417 data[i++] = pdev_stats->phy_errs;
1418 data[i++] = pdev_stats->phy_err_drop;
1419 data[i++] = pdev_stats->mpdu_errs;
1420 data[i++] = ar->stats.fw_crash_counter;
1421 data[i++] = ar->stats.fw_warm_reset_counter;
1422 data[i++] = ar->stats.fw_cold_reset_counter;
1424 spin_unlock_bh(&ar->data_lock);
1426 mutex_unlock(&ar->conf_mutex);
1428 WARN_ON(i != ATH10K_SSTATS_LEN);
1431 static const struct file_operations fops_fw_dbglog = {
1432 .read = ath10k_read_fw_dbglog,
1433 .write = ath10k_write_fw_dbglog,
1434 .open = simple_open,
1435 .owner = THIS_MODULE,
1436 .llseek = default_llseek,
1439 static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
1441 struct ath10k *ar = inode->i_private;
1447 mutex_lock(&ar->conf_mutex);
1449 if (ar->state != ATH10K_STATE_ON &&
1450 ar->state != ATH10K_STATE_UTF) {
1455 buf = vmalloc(ar->hw_params.cal_data_len);
1461 hi_addr = host_interest_item_address(HI_ITEM(hi_board_data));
1463 ret = ath10k_hif_diag_read(ar, hi_addr, &addr, sizeof(addr));
1465 ath10k_warn(ar, "failed to read hi_board_data address: %d\n", ret);
1469 ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), buf,
1470 ar->hw_params.cal_data_len);
1472 ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
1476 file->private_data = buf;
1478 mutex_unlock(&ar->conf_mutex);
1486 mutex_unlock(&ar->conf_mutex);
1491 static ssize_t ath10k_debug_cal_data_read(struct file *file,
1492 char __user *user_buf,
1493 size_t count, loff_t *ppos)
1495 struct ath10k *ar = file->private_data;
1496 void *buf = file->private_data;
1498 return simple_read_from_buffer(user_buf, count, ppos,
1499 buf, ar->hw_params.cal_data_len);
1502 static int ath10k_debug_cal_data_release(struct inode *inode,
1505 vfree(file->private_data);
1510 static ssize_t ath10k_write_ani_enable(struct file *file,
1511 const char __user *user_buf,
1512 size_t count, loff_t *ppos)
1514 struct ath10k *ar = file->private_data;
1518 if (kstrtou8_from_user(user_buf, count, 0, &enable))
1521 mutex_lock(&ar->conf_mutex);
1523 if (ar->ani_enabled == enable) {
1528 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->ani_enable,
1531 ath10k_warn(ar, "ani_enable failed from debugfs: %d\n", ret);
1534 ar->ani_enabled = enable;
1539 mutex_unlock(&ar->conf_mutex);
1544 static ssize_t ath10k_read_ani_enable(struct file *file, char __user *user_buf,
1545 size_t count, loff_t *ppos)
1547 struct ath10k *ar = file->private_data;
1551 len = scnprintf(buf, sizeof(buf) - len, "%d\n",
1554 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1557 static const struct file_operations fops_ani_enable = {
1558 .read = ath10k_read_ani_enable,
1559 .write = ath10k_write_ani_enable,
1560 .open = simple_open,
1561 .owner = THIS_MODULE,
1562 .llseek = default_llseek,
1565 static const struct file_operations fops_cal_data = {
1566 .open = ath10k_debug_cal_data_open,
1567 .read = ath10k_debug_cal_data_read,
1568 .release = ath10k_debug_cal_data_release,
1569 .owner = THIS_MODULE,
1570 .llseek = default_llseek,
1573 static ssize_t ath10k_read_nf_cal_period(struct file *file,
1574 char __user *user_buf,
1575 size_t count, loff_t *ppos)
1577 struct ath10k *ar = file->private_data;
1581 len = scnprintf(buf, sizeof(buf), "%d\n",
1582 ar->debug.nf_cal_period);
1584 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1587 static ssize_t ath10k_write_nf_cal_period(struct file *file,
1588 const char __user *user_buf,
1589 size_t count, loff_t *ppos)
1591 struct ath10k *ar = file->private_data;
1592 unsigned long period;
1595 ret = kstrtoul_from_user(user_buf, count, 0, &period);
1599 if (period > WMI_PDEV_PARAM_CAL_PERIOD_MAX)
1602 /* there's no way to switch back to the firmware default */
1606 mutex_lock(&ar->conf_mutex);
1608 ar->debug.nf_cal_period = period;
1610 if (ar->state != ATH10K_STATE_ON) {
1611 /* firmware is not running, nothing else to do */
1616 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->cal_period,
1617 ar->debug.nf_cal_period);
1619 ath10k_warn(ar, "cal period cfg failed from debugfs: %d\n",
1627 mutex_unlock(&ar->conf_mutex);
1632 static const struct file_operations fops_nf_cal_period = {
1633 .read = ath10k_read_nf_cal_period,
1634 .write = ath10k_write_nf_cal_period,
1635 .open = simple_open,
1636 .owner = THIS_MODULE,
1637 .llseek = default_llseek,
1640 #define ATH10K_TPC_CONFIG_BUF_SIZE (1024 * 1024)
1642 static int ath10k_debug_tpc_stats_request(struct ath10k *ar)
1645 unsigned long time_left;
1647 lockdep_assert_held(&ar->conf_mutex);
1649 reinit_completion(&ar->debug.tpc_complete);
1651 ret = ath10k_wmi_pdev_get_tpc_config(ar, WMI_TPC_CONFIG_PARAM);
1653 ath10k_warn(ar, "failed to request tpc config: %d\n", ret);
1657 time_left = wait_for_completion_timeout(&ar->debug.tpc_complete,
1665 void ath10k_debug_tpc_stats_process(struct ath10k *ar,
1666 struct ath10k_tpc_stats *tpc_stats)
1668 spin_lock_bh(&ar->data_lock);
1670 kfree(ar->debug.tpc_stats);
1671 ar->debug.tpc_stats = tpc_stats;
1672 complete(&ar->debug.tpc_complete);
1674 spin_unlock_bh(&ar->data_lock);
1677 static void ath10k_tpc_stats_print(struct ath10k_tpc_stats *tpc_stats,
1678 unsigned int j, char *buf, unsigned int *len)
1680 unsigned int i, buf_len;
1681 static const char table_str[][5] = { "CDD",
1684 static const char pream_str[][6] = { "CCK",
1693 buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1694 *len += scnprintf(buf + *len, buf_len - *len,
1695 "********************************\n");
1696 *len += scnprintf(buf + *len, buf_len - *len,
1697 "******************* %s POWER TABLE ****************\n",
1699 *len += scnprintf(buf + *len, buf_len - *len,
1700 "********************************\n");
1701 *len += scnprintf(buf + *len, buf_len - *len,
1702 "No. Preamble Rate_code tpc_value1 tpc_value2 tpc_value3\n");
1704 for (i = 0; i < tpc_stats->rate_max; i++) {
1705 *len += scnprintf(buf + *len, buf_len - *len,
1706 "%8d %s 0x%2x %s\n", i,
1707 pream_str[tpc_stats->tpc_table[j].pream_idx[i]],
1708 tpc_stats->tpc_table[j].rate_code[i],
1709 tpc_stats->tpc_table[j].tpc_value[i]);
1712 *len += scnprintf(buf + *len, buf_len - *len,
1713 "***********************************\n");
1716 static void ath10k_tpc_stats_fill(struct ath10k *ar,
1717 struct ath10k_tpc_stats *tpc_stats,
1720 unsigned int len, j, buf_len;
1723 buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1725 spin_lock_bh(&ar->data_lock);
1728 ath10k_warn(ar, "failed to get tpc stats\n");
1732 len += scnprintf(buf + len, buf_len - len, "\n");
1733 len += scnprintf(buf + len, buf_len - len,
1734 "*************************************\n");
1735 len += scnprintf(buf + len, buf_len - len,
1736 "TPC config for channel %4d mode %d\n",
1737 tpc_stats->chan_freq,
1738 tpc_stats->phy_mode);
1739 len += scnprintf(buf + len, buf_len - len,
1740 "*************************************\n");
1741 len += scnprintf(buf + len, buf_len - len,
1742 "CTL = 0x%2x Reg. Domain = %2d\n",
1744 tpc_stats->reg_domain);
1745 len += scnprintf(buf + len, buf_len - len,
1746 "Antenna Gain = %2d Reg. Max Antenna Gain = %2d\n",
1747 tpc_stats->twice_antenna_gain,
1748 tpc_stats->twice_antenna_reduction);
1749 len += scnprintf(buf + len, buf_len - len,
1750 "Power Limit = %2d Reg. Max Power = %2d\n",
1751 tpc_stats->power_limit,
1752 tpc_stats->twice_max_rd_power / 2);
1753 len += scnprintf(buf + len, buf_len - len,
1754 "Num tx chains = %2d Num supported rates = %2d\n",
1755 tpc_stats->num_tx_chain,
1756 tpc_stats->rate_max);
1758 for (j = 0; j < tpc_stats->num_tx_chain ; j++) {
1760 case WMI_TPC_TABLE_TYPE_CDD:
1761 if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1762 len += scnprintf(buf + len, buf_len - len,
1763 "CDD not supported\n");
1767 ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1769 case WMI_TPC_TABLE_TYPE_STBC:
1770 if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1771 len += scnprintf(buf + len, buf_len - len,
1772 "STBC not supported\n");
1776 ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1778 case WMI_TPC_TABLE_TYPE_TXBF:
1779 if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1780 len += scnprintf(buf + len, buf_len - len,
1781 "TXBF not supported\n***************************\n");
1785 ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1788 len += scnprintf(buf + len, buf_len - len,
1795 spin_unlock_bh(&ar->data_lock);
1803 static int ath10k_tpc_stats_open(struct inode *inode, struct file *file)
1805 struct ath10k *ar = inode->i_private;
1809 mutex_lock(&ar->conf_mutex);
1811 if (ar->state != ATH10K_STATE_ON) {
1816 buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
1822 ret = ath10k_debug_tpc_stats_request(ar);
1824 ath10k_warn(ar, "failed to request tpc config stats: %d\n",
1829 ath10k_tpc_stats_fill(ar, ar->debug.tpc_stats, buf);
1830 file->private_data = buf;
1832 mutex_unlock(&ar->conf_mutex);
1839 mutex_unlock(&ar->conf_mutex);
1843 static int ath10k_tpc_stats_release(struct inode *inode, struct file *file)
1845 vfree(file->private_data);
1850 static ssize_t ath10k_tpc_stats_read(struct file *file, char __user *user_buf,
1851 size_t count, loff_t *ppos)
1853 const char *buf = file->private_data;
1854 unsigned int len = strlen(buf);
1856 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1859 static const struct file_operations fops_tpc_stats = {
1860 .open = ath10k_tpc_stats_open,
1861 .release = ath10k_tpc_stats_release,
1862 .read = ath10k_tpc_stats_read,
1863 .owner = THIS_MODULE,
1864 .llseek = default_llseek,
1867 int ath10k_debug_start(struct ath10k *ar)
1871 lockdep_assert_held(&ar->conf_mutex);
1873 ret = ath10k_debug_htt_stats_req(ar);
1875 /* continue normally anyway, this isn't serious */
1876 ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1879 if (ar->debug.fw_dbglog_mask) {
1880 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1881 ATH10K_DBGLOG_LEVEL_WARN);
1884 ath10k_warn(ar, "failed to enable dbglog during start: %d",
1888 if (ar->debug.pktlog_filter) {
1889 ret = ath10k_wmi_pdev_pktlog_enable(ar,
1890 ar->debug.pktlog_filter);
1894 "failed to enable pktlog filter %x: %d\n",
1895 ar->debug.pktlog_filter, ret);
1897 ret = ath10k_wmi_pdev_pktlog_disable(ar);
1900 ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1903 if (ar->debug.nf_cal_period) {
1904 ret = ath10k_wmi_pdev_set_param(ar,
1905 ar->wmi.pdev_param->cal_period,
1906 ar->debug.nf_cal_period);
1909 ath10k_warn(ar, "cal period cfg failed from debug start: %d\n",
1916 void ath10k_debug_stop(struct ath10k *ar)
1918 lockdep_assert_held(&ar->conf_mutex);
1920 /* Must not use _sync to avoid deadlock, we do that in
1921 * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1922 * warning from del_timer(). */
1923 if (ar->debug.htt_stats_mask != 0)
1924 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1926 ath10k_wmi_pdev_pktlog_disable(ar);
1929 static ssize_t ath10k_write_simulate_radar(struct file *file,
1930 const char __user *user_buf,
1931 size_t count, loff_t *ppos)
1933 struct ath10k *ar = file->private_data;
1935 ieee80211_radar_detected(ar->hw);
1940 static const struct file_operations fops_simulate_radar = {
1941 .write = ath10k_write_simulate_radar,
1942 .open = simple_open,
1943 .owner = THIS_MODULE,
1944 .llseek = default_llseek,
1947 #define ATH10K_DFS_STAT(s, p) (\
1948 len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1949 ar->debug.dfs_stats.p))
1951 #define ATH10K_DFS_POOL_STAT(s, p) (\
1952 len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1953 ar->debug.dfs_pool_stats.p))
1955 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1956 size_t count, loff_t *ppos)
1958 int retval = 0, len = 0;
1959 const int size = 8000;
1960 struct ath10k *ar = file->private_data;
1963 buf = kzalloc(size, GFP_KERNEL);
1967 if (!ar->dfs_detector) {
1968 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1972 ar->debug.dfs_pool_stats =
1973 ar->dfs_detector->get_stats(ar->dfs_detector);
1975 len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1977 ATH10K_DFS_STAT("reported phy errors", phy_errors);
1978 ATH10K_DFS_STAT("pulse events reported", pulses_total);
1979 ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1980 ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1981 ATH10K_DFS_STAT("Radars detected", radar_detected);
1983 len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1984 ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1985 ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1986 ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1987 ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1988 ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1989 ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1990 ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1996 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
2002 static const struct file_operations fops_dfs_stats = {
2003 .read = ath10k_read_dfs_stats,
2004 .open = simple_open,
2005 .owner = THIS_MODULE,
2006 .llseek = default_llseek,
2009 static ssize_t ath10k_write_pktlog_filter(struct file *file,
2010 const char __user *ubuf,
2011 size_t count, loff_t *ppos)
2013 struct ath10k *ar = file->private_data;
2017 if (kstrtouint_from_user(ubuf, count, 0, &filter))
2020 mutex_lock(&ar->conf_mutex);
2022 if (ar->state != ATH10K_STATE_ON) {
2023 ar->debug.pktlog_filter = filter;
2028 if (filter == ar->debug.pktlog_filter) {
2034 ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
2036 ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
2037 ar->debug.pktlog_filter, ret);
2041 ret = ath10k_wmi_pdev_pktlog_disable(ar);
2043 ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
2048 ar->debug.pktlog_filter = filter;
2052 mutex_unlock(&ar->conf_mutex);
2056 static ssize_t ath10k_read_pktlog_filter(struct file *file, char __user *ubuf,
2057 size_t count, loff_t *ppos)
2060 struct ath10k *ar = file->private_data;
2063 mutex_lock(&ar->conf_mutex);
2064 len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
2065 ar->debug.pktlog_filter);
2066 mutex_unlock(&ar->conf_mutex);
2068 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2071 static const struct file_operations fops_pktlog_filter = {
2072 .read = ath10k_read_pktlog_filter,
2073 .write = ath10k_write_pktlog_filter,
2077 static ssize_t ath10k_write_quiet_period(struct file *file,
2078 const char __user *ubuf,
2079 size_t count, loff_t *ppos)
2081 struct ath10k *ar = file->private_data;
2084 if (kstrtouint_from_user(ubuf, count, 0, &period))
2087 if (period < ATH10K_QUIET_PERIOD_MIN) {
2088 ath10k_warn(ar, "Quiet period %u can not be lesser than 25ms\n",
2092 mutex_lock(&ar->conf_mutex);
2093 ar->thermal.quiet_period = period;
2094 ath10k_thermal_set_throttling(ar);
2095 mutex_unlock(&ar->conf_mutex);
2100 static ssize_t ath10k_read_quiet_period(struct file *file, char __user *ubuf,
2101 size_t count, loff_t *ppos)
2104 struct ath10k *ar = file->private_data;
2107 mutex_lock(&ar->conf_mutex);
2108 len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2109 ar->thermal.quiet_period);
2110 mutex_unlock(&ar->conf_mutex);
2112 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2115 static const struct file_operations fops_quiet_period = {
2116 .read = ath10k_read_quiet_period,
2117 .write = ath10k_write_quiet_period,
2121 static ssize_t ath10k_write_btcoex(struct file *file,
2122 const char __user *ubuf,
2123 size_t count, loff_t *ppos)
2125 struct ath10k *ar = file->private_data;
2131 buf_size = min(count, (sizeof(buf) - 1));
2132 if (copy_from_user(buf, ubuf, buf_size))
2135 buf[buf_size] = '\0';
2137 if (strtobool(buf, &val) != 0)
2140 mutex_lock(&ar->conf_mutex);
2142 if (ar->state != ATH10K_STATE_ON &&
2143 ar->state != ATH10K_STATE_RESTARTED) {
2148 if (!(test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags) ^ val)) {
2154 set_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2156 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2158 ath10k_info(ar, "restarting firmware due to btcoex change");
2160 queue_work(ar->workqueue, &ar->restart_work);
2164 mutex_unlock(&ar->conf_mutex);
2169 static ssize_t ath10k_read_btcoex(struct file *file, char __user *ubuf,
2170 size_t count, loff_t *ppos)
2173 struct ath10k *ar = file->private_data;
2176 mutex_lock(&ar->conf_mutex);
2177 len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2178 test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags));
2179 mutex_unlock(&ar->conf_mutex);
2181 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2184 static const struct file_operations fops_btcoex = {
2185 .read = ath10k_read_btcoex,
2186 .write = ath10k_write_btcoex,
2190 static ssize_t ath10k_write_peer_stats(struct file *file,
2191 const char __user *ubuf,
2192 size_t count, loff_t *ppos)
2194 struct ath10k *ar = file->private_data;
2200 buf_size = min(count, (sizeof(buf) - 1));
2201 if (copy_from_user(buf, ubuf, buf_size))
2204 buf[buf_size] = '\0';
2206 if (strtobool(buf, &val) != 0)
2209 mutex_lock(&ar->conf_mutex);
2211 if (ar->state != ATH10K_STATE_ON &&
2212 ar->state != ATH10K_STATE_RESTARTED) {
2217 if (!(test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) ^ val)) {
2223 set_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2225 clear_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2227 ath10k_info(ar, "restarting firmware due to Peer stats change");
2229 queue_work(ar->workqueue, &ar->restart_work);
2233 mutex_unlock(&ar->conf_mutex);
2237 static ssize_t ath10k_read_peer_stats(struct file *file, char __user *ubuf,
2238 size_t count, loff_t *ppos)
2242 struct ath10k *ar = file->private_data;
2245 mutex_lock(&ar->conf_mutex);
2246 len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2247 test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags));
2248 mutex_unlock(&ar->conf_mutex);
2250 return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2253 static const struct file_operations fops_peer_stats = {
2254 .read = ath10k_read_peer_stats,
2255 .write = ath10k_write_peer_stats,
2259 static ssize_t ath10k_debug_fw_checksums_read(struct file *file,
2260 char __user *user_buf,
2261 size_t count, loff_t *ppos)
2263 struct ath10k *ar = file->private_data;
2264 unsigned int len = 0, buf_len = 4096;
2268 buf = kzalloc(buf_len, GFP_KERNEL);
2272 mutex_lock(&ar->conf_mutex);
2274 len += scnprintf(buf + len, buf_len - len,
2275 "firmware-N.bin\t\t%08x\n",
2276 crc32_le(0, ar->normal_mode_fw.fw_file.firmware->data,
2277 ar->normal_mode_fw.fw_file.firmware->size));
2278 len += scnprintf(buf + len, buf_len - len,
2279 "athwlan\t\t\t%08x\n",
2280 crc32_le(0, ar->normal_mode_fw.fw_file.firmware_data,
2281 ar->normal_mode_fw.fw_file.firmware_len));
2282 len += scnprintf(buf + len, buf_len - len,
2284 crc32_le(0, ar->normal_mode_fw.fw_file.otp_data,
2285 ar->normal_mode_fw.fw_file.otp_len));
2286 len += scnprintf(buf + len, buf_len - len,
2287 "codeswap\t\t%08x\n",
2288 crc32_le(0, ar->normal_mode_fw.fw_file.codeswap_data,
2289 ar->normal_mode_fw.fw_file.codeswap_len));
2290 len += scnprintf(buf + len, buf_len - len,
2291 "board-N.bin\t\t%08x\n",
2292 crc32_le(0, ar->normal_mode_fw.board->data,
2293 ar->normal_mode_fw.board->size));
2294 len += scnprintf(buf + len, buf_len - len,
2295 "board\t\t\t%08x\n",
2296 crc32_le(0, ar->normal_mode_fw.board_data,
2297 ar->normal_mode_fw.board_len));
2299 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
2301 mutex_unlock(&ar->conf_mutex);
2307 static const struct file_operations fops_fw_checksums = {
2308 .read = ath10k_debug_fw_checksums_read,
2309 .open = simple_open,
2310 .owner = THIS_MODULE,
2311 .llseek = default_llseek,
2314 int ath10k_debug_create(struct ath10k *ar)
2316 ar->debug.fw_crash_data = vzalloc(sizeof(*ar->debug.fw_crash_data));
2317 if (!ar->debug.fw_crash_data)
2320 INIT_LIST_HEAD(&ar->debug.fw_stats.pdevs);
2321 INIT_LIST_HEAD(&ar->debug.fw_stats.vdevs);
2322 INIT_LIST_HEAD(&ar->debug.fw_stats.peers);
2327 void ath10k_debug_destroy(struct ath10k *ar)
2329 vfree(ar->debug.fw_crash_data);
2330 ar->debug.fw_crash_data = NULL;
2332 ath10k_debug_fw_stats_reset(ar);
2334 kfree(ar->debug.tpc_stats);
2337 int ath10k_debug_register(struct ath10k *ar)
2339 ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
2340 ar->hw->wiphy->debugfsdir);
2341 if (IS_ERR_OR_NULL(ar->debug.debugfs_phy)) {
2342 if (IS_ERR(ar->debug.debugfs_phy))
2343 return PTR_ERR(ar->debug.debugfs_phy);
2348 INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
2349 ath10k_debug_htt_stats_dwork);
2351 init_completion(&ar->debug.tpc_complete);
2352 init_completion(&ar->debug.fw_stats_complete);
2354 debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
2357 debugfs_create_file("fw_reset_stats", S_IRUSR, ar->debug.debugfs_phy,
2358 ar, &fops_fw_reset_stats);
2360 debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
2361 &fops_wmi_services);
2363 debugfs_create_file("simulate_fw_crash", S_IRUSR | S_IWUSR,
2364 ar->debug.debugfs_phy, ar, &fops_simulate_fw_crash);
2366 debugfs_create_file("fw_crash_dump", S_IRUSR, ar->debug.debugfs_phy,
2367 ar, &fops_fw_crash_dump);
2369 debugfs_create_file("reg_addr", S_IRUSR | S_IWUSR,
2370 ar->debug.debugfs_phy, ar, &fops_reg_addr);
2372 debugfs_create_file("reg_value", S_IRUSR | S_IWUSR,
2373 ar->debug.debugfs_phy, ar, &fops_reg_value);
2375 debugfs_create_file("mem_value", S_IRUSR | S_IWUSR,
2376 ar->debug.debugfs_phy, ar, &fops_mem_value);
2378 debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
2381 debugfs_create_file("htt_stats_mask", S_IRUSR | S_IWUSR,
2382 ar->debug.debugfs_phy, ar, &fops_htt_stats_mask);
2384 debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
2385 ar->debug.debugfs_phy, ar,
2386 &fops_htt_max_amsdu_ampdu);
2388 debugfs_create_file("fw_dbglog", S_IRUSR | S_IWUSR,
2389 ar->debug.debugfs_phy, ar, &fops_fw_dbglog);
2391 debugfs_create_file("cal_data", S_IRUSR, ar->debug.debugfs_phy,
2392 ar, &fops_cal_data);
2394 debugfs_create_file("ani_enable", S_IRUSR | S_IWUSR,
2395 ar->debug.debugfs_phy, ar, &fops_ani_enable);
2397 debugfs_create_file("nf_cal_period", S_IRUSR | S_IWUSR,
2398 ar->debug.debugfs_phy, ar, &fops_nf_cal_period);
2400 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
2401 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
2402 ar->debug.debugfs_phy, ar,
2403 &fops_simulate_radar);
2405 debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
2406 ar->debug.debugfs_phy,
2407 &ar->dfs_block_radar_events);
2409 debugfs_create_file("dfs_stats", S_IRUSR,
2410 ar->debug.debugfs_phy, ar,
2414 debugfs_create_file("pktlog_filter", S_IRUGO | S_IWUSR,
2415 ar->debug.debugfs_phy, ar, &fops_pktlog_filter);
2417 debugfs_create_file("quiet_period", S_IRUGO | S_IWUSR,
2418 ar->debug.debugfs_phy, ar, &fops_quiet_period);
2420 debugfs_create_file("tpc_stats", S_IRUSR,
2421 ar->debug.debugfs_phy, ar, &fops_tpc_stats);
2423 if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
2424 debugfs_create_file("btcoex", S_IRUGO | S_IWUSR,
2425 ar->debug.debugfs_phy, ar, &fops_btcoex);
2427 if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
2428 debugfs_create_file("peer_stats", S_IRUGO | S_IWUSR,
2429 ar->debug.debugfs_phy, ar,
2432 debugfs_create_file("fw_checksums", S_IRUSR,
2433 ar->debug.debugfs_phy, ar, &fops_fw_checksums);
2438 void ath10k_debug_unregister(struct ath10k *ar)
2440 cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
2443 #endif /* CONFIG_ATH10K_DEBUGFS */
2445 #ifdef CONFIG_ATH10K_DEBUG
2446 void ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
2447 const char *fmt, ...)
2449 struct va_format vaf;
2452 va_start(args, fmt);
2457 if (ath10k_debug_mask & mask)
2458 dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
2460 trace_ath10k_log_dbg(ar, mask, &vaf);
2464 EXPORT_SYMBOL(ath10k_dbg);
2466 void ath10k_dbg_dump(struct ath10k *ar,
2467 enum ath10k_debug_mask mask,
2468 const char *msg, const char *prefix,
2469 const void *buf, size_t len)
2472 unsigned int linebuflen;
2475 if (ath10k_debug_mask & mask) {
2477 ath10k_dbg(ar, mask, "%s\n", msg);
2479 for (ptr = buf; (ptr - buf) < len; ptr += 16) {
2481 linebuflen += scnprintf(linebuf + linebuflen,
2482 sizeof(linebuf) - linebuflen,
2484 (prefix ? prefix : ""),
2485 (unsigned int)(ptr - buf));
2486 hex_dump_to_buffer(ptr, len - (ptr - buf), 16, 1,
2487 linebuf + linebuflen,
2488 sizeof(linebuf) - linebuflen, true);
2489 dev_printk(KERN_DEBUG, ar->dev, "%s\n", linebuf);
2493 /* tracing code doesn't like null strings :/ */
2494 trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
2497 EXPORT_SYMBOL(ath10k_dbg_dump);
2499 #endif /* CONFIG_ATH10K_DEBUG */