| // SPDX-License-Identifier: BSD-3-Clause-Clear | |
| /* | |
| * Copyright (c) 2018-2020 The Linux Foundation. All rights reserved. | |
| */ | |
| #include "debugfs.h" | |
| #include "core.h" | |
| #include "debug.h" | |
| #include "wmi.h" | |
| #include "hal_rx.h" | |
| #include "dp_tx.h" | |
| #include "debugfs_htt_stats.h" | |
| #include "peer.h" | |
| static const char *htt_bp_umac_ring[HTT_SW_UMAC_RING_IDX_MAX] = { | |
| "REO2SW1_RING", | |
| "REO2SW2_RING", | |
| "REO2SW3_RING", | |
| "REO2SW4_RING", | |
| "WBM2REO_LINK_RING", | |
| "REO2TCL_RING", | |
| "REO2FW_RING", | |
| "RELEASE_RING", | |
| "PPE_RELEASE_RING", | |
| "TCL2TQM_RING", | |
| "TQM_RELEASE_RING", | |
| "REO_RELEASE_RING", | |
| "WBM2SW0_RELEASE_RING", | |
| "WBM2SW1_RELEASE_RING", | |
| "WBM2SW2_RELEASE_RING", | |
| "WBM2SW3_RELEASE_RING", | |
| "REO_CMD_RING", | |
| "REO_STATUS_RING", | |
| }; | |
| static const char *htt_bp_lmac_ring[HTT_SW_LMAC_RING_IDX_MAX] = { | |
| "FW2RXDMA_BUF_RING", | |
| "FW2RXDMA_STATUS_RING", | |
| "FW2RXDMA_LINK_RING", | |
| "SW2RXDMA_BUF_RING", | |
| "WBM2RXDMA_LINK_RING", | |
| "RXDMA2FW_RING", | |
| "RXDMA2SW_RING", | |
| "RXDMA2RELEASE_RING", | |
| "RXDMA2REO_RING", | |
| "MONITOR_STATUS_RING", | |
| "MONITOR_BUF_RING", | |
| "MONITOR_DESC_RING", | |
| "MONITOR_DEST_RING", | |
| }; | |
| static void ath11k_fw_stats_pdevs_free(struct list_head *head) | |
| { | |
| struct ath11k_fw_stats_pdev *i, *tmp; | |
| list_for_each_entry_safe(i, tmp, head, list) { | |
| list_del(&i->list); | |
| kfree(i); | |
| } | |
| } | |
| static void ath11k_fw_stats_vdevs_free(struct list_head *head) | |
| { | |
| struct ath11k_fw_stats_vdev *i, *tmp; | |
| list_for_each_entry_safe(i, tmp, head, list) { | |
| list_del(&i->list); | |
| kfree(i); | |
| } | |
| } | |
| static void ath11k_fw_stats_bcn_free(struct list_head *head) | |
| { | |
| struct ath11k_fw_stats_bcn *i, *tmp; | |
| list_for_each_entry_safe(i, tmp, head, list) { | |
| list_del(&i->list); | |
| kfree(i); | |
| } | |
| } | |
| static void ath11k_debugfs_fw_stats_reset(struct ath11k *ar) | |
| { | |
| spin_lock_bh(&ar->data_lock); | |
| ar->debug.fw_stats_done = false; | |
| ath11k_fw_stats_pdevs_free(&ar->debug.fw_stats.pdevs); | |
| ath11k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs); | |
| spin_unlock_bh(&ar->data_lock); | |
| } | |
| void ath11k_debugfs_fw_stats_process(struct ath11k_base *ab, struct sk_buff *skb) | |
| { | |
| struct ath11k_fw_stats stats = {}; | |
| struct ath11k *ar; | |
| struct ath11k_pdev *pdev; | |
| bool is_end; | |
| static unsigned int num_vdev, num_bcn; | |
| size_t total_vdevs_started = 0; | |
| int i, ret; | |
| INIT_LIST_HEAD(&stats.pdevs); | |
| INIT_LIST_HEAD(&stats.vdevs); | |
| INIT_LIST_HEAD(&stats.bcn); | |
| ret = ath11k_wmi_pull_fw_stats(ab, skb, &stats); | |
| if (ret) { | |
| ath11k_warn(ab, "failed to pull fw stats: %d\n", ret); | |
| goto free; | |
| } | |
| rcu_read_lock(); | |
| ar = ath11k_mac_get_ar_by_pdev_id(ab, stats.pdev_id); | |
| if (!ar) { | |
| rcu_read_unlock(); | |
| ath11k_warn(ab, "failed to get ar for pdev_id %d: %d\n", | |
| stats.pdev_id, ret); | |
| goto free; | |
| } | |
| spin_lock_bh(&ar->data_lock); | |
| if (stats.stats_id == WMI_REQUEST_PDEV_STAT) { | |
| list_splice_tail_init(&stats.pdevs, &ar->debug.fw_stats.pdevs); | |
| ar->debug.fw_stats_done = true; | |
| goto complete; | |
| } | |
| if (stats.stats_id == WMI_REQUEST_VDEV_STAT) { | |
| if (list_empty(&stats.vdevs)) { | |
| ath11k_warn(ab, "empty vdev stats"); | |
| goto complete; | |
| } | |
| /* FW sends all the active VDEV stats irrespective of PDEV, | |
| * hence limit until the count of all VDEVs started | |
| */ | |
| for (i = 0; i < ab->num_radios; i++) { | |
| pdev = rcu_dereference(ab->pdevs_active[i]); | |
| if (pdev && pdev->ar) | |
| total_vdevs_started += ar->num_started_vdevs; | |
| } | |
| is_end = ((++num_vdev) == total_vdevs_started); | |
| list_splice_tail_init(&stats.vdevs, | |
| &ar->debug.fw_stats.vdevs); | |
| if (is_end) { | |
| ar->debug.fw_stats_done = true; | |
| num_vdev = 0; | |
| } | |
| goto complete; | |
| } | |
| if (stats.stats_id == WMI_REQUEST_BCN_STAT) { | |
| if (list_empty(&stats.bcn)) { | |
| ath11k_warn(ab, "empty bcn stats"); | |
| goto complete; | |
| } | |
| /* Mark end until we reached the count of all started VDEVs | |
| * within the PDEV | |
| */ | |
| is_end = ((++num_bcn) == ar->num_started_vdevs); | |
| list_splice_tail_init(&stats.bcn, | |
| &ar->debug.fw_stats.bcn); | |
| if (is_end) { | |
| ar->debug.fw_stats_done = true; | |
| num_bcn = 0; | |
| } | |
| } | |
| complete: | |
| complete(&ar->debug.fw_stats_complete); | |
| rcu_read_unlock(); | |
| spin_unlock_bh(&ar->data_lock); | |
| free: | |
| ath11k_fw_stats_pdevs_free(&stats.pdevs); | |
| ath11k_fw_stats_vdevs_free(&stats.vdevs); | |
| ath11k_fw_stats_bcn_free(&stats.bcn); | |
| } | |
| static int ath11k_debugfs_fw_stats_request(struct ath11k *ar, | |
| struct stats_request_params *req_param) | |
| { | |
| struct ath11k_base *ab = ar->ab; | |
| unsigned long timeout, time_left; | |
| int ret; | |
| lockdep_assert_held(&ar->conf_mutex); | |
| /* FW stats can get split when exceeding the stats data buffer limit. | |
| * In that case, since there is no end marking for the back-to-back | |
| * received 'update stats' event, we keep a 3 seconds timeout in case, | |
| * fw_stats_done is not marked yet | |
| */ | |
| timeout = jiffies + msecs_to_jiffies(3 * HZ); | |
| ath11k_debugfs_fw_stats_reset(ar); | |
| reinit_completion(&ar->debug.fw_stats_complete); | |
| ret = ath11k_wmi_send_stats_request_cmd(ar, req_param); | |
| if (ret) { | |
| ath11k_warn(ab, "could not request fw stats (%d)\n", | |
| ret); | |
| return ret; | |
| } | |
| time_left = | |
| wait_for_completion_timeout(&ar->debug.fw_stats_complete, | |
| 1 * HZ); | |
| if (!time_left) | |
| return -ETIMEDOUT; | |
| for (;;) { | |
| if (time_after(jiffies, timeout)) | |
| break; | |
| spin_lock_bh(&ar->data_lock); | |
| if (ar->debug.fw_stats_done) { | |
| spin_unlock_bh(&ar->data_lock); | |
| break; | |
| } | |
| spin_unlock_bh(&ar->data_lock); | |
| } | |
| return 0; | |
| } | |
| static int ath11k_open_pdev_stats(struct inode *inode, struct file *file) | |
| { | |
| struct ath11k *ar = inode->i_private; | |
| struct ath11k_base *ab = ar->ab; | |
| struct stats_request_params req_param; | |
| void *buf = NULL; | |
| int ret; | |
| mutex_lock(&ar->conf_mutex); | |
| if (ar->state != ATH11K_STATE_ON) { | |
| ret = -ENETDOWN; | |
| goto err_unlock; | |
| } | |
| buf = vmalloc(ATH11K_FW_STATS_BUF_SIZE); | |
| if (!buf) { | |
| ret = -ENOMEM; | |
| goto err_unlock; | |
| } | |
| req_param.pdev_id = ar->pdev->pdev_id; | |
| req_param.vdev_id = 0; | |
| req_param.stats_id = WMI_REQUEST_PDEV_STAT; | |
| ret = ath11k_debugfs_fw_stats_request(ar, &req_param); | |
| if (ret) { | |
| ath11k_warn(ab, "failed to request fw pdev stats: %d\n", ret); | |
| goto err_free; | |
| } | |
| ath11k_wmi_fw_stats_fill(ar, &ar->debug.fw_stats, req_param.stats_id, | |
| buf); | |
| file->private_data = buf; | |
| mutex_unlock(&ar->conf_mutex); | |
| return 0; | |
| err_free: | |
| vfree(buf); | |
| err_unlock: | |
| mutex_unlock(&ar->conf_mutex); | |
| return ret; | |
| } | |
| static int ath11k_release_pdev_stats(struct inode *inode, struct file *file) | |
| { | |
| vfree(file->private_data); | |
| return 0; | |
| } | |
| static ssize_t ath11k_read_pdev_stats(struct file *file, | |
| char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| const char *buf = file->private_data; | |
| size_t len = strlen(buf); | |
| return simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
| } | |
| static const struct file_operations fops_pdev_stats = { | |
| .open = ath11k_open_pdev_stats, | |
| .release = ath11k_release_pdev_stats, | |
| .read = ath11k_read_pdev_stats, | |
| .owner = THIS_MODULE, | |
| .llseek = default_llseek, | |
| }; | |
| static int ath11k_open_vdev_stats(struct inode *inode, struct file *file) | |
| { | |
| struct ath11k *ar = inode->i_private; | |
| struct stats_request_params req_param; | |
| void *buf = NULL; | |
| int ret; | |
| mutex_lock(&ar->conf_mutex); | |
| if (ar->state != ATH11K_STATE_ON) { | |
| ret = -ENETDOWN; | |
| goto err_unlock; | |
| } | |
| buf = vmalloc(ATH11K_FW_STATS_BUF_SIZE); | |
| if (!buf) { | |
| ret = -ENOMEM; | |
| goto err_unlock; | |
| } | |
| req_param.pdev_id = ar->pdev->pdev_id; | |
| /* VDEV stats is always sent for all active VDEVs from FW */ | |
| req_param.vdev_id = 0; | |
| req_param.stats_id = WMI_REQUEST_VDEV_STAT; | |
| ret = ath11k_debugfs_fw_stats_request(ar, &req_param); | |
| if (ret) { | |
| ath11k_warn(ar->ab, "failed to request fw vdev stats: %d\n", ret); | |
| goto err_free; | |
| } | |
| ath11k_wmi_fw_stats_fill(ar, &ar->debug.fw_stats, req_param.stats_id, | |
| buf); | |
| file->private_data = buf; | |
| mutex_unlock(&ar->conf_mutex); | |
| return 0; | |
| err_free: | |
| vfree(buf); | |
| err_unlock: | |
| mutex_unlock(&ar->conf_mutex); | |
| return ret; | |
| } | |
| static int ath11k_release_vdev_stats(struct inode *inode, struct file *file) | |
| { | |
| vfree(file->private_data); | |
| return 0; | |
| } | |
| static ssize_t ath11k_read_vdev_stats(struct file *file, | |
| char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| const char *buf = file->private_data; | |
| size_t len = strlen(buf); | |
| return simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
| } | |
| static const struct file_operations fops_vdev_stats = { | |
| .open = ath11k_open_vdev_stats, | |
| .release = ath11k_release_vdev_stats, | |
| .read = ath11k_read_vdev_stats, | |
| .owner = THIS_MODULE, | |
| .llseek = default_llseek, | |
| }; | |
| static int ath11k_open_bcn_stats(struct inode *inode, struct file *file) | |
| { | |
| struct ath11k *ar = inode->i_private; | |
| struct ath11k_vif *arvif; | |
| struct stats_request_params req_param; | |
| void *buf = NULL; | |
| int ret; | |
| mutex_lock(&ar->conf_mutex); | |
| if (ar->state != ATH11K_STATE_ON) { | |
| ret = -ENETDOWN; | |
| goto err_unlock; | |
| } | |
| buf = vmalloc(ATH11K_FW_STATS_BUF_SIZE); | |
| if (!buf) { | |
| ret = -ENOMEM; | |
| goto err_unlock; | |
| } | |
| req_param.stats_id = WMI_REQUEST_BCN_STAT; | |
| req_param.pdev_id = ar->pdev->pdev_id; | |
| /* loop all active VDEVs for bcn stats */ | |
| list_for_each_entry(arvif, &ar->arvifs, list) { | |
| if (!arvif->is_up) | |
| continue; | |
| req_param.vdev_id = arvif->vdev_id; | |
| ret = ath11k_debugfs_fw_stats_request(ar, &req_param); | |
| if (ret) { | |
| ath11k_warn(ar->ab, "failed to request fw bcn stats: %d\n", ret); | |
| goto err_free; | |
| } | |
| } | |
| ath11k_wmi_fw_stats_fill(ar, &ar->debug.fw_stats, req_param.stats_id, | |
| buf); | |
| /* since beacon stats request is looped for all active VDEVs, saved fw | |
| * stats is not freed for each request until done for all active VDEVs | |
| */ | |
| spin_lock_bh(&ar->data_lock); | |
| ath11k_fw_stats_bcn_free(&ar->debug.fw_stats.bcn); | |
| spin_unlock_bh(&ar->data_lock); | |
| file->private_data = buf; | |
| mutex_unlock(&ar->conf_mutex); | |
| return 0; | |
| err_free: | |
| vfree(buf); | |
| err_unlock: | |
| mutex_unlock(&ar->conf_mutex); | |
| return ret; | |
| } | |
| static int ath11k_release_bcn_stats(struct inode *inode, struct file *file) | |
| { | |
| vfree(file->private_data); | |
| return 0; | |
| } | |
| static ssize_t ath11k_read_bcn_stats(struct file *file, | |
| char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| const char *buf = file->private_data; | |
| size_t len = strlen(buf); | |
| return simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
| } | |
| static const struct file_operations fops_bcn_stats = { | |
| .open = ath11k_open_bcn_stats, | |
| .release = ath11k_release_bcn_stats, | |
| .read = ath11k_read_bcn_stats, | |
| .owner = THIS_MODULE, | |
| .llseek = default_llseek, | |
| }; | |
| static ssize_t ath11k_read_simulate_fw_crash(struct file *file, | |
| char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| const char buf[] = | |
| "To simulate firmware crash write one of the keywords to this file:\n" | |
| "`assert` - this will send WMI_FORCE_FW_HANG_CMDID to firmware to cause assert.\n" | |
| "`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n"; | |
| return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf)); | |
| } | |
| /* Simulate firmware crash: | |
| * 'soft': Call wmi command causing firmware hang. This firmware hang is | |
| * recoverable by warm firmware reset. | |
| * 'hard': Force firmware crash by setting any vdev parameter for not allowed | |
| * vdev id. This is hard firmware crash because it is recoverable only by cold | |
| * firmware reset. | |
| */ | |
| static ssize_t ath11k_write_simulate_fw_crash(struct file *file, | |
| const char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k_base *ab = file->private_data; | |
| struct ath11k_pdev *pdev; | |
| struct ath11k *ar = ab->pdevs[0].ar; | |
| char buf[32] = {0}; | |
| ssize_t rc; | |
| int i, ret, radioup = 0; | |
| for (i = 0; i < ab->num_radios; i++) { | |
| pdev = &ab->pdevs[i]; | |
| ar = pdev->ar; | |
| if (ar && ar->state == ATH11K_STATE_ON) { | |
| radioup = 1; | |
| break; | |
| } | |
| } | |
| /* filter partial writes and invalid commands */ | |
| if (*ppos != 0 || count >= sizeof(buf) || count == 0) | |
| return -EINVAL; | |
| rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count); | |
| if (rc < 0) | |
| return rc; | |
| /* drop the possible '\n' from the end */ | |
| if (buf[*ppos - 1] == '\n') | |
| buf[*ppos - 1] = '\0'; | |
| if (radioup == 0) { | |
| ret = -ENETDOWN; | |
| goto exit; | |
| } | |
| if (!strcmp(buf, "assert")) { | |
| ath11k_info(ab, "simulating firmware assert crash\n"); | |
| ret = ath11k_wmi_force_fw_hang_cmd(ar, | |
| ATH11K_WMI_FW_HANG_ASSERT_TYPE, | |
| ATH11K_WMI_FW_HANG_DELAY); | |
| } else { | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| if (ret) { | |
| ath11k_warn(ab, "failed to simulate firmware crash: %d\n", ret); | |
| goto exit; | |
| } | |
| ret = count; | |
| exit: | |
| return ret; | |
| } | |
| static const struct file_operations fops_simulate_fw_crash = { | |
| .read = ath11k_read_simulate_fw_crash, | |
| .write = ath11k_write_simulate_fw_crash, | |
| .open = simple_open, | |
| .owner = THIS_MODULE, | |
| .llseek = default_llseek, | |
| }; | |
| static ssize_t ath11k_write_enable_extd_tx_stats(struct file *file, | |
| const char __user *ubuf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k *ar = file->private_data; | |
| u32 filter; | |
| int ret; | |
| if (kstrtouint_from_user(ubuf, count, 0, &filter)) | |
| return -EINVAL; | |
| mutex_lock(&ar->conf_mutex); | |
| if (ar->state != ATH11K_STATE_ON) { | |
| ret = -ENETDOWN; | |
| goto out; | |
| } | |
| if (filter == ar->debug.extd_tx_stats) { | |
| ret = count; | |
| goto out; | |
| } | |
| ar->debug.extd_tx_stats = filter; | |
| ret = count; | |
| out: | |
| mutex_unlock(&ar->conf_mutex); | |
| return ret; | |
| } | |
| static ssize_t ath11k_read_enable_extd_tx_stats(struct file *file, | |
| char __user *ubuf, | |
| size_t count, loff_t *ppos) | |
| { | |
| char buf[32] = {0}; | |
| struct ath11k *ar = file->private_data; | |
| int len = 0; | |
| mutex_lock(&ar->conf_mutex); | |
| len = scnprintf(buf, sizeof(buf) - len, "%08x\n", | |
| ar->debug.extd_tx_stats); | |
| mutex_unlock(&ar->conf_mutex); | |
| return simple_read_from_buffer(ubuf, count, ppos, buf, len); | |
| } | |
| static const struct file_operations fops_extd_tx_stats = { | |
| .read = ath11k_read_enable_extd_tx_stats, | |
| .write = ath11k_write_enable_extd_tx_stats, | |
| .open = simple_open | |
| }; | |
| static ssize_t ath11k_write_extd_rx_stats(struct file *file, | |
| const char __user *ubuf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k *ar = file->private_data; | |
| struct ath11k_base *ab = ar->ab; | |
| struct htt_rx_ring_tlv_filter tlv_filter = {0}; | |
| u32 enable, rx_filter = 0, ring_id; | |
| int i; | |
| int ret; | |
| if (kstrtouint_from_user(ubuf, count, 0, &enable)) | |
| return -EINVAL; | |
| mutex_lock(&ar->conf_mutex); | |
| if (ar->state != ATH11K_STATE_ON) { | |
| ret = -ENETDOWN; | |
| goto exit; | |
| } | |
| if (enable > 1) { | |
| ret = -EINVAL; | |
| goto exit; | |
| } | |
| if (enable == ar->debug.extd_rx_stats) { | |
| ret = count; | |
| goto exit; | |
| } | |
| if (enable) { | |
| rx_filter = HTT_RX_FILTER_TLV_FLAGS_MPDU_START; | |
| rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_START; | |
| rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END; | |
| rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS; | |
| rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS_EXT; | |
| rx_filter |= HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE; | |
| tlv_filter.rx_filter = rx_filter; | |
| tlv_filter.pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0; | |
| tlv_filter.pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1; | |
| tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2; | |
| tlv_filter.pkt_filter_flags3 = HTT_RX_FP_CTRL_FILTER_FLASG3 | | |
| HTT_RX_FP_DATA_FILTER_FLASG3; | |
| } else { | |
| tlv_filter = ath11k_mac_mon_status_filter_default; | |
| } | |
| ar->debug.rx_filter = tlv_filter.rx_filter; | |
| for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) { | |
| ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; | |
| ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, ar->dp.mac_id, | |
| HAL_RXDMA_MONITOR_STATUS, | |
| DP_RX_BUFFER_SIZE, &tlv_filter); | |
| if (ret) { | |
| ath11k_warn(ar->ab, "failed to set rx filter for monitor status ring\n"); | |
| goto exit; | |
| } | |
| } | |
| ar->debug.extd_rx_stats = enable; | |
| ret = count; | |
| exit: | |
| mutex_unlock(&ar->conf_mutex); | |
| return ret; | |
| } | |
| static ssize_t ath11k_read_extd_rx_stats(struct file *file, | |
| char __user *ubuf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k *ar = file->private_data; | |
| char buf[32]; | |
| int len = 0; | |
| mutex_lock(&ar->conf_mutex); | |
| len = scnprintf(buf, sizeof(buf) - len, "%d\n", | |
| ar->debug.extd_rx_stats); | |
| mutex_unlock(&ar->conf_mutex); | |
| return simple_read_from_buffer(ubuf, count, ppos, buf, len); | |
| } | |
| static const struct file_operations fops_extd_rx_stats = { | |
| .read = ath11k_read_extd_rx_stats, | |
| .write = ath11k_write_extd_rx_stats, | |
| .open = simple_open, | |
| }; | |
| static int ath11k_fill_bp_stats(struct ath11k_base *ab, | |
| struct ath11k_bp_stats *bp_stats, | |
| char *buf, int len, int size) | |
| { | |
| lockdep_assert_held(&ab->base_lock); | |
| len += scnprintf(buf + len, size - len, "count: %u\n", | |
| bp_stats->count); | |
| len += scnprintf(buf + len, size - len, "hp: %u\n", | |
| bp_stats->hp); | |
| len += scnprintf(buf + len, size - len, "tp: %u\n", | |
| bp_stats->tp); | |
| len += scnprintf(buf + len, size - len, "seen before: %ums\n\n", | |
| jiffies_to_msecs(jiffies - bp_stats->jiffies)); | |
| return len; | |
| } | |
| static ssize_t ath11k_debugfs_dump_soc_ring_bp_stats(struct ath11k_base *ab, | |
| char *buf, int size) | |
| { | |
| struct ath11k_bp_stats *bp_stats; | |
| bool stats_rxd = false; | |
| u8 i, pdev_idx; | |
| int len = 0; | |
| len += scnprintf(buf + len, size - len, "\nBackpressure Stats\n"); | |
| len += scnprintf(buf + len, size - len, "==================\n"); | |
| spin_lock_bh(&ab->base_lock); | |
| for (i = 0; i < HTT_SW_UMAC_RING_IDX_MAX; i++) { | |
| bp_stats = &ab->soc_stats.bp_stats.umac_ring_bp_stats[i]; | |
| if (!bp_stats->count) | |
| continue; | |
| len += scnprintf(buf + len, size - len, "Ring: %s\n", | |
| htt_bp_umac_ring[i]); | |
| len = ath11k_fill_bp_stats(ab, bp_stats, buf, len, size); | |
| stats_rxd = true; | |
| } | |
| for (i = 0; i < HTT_SW_LMAC_RING_IDX_MAX; i++) { | |
| for (pdev_idx = 0; pdev_idx < MAX_RADIOS; pdev_idx++) { | |
| bp_stats = | |
| &ab->soc_stats.bp_stats.lmac_ring_bp_stats[i][pdev_idx]; | |
| if (!bp_stats->count) | |
| continue; | |
| len += scnprintf(buf + len, size - len, "Ring: %s\n", | |
| htt_bp_lmac_ring[i]); | |
| len += scnprintf(buf + len, size - len, "pdev: %d\n", | |
| pdev_idx); | |
| len = ath11k_fill_bp_stats(ab, bp_stats, buf, len, size); | |
| stats_rxd = true; | |
| } | |
| } | |
| spin_unlock_bh(&ab->base_lock); | |
| if (!stats_rxd) | |
| len += scnprintf(buf + len, size - len, | |
| "No Ring Backpressure stats received\n\n"); | |
| return len; | |
| } | |
| static ssize_t ath11k_debugfs_dump_soc_dp_stats(struct file *file, | |
| char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k_base *ab = file->private_data; | |
| struct ath11k_soc_dp_stats *soc_stats = &ab->soc_stats; | |
| int len = 0, i, retval; | |
| const int size = 4096; | |
| static const char *rxdma_err[HAL_REO_ENTR_RING_RXDMA_ECODE_MAX] = { | |
| "Overflow", "MPDU len", "FCS", "Decrypt", "TKIP MIC", | |
| "Unencrypt", "MSDU len", "MSDU limit", "WiFi parse", | |
| "AMSDU parse", "SA timeout", "DA timeout", | |
| "Flow timeout", "Flush req"}; | |
| static const char *reo_err[HAL_REO_DEST_RING_ERROR_CODE_MAX] = { | |
| "Desc addr zero", "Desc inval", "AMPDU in non BA", | |
| "Non BA dup", "BA dup", "Frame 2k jump", "BAR 2k jump", | |
| "Frame OOR", "BAR OOR", "No BA session", | |
| "Frame SN equal SSN", "PN check fail", "2k err", | |
| "PN err", "Desc blocked"}; | |
| char *buf; | |
| buf = kzalloc(size, GFP_KERNEL); | |
| if (!buf) | |
| return -ENOMEM; | |
| len += scnprintf(buf + len, size - len, "SOC RX STATS:\n\n"); | |
| len += scnprintf(buf + len, size - len, "err ring pkts: %u\n", | |
| soc_stats->err_ring_pkts); | |
| len += scnprintf(buf + len, size - len, "Invalid RBM: %u\n\n", | |
| soc_stats->invalid_rbm); | |
| len += scnprintf(buf + len, size - len, "RXDMA errors:\n"); | |
| for (i = 0; i < HAL_REO_ENTR_RING_RXDMA_ECODE_MAX; i++) | |
| len += scnprintf(buf + len, size - len, "%s: %u\n", | |
| rxdma_err[i], soc_stats->rxdma_error[i]); | |
| len += scnprintf(buf + len, size - len, "\nREO errors:\n"); | |
| for (i = 0; i < HAL_REO_DEST_RING_ERROR_CODE_MAX; i++) | |
| len += scnprintf(buf + len, size - len, "%s: %u\n", | |
| reo_err[i], soc_stats->reo_error[i]); | |
| len += scnprintf(buf + len, size - len, "\nHAL REO errors:\n"); | |
| len += scnprintf(buf + len, size - len, | |
| "ring0: %u\nring1: %u\nring2: %u\nring3: %u\n", | |
| soc_stats->hal_reo_error[0], | |
| soc_stats->hal_reo_error[1], | |
| soc_stats->hal_reo_error[2], | |
| soc_stats->hal_reo_error[3]); | |
| len += scnprintf(buf + len, size - len, "\nSOC TX STATS:\n"); | |
| len += scnprintf(buf + len, size - len, "\nTCL Ring Full Failures:\n"); | |
| for (i = 0; i < ab->hw_params.max_tx_ring; i++) | |
| len += scnprintf(buf + len, size - len, "ring%d: %u\n", | |
| i, soc_stats->tx_err.desc_na[i]); | |
| len += scnprintf(buf + len, size - len, | |
| "\nMisc Transmit Failures: %d\n", | |
| atomic_read(&soc_stats->tx_err.misc_fail)); | |
| len += ath11k_debugfs_dump_soc_ring_bp_stats(ab, buf + len, size - len); | |
| if (len > size) | |
| len = size; | |
| retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); | |
| kfree(buf); | |
| return retval; | |
| } | |
| static const struct file_operations fops_soc_dp_stats = { | |
| .read = ath11k_debugfs_dump_soc_dp_stats, | |
| .open = simple_open, | |
| .owner = THIS_MODULE, | |
| .llseek = default_llseek, | |
| }; | |
| int ath11k_debugfs_pdev_create(struct ath11k_base *ab) | |
| { | |
| if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) | |
| return 0; | |
| ab->debugfs_soc = debugfs_create_dir(ab->hw_params.name, ab->debugfs_ath11k); | |
| if (IS_ERR(ab->debugfs_soc)) | |
| return PTR_ERR(ab->debugfs_soc); | |
| debugfs_create_file("simulate_fw_crash", 0600, ab->debugfs_soc, ab, | |
| &fops_simulate_fw_crash); | |
| debugfs_create_file("soc_dp_stats", 0600, ab->debugfs_soc, ab, | |
| &fops_soc_dp_stats); | |
| return 0; | |
| } | |
| void ath11k_debugfs_pdev_destroy(struct ath11k_base *ab) | |
| { | |
| debugfs_remove_recursive(ab->debugfs_soc); | |
| ab->debugfs_soc = NULL; | |
| } | |
| int ath11k_debugfs_soc_create(struct ath11k_base *ab) | |
| { | |
| ab->debugfs_ath11k = debugfs_create_dir("ath11k", NULL); | |
| return PTR_ERR_OR_ZERO(ab->debugfs_ath11k); | |
| } | |
| void ath11k_debugfs_soc_destroy(struct ath11k_base *ab) | |
| { | |
| debugfs_remove_recursive(ab->debugfs_ath11k); | |
| ab->debugfs_ath11k = NULL; | |
| } | |
| EXPORT_SYMBOL(ath11k_debugfs_soc_destroy); | |
| void ath11k_debugfs_fw_stats_init(struct ath11k *ar) | |
| { | |
| struct dentry *fwstats_dir = debugfs_create_dir("fw_stats", | |
| ar->debug.debugfs_pdev); | |
| ar->debug.fw_stats.debugfs_fwstats = fwstats_dir; | |
| /* all stats debugfs files created are under "fw_stats" directory | |
| * created per PDEV | |
| */ | |
| debugfs_create_file("pdev_stats", 0600, fwstats_dir, ar, | |
| &fops_pdev_stats); | |
| debugfs_create_file("vdev_stats", 0600, fwstats_dir, ar, | |
| &fops_vdev_stats); | |
| debugfs_create_file("beacon_stats", 0600, fwstats_dir, ar, | |
| &fops_bcn_stats); | |
| INIT_LIST_HEAD(&ar->debug.fw_stats.pdevs); | |
| INIT_LIST_HEAD(&ar->debug.fw_stats.vdevs); | |
| INIT_LIST_HEAD(&ar->debug.fw_stats.bcn); | |
| init_completion(&ar->debug.fw_stats_complete); | |
| } | |
| static ssize_t ath11k_write_pktlog_filter(struct file *file, | |
| const char __user *ubuf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k *ar = file->private_data; | |
| struct ath11k_base *ab = ar->ab; | |
| struct htt_rx_ring_tlv_filter tlv_filter = {0}; | |
| u32 rx_filter = 0, ring_id, filter, mode; | |
| u8 buf[128] = {0}; | |
| int i, ret, rx_buf_sz = 0; | |
| ssize_t rc; | |
| mutex_lock(&ar->conf_mutex); | |
| if (ar->state != ATH11K_STATE_ON) { | |
| ret = -ENETDOWN; | |
| goto out; | |
| } | |
| rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, ubuf, count); | |
| if (rc < 0) { | |
| ret = rc; | |
| goto out; | |
| } | |
| buf[rc] = '\0'; | |
| ret = sscanf(buf, "0x%x %u", &filter, &mode); | |
| if (ret != 2) { | |
| ret = -EINVAL; | |
| goto out; | |
| } | |
| if (filter) { | |
| ret = ath11k_wmi_pdev_pktlog_enable(ar, filter); | |
| if (ret) { | |
| ath11k_warn(ar->ab, | |
| "failed to enable pktlog filter %x: %d\n", | |
| ar->debug.pktlog_filter, ret); | |
| goto out; | |
| } | |
| } else { | |
| ret = ath11k_wmi_pdev_pktlog_disable(ar); | |
| if (ret) { | |
| ath11k_warn(ar->ab, "failed to disable pktlog: %d\n", ret); | |
| goto out; | |
| } | |
| } | |
| /* Clear rx filter set for monitor mode and rx status */ | |
| for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) { | |
| ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; | |
| ret = ath11k_dp_tx_htt_rx_filter_setup(ar->ab, ring_id, ar->dp.mac_id, | |
| HAL_RXDMA_MONITOR_STATUS, | |
| rx_buf_sz, &tlv_filter); | |
| if (ret) { | |
| ath11k_warn(ar->ab, "failed to set rx filter for monitor status ring\n"); | |
| goto out; | |
| } | |
| } | |
| #define HTT_RX_FILTER_TLV_LITE_MODE \ | |
| (HTT_RX_FILTER_TLV_FLAGS_PPDU_START | \ | |
| HTT_RX_FILTER_TLV_FLAGS_PPDU_END | \ | |
| HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS | \ | |
| HTT_RX_FILTER_TLV_FLAGS_PPDU_END_USER_STATS_EXT | \ | |
| HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE | \ | |
| HTT_RX_FILTER_TLV_FLAGS_MPDU_START) | |
| if (mode == ATH11K_PKTLOG_MODE_FULL) { | |
| rx_filter = HTT_RX_FILTER_TLV_LITE_MODE | | |
| HTT_RX_FILTER_TLV_FLAGS_MSDU_START | | |
| HTT_RX_FILTER_TLV_FLAGS_MSDU_END | | |
| HTT_RX_FILTER_TLV_FLAGS_MPDU_END | | |
| HTT_RX_FILTER_TLV_FLAGS_PACKET_HEADER | | |
| HTT_RX_FILTER_TLV_FLAGS_ATTENTION; | |
| rx_buf_sz = DP_RX_BUFFER_SIZE; | |
| } else if (mode == ATH11K_PKTLOG_MODE_LITE) { | |
| ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar, | |
| HTT_PPDU_STATS_TAG_PKTLOG); | |
| if (ret) { | |
| ath11k_err(ar->ab, "failed to enable pktlog lite: %d\n", ret); | |
| goto out; | |
| } | |
| rx_filter = HTT_RX_FILTER_TLV_LITE_MODE; | |
| rx_buf_sz = DP_RX_BUFFER_SIZE_LITE; | |
| } else { | |
| rx_buf_sz = DP_RX_BUFFER_SIZE; | |
| tlv_filter = ath11k_mac_mon_status_filter_default; | |
| rx_filter = tlv_filter.rx_filter; | |
| ret = ath11k_dp_tx_htt_h2t_ppdu_stats_req(ar, | |
| HTT_PPDU_STATS_TAG_DEFAULT); | |
| if (ret) { | |
| ath11k_err(ar->ab, "failed to send htt ppdu stats req: %d\n", | |
| ret); | |
| goto out; | |
| } | |
| } | |
| tlv_filter.rx_filter = rx_filter; | |
| if (rx_filter) { | |
| tlv_filter.pkt_filter_flags0 = HTT_RX_FP_MGMT_FILTER_FLAGS0; | |
| tlv_filter.pkt_filter_flags1 = HTT_RX_FP_MGMT_FILTER_FLAGS1; | |
| tlv_filter.pkt_filter_flags2 = HTT_RX_FP_CTRL_FILTER_FLASG2; | |
| tlv_filter.pkt_filter_flags3 = HTT_RX_FP_CTRL_FILTER_FLASG3 | | |
| HTT_RX_FP_DATA_FILTER_FLASG3; | |
| } | |
| for (i = 0; i < ab->hw_params.num_rxmda_per_pdev; i++) { | |
| ring_id = ar->dp.rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; | |
| ret = ath11k_dp_tx_htt_rx_filter_setup(ab, ring_id, | |
| ar->dp.mac_id + i, | |
| HAL_RXDMA_MONITOR_STATUS, | |
| rx_buf_sz, &tlv_filter); | |
| if (ret) { | |
| ath11k_warn(ab, "failed to set rx filter for monitor status ring\n"); | |
| goto out; | |
| } | |
| } | |
| ath11k_info(ab, "pktlog mode %s\n", | |
| ((mode == ATH11K_PKTLOG_MODE_FULL) ? "full" : "lite")); | |
| ar->debug.pktlog_filter = filter; | |
| ar->debug.pktlog_mode = mode; | |
| ret = count; | |
| out: | |
| mutex_unlock(&ar->conf_mutex); | |
| return ret; | |
| } | |
| static ssize_t ath11k_read_pktlog_filter(struct file *file, | |
| char __user *ubuf, | |
| size_t count, loff_t *ppos) | |
| { | |
| char buf[32] = {0}; | |
| struct ath11k *ar = file->private_data; | |
| int len = 0; | |
| mutex_lock(&ar->conf_mutex); | |
| len = scnprintf(buf, sizeof(buf) - len, "%08x %08x\n", | |
| ar->debug.pktlog_filter, | |
| ar->debug.pktlog_mode); | |
| mutex_unlock(&ar->conf_mutex); | |
| return simple_read_from_buffer(ubuf, count, ppos, buf, len); | |
| } | |
| static const struct file_operations fops_pktlog_filter = { | |
| .read = ath11k_read_pktlog_filter, | |
| .write = ath11k_write_pktlog_filter, | |
| .open = simple_open | |
| }; | |
| static ssize_t ath11k_write_simulate_radar(struct file *file, | |
| const char __user *user_buf, | |
| size_t count, loff_t *ppos) | |
| { | |
| struct ath11k *ar = file->private_data; | |
| int ret; | |
| ret = ath11k_wmi_simulate_radar(ar); | |
| if (ret) | |
| return ret; | |
| return count; | |
| } | |
| static const struct file_operations fops_simulate_radar = { | |
| .write = ath11k_write_simulate_radar, | |
| .open = simple_open | |
| }; | |
| int ath11k_debugfs_register(struct ath11k *ar) | |
| { | |
| struct ath11k_base *ab = ar->ab; | |
| char pdev_name[5]; | |
| char buf[100] = {0}; | |
| snprintf(pdev_name, sizeof(pdev_name), "%s%d", "mac", ar->pdev_idx); | |
| ar->debug.debugfs_pdev = debugfs_create_dir(pdev_name, ab->debugfs_soc); | |
| if (IS_ERR(ar->debug.debugfs_pdev)) | |
| return PTR_ERR(ar->debug.debugfs_pdev); | |
| /* Create a symlink under ieee80211/phy* */ | |
| snprintf(buf, 100, "../../ath11k/%pd2", ar->debug.debugfs_pdev); | |
| debugfs_create_symlink("ath11k", ar->hw->wiphy->debugfsdir, buf); | |
| ath11k_debugfs_htt_stats_init(ar); | |
| ath11k_debugfs_fw_stats_init(ar); | |
| debugfs_create_file("ext_tx_stats", 0644, | |
| ar->debug.debugfs_pdev, ar, | |
| &fops_extd_tx_stats); | |
| debugfs_create_file("ext_rx_stats", 0644, | |
| ar->debug.debugfs_pdev, ar, | |
| &fops_extd_rx_stats); | |
| debugfs_create_file("pktlog_filter", 0644, | |
| ar->debug.debugfs_pdev, ar, | |
| &fops_pktlog_filter); | |
| if (ar->hw->wiphy->bands[NL80211_BAND_5GHZ]) { | |
| debugfs_create_file("dfs_simulate_radar", 0200, | |
| ar->debug.debugfs_pdev, ar, | |
| &fops_simulate_radar); | |
| debugfs_create_bool("dfs_block_radar_events", 0200, | |
| ar->debug.debugfs_pdev, | |
| &ar->dfs_block_radar_events); | |
| } | |
| return 0; | |
| } | |
| void ath11k_debugfs_unregister(struct ath11k *ar) | |
| { | |
| } |