Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: ISC
0002 /*
0003  * Copyright (c) 2005-2011 Atheros Communications Inc.
0004  * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
0005  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
0006  */
0007 
0008 #include <linux/module.h>
0009 #include <linux/debugfs.h>
0010 #include <linux/vmalloc.h>
0011 #include <linux/crc32.h>
0012 #include <linux/firmware.h>
0013 
0014 #include "core.h"
0015 #include "debug.h"
0016 #include "hif.h"
0017 #include "wmi-ops.h"
0018 
0019 /* ms */
0020 #define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
0021 
0022 #define ATH10K_DEBUG_CAL_DATA_LEN 12064
0023 
0024 void ath10k_info(struct ath10k *ar, const char *fmt, ...)
0025 {
0026     struct va_format vaf = {
0027         .fmt = fmt,
0028     };
0029     va_list args;
0030 
0031     va_start(args, fmt);
0032     vaf.va = &args;
0033     dev_info(ar->dev, "%pV", &vaf);
0034     trace_ath10k_log_info(ar, &vaf);
0035     va_end(args);
0036 }
0037 EXPORT_SYMBOL(ath10k_info);
0038 
0039 void ath10k_debug_print_hwfw_info(struct ath10k *ar)
0040 {
0041     const struct firmware *firmware;
0042     char fw_features[128] = {};
0043     u32 crc = 0;
0044 
0045     ath10k_core_get_fw_features_str(ar, fw_features, sizeof(fw_features));
0046 
0047     ath10k_info(ar, "%s target 0x%08x chip_id 0x%08x sub %04x:%04x",
0048             ar->hw_params.name,
0049             ar->target_version,
0050             ar->bus_param.chip_id,
0051             ar->id.subsystem_vendor, ar->id.subsystem_device);
0052 
0053     ath10k_info(ar, "kconfig debug %d debugfs %d tracing %d dfs %d testmode %d\n",
0054             IS_ENABLED(CONFIG_ATH10K_DEBUG),
0055             IS_ENABLED(CONFIG_ATH10K_DEBUGFS),
0056             IS_ENABLED(CONFIG_ATH10K_TRACING),
0057             IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED),
0058             IS_ENABLED(CONFIG_NL80211_TESTMODE));
0059 
0060     firmware = ar->normal_mode_fw.fw_file.firmware;
0061     if (firmware)
0062         crc = crc32_le(0, firmware->data, firmware->size);
0063 
0064     ath10k_info(ar, "firmware ver %s api %d features %s crc32 %08x\n",
0065             ar->hw->wiphy->fw_version,
0066             ar->fw_api,
0067             fw_features,
0068             crc);
0069 }
0070 
0071 void ath10k_debug_print_board_info(struct ath10k *ar)
0072 {
0073     char boardinfo[100];
0074     const struct firmware *board;
0075     u32 crc;
0076 
0077     if (ar->id.bmi_ids_valid)
0078         scnprintf(boardinfo, sizeof(boardinfo), "%d:%d",
0079               ar->id.bmi_chip_id, ar->id.bmi_board_id);
0080     else
0081         scnprintf(boardinfo, sizeof(boardinfo), "N/A");
0082 
0083     board = ar->normal_mode_fw.board;
0084     if (!IS_ERR_OR_NULL(board))
0085         crc = crc32_le(0, board->data, board->size);
0086     else
0087         crc = 0;
0088 
0089     ath10k_info(ar, "board_file api %d bmi_id %s crc32 %08x",
0090             ar->bd_api,
0091             boardinfo,
0092             crc);
0093 }
0094 
0095 void ath10k_debug_print_boot_info(struct ath10k *ar)
0096 {
0097     ath10k_info(ar, "htt-ver %d.%d wmi-op %d htt-op %d cal %s max-sta %d raw %d hwcrypto %d\n",
0098             ar->htt.target_version_major,
0099             ar->htt.target_version_minor,
0100             ar->normal_mode_fw.fw_file.wmi_op_version,
0101             ar->normal_mode_fw.fw_file.htt_op_version,
0102             ath10k_cal_mode_str(ar->cal_mode),
0103             ar->max_num_stations,
0104             test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags),
0105             !test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags));
0106 }
0107 
0108 void ath10k_print_driver_info(struct ath10k *ar)
0109 {
0110     ath10k_debug_print_hwfw_info(ar);
0111     ath10k_debug_print_board_info(ar);
0112     ath10k_debug_print_boot_info(ar);
0113 }
0114 EXPORT_SYMBOL(ath10k_print_driver_info);
0115 
0116 void ath10k_err(struct ath10k *ar, const char *fmt, ...)
0117 {
0118     struct va_format vaf = {
0119         .fmt = fmt,
0120     };
0121     va_list args;
0122 
0123     va_start(args, fmt);
0124     vaf.va = &args;
0125     dev_err(ar->dev, "%pV", &vaf);
0126     trace_ath10k_log_err(ar, &vaf);
0127     va_end(args);
0128 }
0129 EXPORT_SYMBOL(ath10k_err);
0130 
0131 void ath10k_warn(struct ath10k *ar, const char *fmt, ...)
0132 {
0133     struct va_format vaf = {
0134         .fmt = fmt,
0135     };
0136     va_list args;
0137 
0138     va_start(args, fmt);
0139     vaf.va = &args;
0140     dev_warn_ratelimited(ar->dev, "%pV", &vaf);
0141     trace_ath10k_log_warn(ar, &vaf);
0142 
0143     va_end(args);
0144 }
0145 EXPORT_SYMBOL(ath10k_warn);
0146 
0147 #ifdef CONFIG_ATH10K_DEBUGFS
0148 
0149 static ssize_t ath10k_read_wmi_services(struct file *file,
0150                     char __user *user_buf,
0151                     size_t count, loff_t *ppos)
0152 {
0153     struct ath10k *ar = file->private_data;
0154     char *buf;
0155     size_t len = 0, buf_len = 8192;
0156     const char *name;
0157     ssize_t ret_cnt;
0158     bool enabled;
0159     int i;
0160 
0161     buf = kzalloc(buf_len, GFP_KERNEL);
0162     if (!buf)
0163         return -ENOMEM;
0164 
0165     mutex_lock(&ar->conf_mutex);
0166 
0167     spin_lock_bh(&ar->data_lock);
0168     for (i = 0; i < WMI_SERVICE_MAX; i++) {
0169         enabled = test_bit(i, ar->wmi.svc_map);
0170         name = wmi_service_name(i);
0171 
0172         if (!name) {
0173             if (enabled)
0174                 len += scnprintf(buf + len, buf_len - len,
0175                          "%-40s %s (bit %d)\n",
0176                          "unknown", "enabled", i);
0177 
0178             continue;
0179         }
0180 
0181         len += scnprintf(buf + len, buf_len - len,
0182                  "%-40s %s\n",
0183                  name, enabled ? "enabled" : "-");
0184     }
0185     spin_unlock_bh(&ar->data_lock);
0186 
0187     ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
0188 
0189     mutex_unlock(&ar->conf_mutex);
0190 
0191     kfree(buf);
0192     return ret_cnt;
0193 }
0194 
0195 static const struct file_operations fops_wmi_services = {
0196     .read = ath10k_read_wmi_services,
0197     .open = simple_open,
0198     .owner = THIS_MODULE,
0199     .llseek = default_llseek,
0200 };
0201 
0202 static void ath10k_fw_stats_pdevs_free(struct list_head *head)
0203 {
0204     struct ath10k_fw_stats_pdev *i, *tmp;
0205 
0206     list_for_each_entry_safe(i, tmp, head, list) {
0207         list_del(&i->list);
0208         kfree(i);
0209     }
0210 }
0211 
0212 static void ath10k_fw_stats_vdevs_free(struct list_head *head)
0213 {
0214     struct ath10k_fw_stats_vdev *i, *tmp;
0215 
0216     list_for_each_entry_safe(i, tmp, head, list) {
0217         list_del(&i->list);
0218         kfree(i);
0219     }
0220 }
0221 
0222 static void ath10k_fw_stats_peers_free(struct list_head *head)
0223 {
0224     struct ath10k_fw_stats_peer *i, *tmp;
0225 
0226     list_for_each_entry_safe(i, tmp, head, list) {
0227         list_del(&i->list);
0228         kfree(i);
0229     }
0230 }
0231 
0232 static void ath10k_fw_extd_stats_peers_free(struct list_head *head)
0233 {
0234     struct ath10k_fw_extd_stats_peer *i, *tmp;
0235 
0236     list_for_each_entry_safe(i, tmp, head, list) {
0237         list_del(&i->list);
0238         kfree(i);
0239     }
0240 }
0241 
0242 static void ath10k_debug_fw_stats_reset(struct ath10k *ar)
0243 {
0244     spin_lock_bh(&ar->data_lock);
0245     ar->debug.fw_stats_done = false;
0246     ar->debug.fw_stats.extended = false;
0247     ath10k_fw_stats_pdevs_free(&ar->debug.fw_stats.pdevs);
0248     ath10k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
0249     ath10k_fw_stats_peers_free(&ar->debug.fw_stats.peers);
0250     ath10k_fw_extd_stats_peers_free(&ar->debug.fw_stats.peers_extd);
0251     spin_unlock_bh(&ar->data_lock);
0252 }
0253 
0254 void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
0255 {
0256     struct ath10k_fw_stats stats = {};
0257     bool is_start, is_started, is_end;
0258     size_t num_peers;
0259     size_t num_vdevs;
0260     int ret;
0261 
0262     INIT_LIST_HEAD(&stats.pdevs);
0263     INIT_LIST_HEAD(&stats.vdevs);
0264     INIT_LIST_HEAD(&stats.peers);
0265     INIT_LIST_HEAD(&stats.peers_extd);
0266 
0267     spin_lock_bh(&ar->data_lock);
0268     ret = ath10k_wmi_pull_fw_stats(ar, skb, &stats);
0269     if (ret) {
0270         ath10k_warn(ar, "failed to pull fw stats: %d\n", ret);
0271         goto free;
0272     }
0273 
0274     /* Stat data may exceed htc-wmi buffer limit. In such case firmware
0275      * splits the stats data and delivers it in a ping-pong fashion of
0276      * request cmd-update event.
0277      *
0278      * However there is no explicit end-of-data. Instead start-of-data is
0279      * used as an implicit one. This works as follows:
0280      *  a) discard stat update events until one with pdev stats is
0281      *     delivered - this skips session started at end of (b)
0282      *  b) consume stat update events until another one with pdev stats is
0283      *     delivered which is treated as end-of-data and is itself discarded
0284      */
0285     if (ath10k_peer_stats_enabled(ar))
0286         ath10k_sta_update_rx_duration(ar, &stats);
0287 
0288     if (ar->debug.fw_stats_done) {
0289         if (!ath10k_peer_stats_enabled(ar))
0290             ath10k_warn(ar, "received unsolicited stats update event\n");
0291 
0292         goto free;
0293     }
0294 
0295     num_peers = ath10k_wmi_fw_stats_num_peers(&ar->debug.fw_stats.peers);
0296     num_vdevs = ath10k_wmi_fw_stats_num_vdevs(&ar->debug.fw_stats.vdevs);
0297     is_start = (list_empty(&ar->debug.fw_stats.pdevs) &&
0298             !list_empty(&stats.pdevs));
0299     is_end = (!list_empty(&ar->debug.fw_stats.pdevs) &&
0300           !list_empty(&stats.pdevs));
0301 
0302     if (is_start)
0303         list_splice_tail_init(&stats.pdevs, &ar->debug.fw_stats.pdevs);
0304 
0305     if (is_end)
0306         ar->debug.fw_stats_done = true;
0307 
0308     if (stats.extended)
0309         ar->debug.fw_stats.extended = true;
0310 
0311     is_started = !list_empty(&ar->debug.fw_stats.pdevs);
0312 
0313     if (is_started && !is_end) {
0314         if (num_peers >= ATH10K_MAX_NUM_PEER_IDS) {
0315             /* Although this is unlikely impose a sane limit to
0316              * prevent firmware from DoS-ing the host.
0317              */
0318             ath10k_fw_stats_peers_free(&ar->debug.fw_stats.peers);
0319             ath10k_fw_extd_stats_peers_free(&ar->debug.fw_stats.peers_extd);
0320             ath10k_warn(ar, "dropping fw peer stats\n");
0321             goto free;
0322         }
0323 
0324         if (num_vdevs >= BITS_PER_LONG) {
0325             ath10k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
0326             ath10k_warn(ar, "dropping fw vdev stats\n");
0327             goto free;
0328         }
0329 
0330         if (!list_empty(&stats.peers))
0331             list_splice_tail_init(&stats.peers_extd,
0332                           &ar->debug.fw_stats.peers_extd);
0333 
0334         list_splice_tail_init(&stats.peers, &ar->debug.fw_stats.peers);
0335         list_splice_tail_init(&stats.vdevs, &ar->debug.fw_stats.vdevs);
0336     }
0337 
0338     complete(&ar->debug.fw_stats_complete);
0339 
0340 free:
0341     /* In some cases lists have been spliced and cleared. Free up
0342      * resources if that is not the case.
0343      */
0344     ath10k_fw_stats_pdevs_free(&stats.pdevs);
0345     ath10k_fw_stats_vdevs_free(&stats.vdevs);
0346     ath10k_fw_stats_peers_free(&stats.peers);
0347     ath10k_fw_extd_stats_peers_free(&stats.peers_extd);
0348 
0349     spin_unlock_bh(&ar->data_lock);
0350 }
0351 
0352 int ath10k_debug_fw_stats_request(struct ath10k *ar)
0353 {
0354     unsigned long timeout, time_left;
0355     int ret;
0356 
0357     lockdep_assert_held(&ar->conf_mutex);
0358 
0359     timeout = jiffies + msecs_to_jiffies(1 * HZ);
0360 
0361     ath10k_debug_fw_stats_reset(ar);
0362 
0363     for (;;) {
0364         if (time_after(jiffies, timeout))
0365             return -ETIMEDOUT;
0366 
0367         reinit_completion(&ar->debug.fw_stats_complete);
0368 
0369         ret = ath10k_wmi_request_stats(ar, ar->fw_stats_req_mask);
0370         if (ret) {
0371             ath10k_warn(ar, "could not request stats (%d)\n", ret);
0372             return ret;
0373         }
0374 
0375         time_left =
0376         wait_for_completion_timeout(&ar->debug.fw_stats_complete,
0377                         1 * HZ);
0378         if (!time_left)
0379             return -ETIMEDOUT;
0380 
0381         spin_lock_bh(&ar->data_lock);
0382         if (ar->debug.fw_stats_done) {
0383             spin_unlock_bh(&ar->data_lock);
0384             break;
0385         }
0386         spin_unlock_bh(&ar->data_lock);
0387     }
0388 
0389     return 0;
0390 }
0391 
0392 static int ath10k_fw_stats_open(struct inode *inode, struct file *file)
0393 {
0394     struct ath10k *ar = inode->i_private;
0395     void *buf = NULL;
0396     int ret;
0397 
0398     mutex_lock(&ar->conf_mutex);
0399 
0400     if (ar->state != ATH10K_STATE_ON) {
0401         ret = -ENETDOWN;
0402         goto err_unlock;
0403     }
0404 
0405     buf = vmalloc(ATH10K_FW_STATS_BUF_SIZE);
0406     if (!buf) {
0407         ret = -ENOMEM;
0408         goto err_unlock;
0409     }
0410 
0411     ret = ath10k_debug_fw_stats_request(ar);
0412     if (ret) {
0413         ath10k_warn(ar, "failed to request fw stats: %d\n", ret);
0414         goto err_free;
0415     }
0416 
0417     ret = ath10k_wmi_fw_stats_fill(ar, &ar->debug.fw_stats, buf);
0418     if (ret) {
0419         ath10k_warn(ar, "failed to fill fw stats: %d\n", ret);
0420         goto err_free;
0421     }
0422 
0423     file->private_data = buf;
0424 
0425     mutex_unlock(&ar->conf_mutex);
0426     return 0;
0427 
0428 err_free:
0429     vfree(buf);
0430 
0431 err_unlock:
0432     mutex_unlock(&ar->conf_mutex);
0433     return ret;
0434 }
0435 
0436 static int ath10k_fw_stats_release(struct inode *inode, struct file *file)
0437 {
0438     vfree(file->private_data);
0439 
0440     return 0;
0441 }
0442 
0443 static ssize_t ath10k_fw_stats_read(struct file *file, char __user *user_buf,
0444                     size_t count, loff_t *ppos)
0445 {
0446     const char *buf = file->private_data;
0447     size_t len = strlen(buf);
0448 
0449     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0450 }
0451 
0452 static const struct file_operations fops_fw_stats = {
0453     .open = ath10k_fw_stats_open,
0454     .release = ath10k_fw_stats_release,
0455     .read = ath10k_fw_stats_read,
0456     .owner = THIS_MODULE,
0457     .llseek = default_llseek,
0458 };
0459 
0460 static ssize_t ath10k_debug_fw_reset_stats_read(struct file *file,
0461                         char __user *user_buf,
0462                         size_t count, loff_t *ppos)
0463 {
0464     struct ath10k *ar = file->private_data;
0465     int ret;
0466     size_t len = 0, buf_len = 500;
0467     char *buf;
0468 
0469     buf = kmalloc(buf_len, GFP_KERNEL);
0470     if (!buf)
0471         return -ENOMEM;
0472 
0473     spin_lock_bh(&ar->data_lock);
0474 
0475     len += scnprintf(buf + len, buf_len - len,
0476              "fw_crash_counter\t\t%d\n", ar->stats.fw_crash_counter);
0477     len += scnprintf(buf + len, buf_len - len,
0478              "fw_warm_reset_counter\t\t%d\n",
0479              ar->stats.fw_warm_reset_counter);
0480     len += scnprintf(buf + len, buf_len - len,
0481              "fw_cold_reset_counter\t\t%d\n",
0482              ar->stats.fw_cold_reset_counter);
0483 
0484     spin_unlock_bh(&ar->data_lock);
0485 
0486     ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
0487 
0488     kfree(buf);
0489 
0490     return ret;
0491 }
0492 
0493 static const struct file_operations fops_fw_reset_stats = {
0494     .open = simple_open,
0495     .read = ath10k_debug_fw_reset_stats_read,
0496     .owner = THIS_MODULE,
0497     .llseek = default_llseek,
0498 };
0499 
0500 /* This is a clean assert crash in firmware. */
0501 static int ath10k_debug_fw_assert(struct ath10k *ar)
0502 {
0503     struct wmi_vdev_install_key_cmd *cmd;
0504     struct sk_buff *skb;
0505 
0506     skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd) + 16);
0507     if (!skb)
0508         return -ENOMEM;
0509 
0510     cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
0511     memset(cmd, 0, sizeof(*cmd));
0512 
0513     /* big enough number so that firmware asserts */
0514     cmd->vdev_id = __cpu_to_le32(0x7ffe);
0515 
0516     return ath10k_wmi_cmd_send(ar, skb,
0517                    ar->wmi.cmd->vdev_install_key_cmdid);
0518 }
0519 
0520 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
0521                          char __user *user_buf,
0522                          size_t count, loff_t *ppos)
0523 {
0524     const char buf[] =
0525         "To simulate firmware crash write one of the keywords to this file:\n"
0526         "`soft` - this will send WMI_FORCE_FW_HANG_ASSERT to firmware if FW supports that command.\n"
0527         "`hard` - this will send to firmware command with illegal parameters causing firmware crash.\n"
0528         "`assert` - this will send special illegal parameter to firmware to cause assert failure and crash.\n"
0529         "`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n";
0530 
0531     return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
0532 }
0533 
0534 /* Simulate firmware crash:
0535  * 'soft': Call wmi command causing firmware hang. This firmware hang is
0536  * recoverable by warm firmware reset.
0537  * 'hard': Force firmware crash by setting any vdev parameter for not allowed
0538  * vdev id. This is hard firmware crash because it is recoverable only by cold
0539  * firmware reset.
0540  */
0541 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
0542                           const char __user *user_buf,
0543                           size_t count, loff_t *ppos)
0544 {
0545     struct ath10k *ar = file->private_data;
0546     char buf[32] = {0};
0547     ssize_t rc;
0548     int ret;
0549 
0550     /* filter partial writes and invalid commands */
0551     if (*ppos != 0 || count >= sizeof(buf) || count == 0)
0552         return -EINVAL;
0553 
0554     rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
0555     if (rc < 0)
0556         return rc;
0557 
0558     /* drop the possible '\n' from the end */
0559     if (buf[*ppos - 1] == '\n')
0560         buf[*ppos - 1] = '\0';
0561 
0562     mutex_lock(&ar->conf_mutex);
0563 
0564     if (ar->state != ATH10K_STATE_ON &&
0565         ar->state != ATH10K_STATE_RESTARTED) {
0566         ret = -ENETDOWN;
0567         goto exit;
0568     }
0569 
0570     if (!strcmp(buf, "soft")) {
0571         ath10k_info(ar, "simulating soft firmware crash\n");
0572         ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
0573     } else if (!strcmp(buf, "hard")) {
0574         ath10k_info(ar, "simulating hard firmware crash\n");
0575         /* 0x7fff is vdev id, and it is always out of range for all
0576          * firmware variants in order to force a firmware crash.
0577          */
0578         ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
0579                         ar->wmi.vdev_param->rts_threshold,
0580                         0);
0581     } else if (!strcmp(buf, "assert")) {
0582         ath10k_info(ar, "simulating firmware assert crash\n");
0583         ret = ath10k_debug_fw_assert(ar);
0584     } else if (!strcmp(buf, "hw-restart")) {
0585         ath10k_info(ar, "user requested hw restart\n");
0586         ath10k_core_start_recovery(ar);
0587         ret = 0;
0588     } else {
0589         ret = -EINVAL;
0590         goto exit;
0591     }
0592 
0593     if (ret) {
0594         ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
0595         goto exit;
0596     }
0597 
0598     ret = count;
0599 
0600 exit:
0601     mutex_unlock(&ar->conf_mutex);
0602     return ret;
0603 }
0604 
0605 static const struct file_operations fops_simulate_fw_crash = {
0606     .read = ath10k_read_simulate_fw_crash,
0607     .write = ath10k_write_simulate_fw_crash,
0608     .open = simple_open,
0609     .owner = THIS_MODULE,
0610     .llseek = default_llseek,
0611 };
0612 
0613 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
0614                    size_t count, loff_t *ppos)
0615 {
0616     struct ath10k *ar = file->private_data;
0617     size_t len;
0618     char buf[50];
0619 
0620     len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->bus_param.chip_id);
0621 
0622     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0623 }
0624 
0625 static const struct file_operations fops_chip_id = {
0626     .read = ath10k_read_chip_id,
0627     .open = simple_open,
0628     .owner = THIS_MODULE,
0629     .llseek = default_llseek,
0630 };
0631 
0632 static ssize_t ath10k_reg_addr_read(struct file *file,
0633                     char __user *user_buf,
0634                     size_t count, loff_t *ppos)
0635 {
0636     struct ath10k *ar = file->private_data;
0637     u8 buf[32];
0638     size_t len = 0;
0639     u32 reg_addr;
0640 
0641     mutex_lock(&ar->conf_mutex);
0642     reg_addr = ar->debug.reg_addr;
0643     mutex_unlock(&ar->conf_mutex);
0644 
0645     len += scnprintf(buf + len, sizeof(buf) - len, "0x%x\n", reg_addr);
0646 
0647     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0648 }
0649 
0650 static ssize_t ath10k_reg_addr_write(struct file *file,
0651                      const char __user *user_buf,
0652                      size_t count, loff_t *ppos)
0653 {
0654     struct ath10k *ar = file->private_data;
0655     u32 reg_addr;
0656     int ret;
0657 
0658     ret = kstrtou32_from_user(user_buf, count, 0, &reg_addr);
0659     if (ret)
0660         return ret;
0661 
0662     if (!IS_ALIGNED(reg_addr, 4))
0663         return -EFAULT;
0664 
0665     mutex_lock(&ar->conf_mutex);
0666     ar->debug.reg_addr = reg_addr;
0667     mutex_unlock(&ar->conf_mutex);
0668 
0669     return count;
0670 }
0671 
0672 static const struct file_operations fops_reg_addr = {
0673     .read = ath10k_reg_addr_read,
0674     .write = ath10k_reg_addr_write,
0675     .open = simple_open,
0676     .owner = THIS_MODULE,
0677     .llseek = default_llseek,
0678 };
0679 
0680 static ssize_t ath10k_reg_value_read(struct file *file,
0681                      char __user *user_buf,
0682                      size_t count, loff_t *ppos)
0683 {
0684     struct ath10k *ar = file->private_data;
0685     u8 buf[48];
0686     size_t len;
0687     u32 reg_addr, reg_val;
0688     int ret;
0689 
0690     mutex_lock(&ar->conf_mutex);
0691 
0692     if (ar->state != ATH10K_STATE_ON &&
0693         ar->state != ATH10K_STATE_UTF) {
0694         ret = -ENETDOWN;
0695         goto exit;
0696     }
0697 
0698     reg_addr = ar->debug.reg_addr;
0699 
0700     reg_val = ath10k_hif_read32(ar, reg_addr);
0701     len = scnprintf(buf, sizeof(buf), "0x%08x:0x%08x\n", reg_addr, reg_val);
0702 
0703     ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
0704 
0705 exit:
0706     mutex_unlock(&ar->conf_mutex);
0707 
0708     return ret;
0709 }
0710 
0711 static ssize_t ath10k_reg_value_write(struct file *file,
0712                       const char __user *user_buf,
0713                       size_t count, loff_t *ppos)
0714 {
0715     struct ath10k *ar = file->private_data;
0716     u32 reg_addr, reg_val;
0717     int ret;
0718 
0719     mutex_lock(&ar->conf_mutex);
0720 
0721     if (ar->state != ATH10K_STATE_ON &&
0722         ar->state != ATH10K_STATE_UTF) {
0723         ret = -ENETDOWN;
0724         goto exit;
0725     }
0726 
0727     reg_addr = ar->debug.reg_addr;
0728 
0729     ret = kstrtou32_from_user(user_buf, count, 0, &reg_val);
0730     if (ret)
0731         goto exit;
0732 
0733     ath10k_hif_write32(ar, reg_addr, reg_val);
0734 
0735     ret = count;
0736 
0737 exit:
0738     mutex_unlock(&ar->conf_mutex);
0739 
0740     return ret;
0741 }
0742 
0743 static const struct file_operations fops_reg_value = {
0744     .read = ath10k_reg_value_read,
0745     .write = ath10k_reg_value_write,
0746     .open = simple_open,
0747     .owner = THIS_MODULE,
0748     .llseek = default_llseek,
0749 };
0750 
0751 static ssize_t ath10k_mem_value_read(struct file *file,
0752                      char __user *user_buf,
0753                      size_t count, loff_t *ppos)
0754 {
0755     struct ath10k *ar = file->private_data;
0756     u8 *buf;
0757     int ret;
0758 
0759     if (*ppos < 0)
0760         return -EINVAL;
0761 
0762     if (!count)
0763         return 0;
0764 
0765     mutex_lock(&ar->conf_mutex);
0766 
0767     buf = vmalloc(count);
0768     if (!buf) {
0769         ret = -ENOMEM;
0770         goto exit;
0771     }
0772 
0773     if (ar->state != ATH10K_STATE_ON &&
0774         ar->state != ATH10K_STATE_UTF) {
0775         ret = -ENETDOWN;
0776         goto exit;
0777     }
0778 
0779     ret = ath10k_hif_diag_read(ar, *ppos, buf, count);
0780     if (ret) {
0781         ath10k_warn(ar, "failed to read address 0x%08x via diagnose window from debugfs: %d\n",
0782                 (u32)(*ppos), ret);
0783         goto exit;
0784     }
0785 
0786     ret = copy_to_user(user_buf, buf, count);
0787     if (ret) {
0788         ret = -EFAULT;
0789         goto exit;
0790     }
0791 
0792     count -= ret;
0793     *ppos += count;
0794     ret = count;
0795 
0796 exit:
0797     vfree(buf);
0798     mutex_unlock(&ar->conf_mutex);
0799 
0800     return ret;
0801 }
0802 
0803 static ssize_t ath10k_mem_value_write(struct file *file,
0804                       const char __user *user_buf,
0805                       size_t count, loff_t *ppos)
0806 {
0807     struct ath10k *ar = file->private_data;
0808     u8 *buf;
0809     int ret;
0810 
0811     if (*ppos < 0)
0812         return -EINVAL;
0813 
0814     if (!count)
0815         return 0;
0816 
0817     mutex_lock(&ar->conf_mutex);
0818 
0819     buf = vmalloc(count);
0820     if (!buf) {
0821         ret = -ENOMEM;
0822         goto exit;
0823     }
0824 
0825     if (ar->state != ATH10K_STATE_ON &&
0826         ar->state != ATH10K_STATE_UTF) {
0827         ret = -ENETDOWN;
0828         goto exit;
0829     }
0830 
0831     ret = copy_from_user(buf, user_buf, count);
0832     if (ret) {
0833         ret = -EFAULT;
0834         goto exit;
0835     }
0836 
0837     ret = ath10k_hif_diag_write(ar, *ppos, buf, count);
0838     if (ret) {
0839         ath10k_warn(ar, "failed to write address 0x%08x via diagnose window from debugfs: %d\n",
0840                 (u32)(*ppos), ret);
0841         goto exit;
0842     }
0843 
0844     *ppos += count;
0845     ret = count;
0846 
0847 exit:
0848     vfree(buf);
0849     mutex_unlock(&ar->conf_mutex);
0850 
0851     return ret;
0852 }
0853 
0854 static const struct file_operations fops_mem_value = {
0855     .read = ath10k_mem_value_read,
0856     .write = ath10k_mem_value_write,
0857     .open = simple_open,
0858     .owner = THIS_MODULE,
0859     .llseek = default_llseek,
0860 };
0861 
0862 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
0863 {
0864     u64 cookie;
0865     int ret;
0866 
0867     lockdep_assert_held(&ar->conf_mutex);
0868 
0869     if (ar->debug.htt_stats_mask == 0)
0870         /* htt stats are disabled */
0871         return 0;
0872 
0873     if (ar->state != ATH10K_STATE_ON)
0874         return 0;
0875 
0876     cookie = get_jiffies_64();
0877 
0878     ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
0879                        ar->debug.reset_htt_stats, cookie);
0880     if (ret) {
0881         ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
0882         return ret;
0883     }
0884 
0885     queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
0886                msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
0887 
0888     return 0;
0889 }
0890 
0891 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
0892 {
0893     struct ath10k *ar = container_of(work, struct ath10k,
0894                      debug.htt_stats_dwork.work);
0895 
0896     mutex_lock(&ar->conf_mutex);
0897 
0898     ath10k_debug_htt_stats_req(ar);
0899 
0900     mutex_unlock(&ar->conf_mutex);
0901 }
0902 
0903 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
0904                       char __user *user_buf,
0905                       size_t count, loff_t *ppos)
0906 {
0907     struct ath10k *ar = file->private_data;
0908     char buf[32];
0909     size_t len;
0910 
0911     len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
0912 
0913     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0914 }
0915 
0916 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
0917                        const char __user *user_buf,
0918                        size_t count, loff_t *ppos)
0919 {
0920     struct ath10k *ar = file->private_data;
0921     unsigned long mask;
0922     int ret;
0923 
0924     ret = kstrtoul_from_user(user_buf, count, 0, &mask);
0925     if (ret)
0926         return ret;
0927 
0928     /* max 17 bit masks (for now) */
0929     if (mask > HTT_STATS_BIT_MASK)
0930         return -E2BIG;
0931 
0932     mutex_lock(&ar->conf_mutex);
0933 
0934     ar->debug.htt_stats_mask = mask;
0935 
0936     ret = ath10k_debug_htt_stats_req(ar);
0937     if (ret)
0938         goto out;
0939 
0940     ret = count;
0941 
0942 out:
0943     mutex_unlock(&ar->conf_mutex);
0944 
0945     return ret;
0946 }
0947 
0948 static const struct file_operations fops_htt_stats_mask = {
0949     .read = ath10k_read_htt_stats_mask,
0950     .write = ath10k_write_htt_stats_mask,
0951     .open = simple_open,
0952     .owner = THIS_MODULE,
0953     .llseek = default_llseek,
0954 };
0955 
0956 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
0957                            char __user *user_buf,
0958                            size_t count, loff_t *ppos)
0959 {
0960     struct ath10k *ar = file->private_data;
0961     char buf[64];
0962     u8 amsdu, ampdu;
0963     size_t len;
0964 
0965     mutex_lock(&ar->conf_mutex);
0966 
0967     amsdu = ar->htt.max_num_amsdu;
0968     ampdu = ar->htt.max_num_ampdu;
0969     mutex_unlock(&ar->conf_mutex);
0970 
0971     len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
0972 
0973     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
0974 }
0975 
0976 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
0977                         const char __user *user_buf,
0978                         size_t count, loff_t *ppos)
0979 {
0980     struct ath10k *ar = file->private_data;
0981     int res;
0982     char buf[64] = {0};
0983     unsigned int amsdu, ampdu;
0984 
0985     res = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
0986                      user_buf, count);
0987     if (res <= 0)
0988         return res;
0989 
0990     res = sscanf(buf, "%u %u", &amsdu, &ampdu);
0991 
0992     if (res != 2)
0993         return -EINVAL;
0994 
0995     mutex_lock(&ar->conf_mutex);
0996 
0997     res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
0998     if (res)
0999         goto out;
1000 
1001     res = count;
1002     ar->htt.max_num_amsdu = amsdu;
1003     ar->htt.max_num_ampdu = ampdu;
1004 
1005 out:
1006     mutex_unlock(&ar->conf_mutex);
1007     return res;
1008 }
1009 
1010 static const struct file_operations fops_htt_max_amsdu_ampdu = {
1011     .read = ath10k_read_htt_max_amsdu_ampdu,
1012     .write = ath10k_write_htt_max_amsdu_ampdu,
1013     .open = simple_open,
1014     .owner = THIS_MODULE,
1015     .llseek = default_llseek,
1016 };
1017 
1018 static ssize_t ath10k_read_fw_dbglog(struct file *file,
1019                      char __user *user_buf,
1020                      size_t count, loff_t *ppos)
1021 {
1022     struct ath10k *ar = file->private_data;
1023     size_t len;
1024     char buf[96];
1025 
1026     len = scnprintf(buf, sizeof(buf), "0x%16llx %u\n",
1027             ar->debug.fw_dbglog_mask, ar->debug.fw_dbglog_level);
1028 
1029     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1030 }
1031 
1032 static ssize_t ath10k_write_fw_dbglog(struct file *file,
1033                       const char __user *user_buf,
1034                       size_t count, loff_t *ppos)
1035 {
1036     struct ath10k *ar = file->private_data;
1037     int ret;
1038     char buf[96] = {0};
1039     unsigned int log_level;
1040     u64 mask;
1041 
1042     ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
1043                      user_buf, count);
1044     if (ret <= 0)
1045         return ret;
1046 
1047     ret = sscanf(buf, "%llx %u", &mask, &log_level);
1048 
1049     if (!ret)
1050         return -EINVAL;
1051 
1052     if (ret == 1)
1053         /* default if user did not specify */
1054         log_level = ATH10K_DBGLOG_LEVEL_WARN;
1055 
1056     mutex_lock(&ar->conf_mutex);
1057 
1058     ar->debug.fw_dbglog_mask = mask;
1059     ar->debug.fw_dbglog_level = log_level;
1060 
1061     if (ar->state == ATH10K_STATE_ON) {
1062         ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1063                         ar->debug.fw_dbglog_level);
1064         if (ret) {
1065             ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1066                     ret);
1067             goto exit;
1068         }
1069     }
1070 
1071     ret = count;
1072 
1073 exit:
1074     mutex_unlock(&ar->conf_mutex);
1075 
1076     return ret;
1077 }
1078 
1079 /* TODO:  Would be nice to always support ethtool stats, would need to
1080  * move the stats storage out of ath10k_debug, or always have ath10k_debug
1081  * struct available..
1082  */
1083 
1084 /* This generally cooresponds to the debugfs fw_stats file */
1085 static const char ath10k_gstrings_stats[][ETH_GSTRING_LEN] = {
1086     "tx_pkts_nic",
1087     "tx_bytes_nic",
1088     "rx_pkts_nic",
1089     "rx_bytes_nic",
1090     "d_noise_floor",
1091     "d_cycle_count",
1092     "d_phy_error",
1093     "d_rts_bad",
1094     "d_rts_good",
1095     "d_tx_power", /* in .5 dbM I think */
1096     "d_rx_crc_err", /* fcs_bad */
1097     "d_rx_crc_err_drop", /* frame with FCS error, dropped late in kernel */
1098     "d_no_beacon",
1099     "d_tx_mpdus_queued",
1100     "d_tx_msdu_queued",
1101     "d_tx_msdu_dropped",
1102     "d_local_enqued",
1103     "d_local_freed",
1104     "d_tx_ppdu_hw_queued",
1105     "d_tx_ppdu_reaped",
1106     "d_tx_fifo_underrun",
1107     "d_tx_ppdu_abort",
1108     "d_tx_mpdu_requeued",
1109     "d_tx_excessive_retries",
1110     "d_tx_hw_rate",
1111     "d_tx_dropped_sw_retries",
1112     "d_tx_illegal_rate",
1113     "d_tx_continuous_xretries",
1114     "d_tx_timeout",
1115     "d_tx_mpdu_txop_limit",
1116     "d_pdev_resets",
1117     "d_rx_mid_ppdu_route_change",
1118     "d_rx_status",
1119     "d_rx_extra_frags_ring0",
1120     "d_rx_extra_frags_ring1",
1121     "d_rx_extra_frags_ring2",
1122     "d_rx_extra_frags_ring3",
1123     "d_rx_msdu_htt",
1124     "d_rx_mpdu_htt",
1125     "d_rx_msdu_stack",
1126     "d_rx_mpdu_stack",
1127     "d_rx_phy_err",
1128     "d_rx_phy_err_drops",
1129     "d_rx_mpdu_errors", /* FCS, MIC, ENC */
1130     "d_fw_crash_count",
1131     "d_fw_warm_reset_count",
1132     "d_fw_cold_reset_count",
1133 };
1134 
1135 #define ATH10K_SSTATS_LEN ARRAY_SIZE(ath10k_gstrings_stats)
1136 
1137 void ath10k_debug_get_et_strings(struct ieee80211_hw *hw,
1138                  struct ieee80211_vif *vif,
1139                  u32 sset, u8 *data)
1140 {
1141     if (sset == ETH_SS_STATS)
1142         memcpy(data, *ath10k_gstrings_stats,
1143                sizeof(ath10k_gstrings_stats));
1144 }
1145 
1146 int ath10k_debug_get_et_sset_count(struct ieee80211_hw *hw,
1147                    struct ieee80211_vif *vif, int sset)
1148 {
1149     if (sset == ETH_SS_STATS)
1150         return ATH10K_SSTATS_LEN;
1151 
1152     return 0;
1153 }
1154 
1155 void ath10k_debug_get_et_stats(struct ieee80211_hw *hw,
1156                    struct ieee80211_vif *vif,
1157                    struct ethtool_stats *stats, u64 *data)
1158 {
1159     struct ath10k *ar = hw->priv;
1160     static const struct ath10k_fw_stats_pdev zero_stats = {};
1161     const struct ath10k_fw_stats_pdev *pdev_stats;
1162     int i = 0, ret;
1163 
1164     mutex_lock(&ar->conf_mutex);
1165 
1166     if (ar->state == ATH10K_STATE_ON) {
1167         ret = ath10k_debug_fw_stats_request(ar);
1168         if (ret) {
1169             /* just print a warning and try to use older results */
1170             ath10k_warn(ar,
1171                     "failed to get fw stats for ethtool: %d\n",
1172                     ret);
1173         }
1174     }
1175 
1176     pdev_stats = list_first_entry_or_null(&ar->debug.fw_stats.pdevs,
1177                           struct ath10k_fw_stats_pdev,
1178                           list);
1179     if (!pdev_stats) {
1180         /* no results available so just return zeroes */
1181         pdev_stats = &zero_stats;
1182     }
1183 
1184     spin_lock_bh(&ar->data_lock);
1185 
1186     data[i++] = pdev_stats->hw_reaped; /* ppdu reaped */
1187     data[i++] = 0; /* tx bytes */
1188     data[i++] = pdev_stats->htt_mpdus;
1189     data[i++] = 0; /* rx bytes */
1190     data[i++] = pdev_stats->ch_noise_floor;
1191     data[i++] = pdev_stats->cycle_count;
1192     data[i++] = pdev_stats->phy_err_count;
1193     data[i++] = pdev_stats->rts_bad;
1194     data[i++] = pdev_stats->rts_good;
1195     data[i++] = pdev_stats->chan_tx_power;
1196     data[i++] = pdev_stats->fcs_bad;
1197     data[i++] = ar->stats.rx_crc_err_drop;
1198     data[i++] = pdev_stats->no_beacons;
1199     data[i++] = pdev_stats->mpdu_enqued;
1200     data[i++] = pdev_stats->msdu_enqued;
1201     data[i++] = pdev_stats->wmm_drop;
1202     data[i++] = pdev_stats->local_enqued;
1203     data[i++] = pdev_stats->local_freed;
1204     data[i++] = pdev_stats->hw_queued;
1205     data[i++] = pdev_stats->hw_reaped;
1206     data[i++] = pdev_stats->underrun;
1207     data[i++] = pdev_stats->tx_abort;
1208     data[i++] = pdev_stats->mpdus_requeued;
1209     data[i++] = pdev_stats->tx_ko;
1210     data[i++] = pdev_stats->data_rc;
1211     data[i++] = pdev_stats->sw_retry_failure;
1212     data[i++] = pdev_stats->illgl_rate_phy_err;
1213     data[i++] = pdev_stats->pdev_cont_xretry;
1214     data[i++] = pdev_stats->pdev_tx_timeout;
1215     data[i++] = pdev_stats->txop_ovf;
1216     data[i++] = pdev_stats->pdev_resets;
1217     data[i++] = pdev_stats->mid_ppdu_route_change;
1218     data[i++] = pdev_stats->status_rcvd;
1219     data[i++] = pdev_stats->r0_frags;
1220     data[i++] = pdev_stats->r1_frags;
1221     data[i++] = pdev_stats->r2_frags;
1222     data[i++] = pdev_stats->r3_frags;
1223     data[i++] = pdev_stats->htt_msdus;
1224     data[i++] = pdev_stats->htt_mpdus;
1225     data[i++] = pdev_stats->loc_msdus;
1226     data[i++] = pdev_stats->loc_mpdus;
1227     data[i++] = pdev_stats->phy_errs;
1228     data[i++] = pdev_stats->phy_err_drop;
1229     data[i++] = pdev_stats->mpdu_errs;
1230     data[i++] = ar->stats.fw_crash_counter;
1231     data[i++] = ar->stats.fw_warm_reset_counter;
1232     data[i++] = ar->stats.fw_cold_reset_counter;
1233 
1234     spin_unlock_bh(&ar->data_lock);
1235 
1236     mutex_unlock(&ar->conf_mutex);
1237 
1238     WARN_ON(i != ATH10K_SSTATS_LEN);
1239 }
1240 
1241 static const struct file_operations fops_fw_dbglog = {
1242     .read = ath10k_read_fw_dbglog,
1243     .write = ath10k_write_fw_dbglog,
1244     .open = simple_open,
1245     .owner = THIS_MODULE,
1246     .llseek = default_llseek,
1247 };
1248 
1249 static int ath10k_debug_cal_data_fetch(struct ath10k *ar)
1250 {
1251     u32 hi_addr;
1252     __le32 addr;
1253     int ret;
1254 
1255     lockdep_assert_held(&ar->conf_mutex);
1256 
1257     if (WARN_ON(ar->hw_params.cal_data_len > ATH10K_DEBUG_CAL_DATA_LEN))
1258         return -EINVAL;
1259 
1260     if (ar->hw_params.cal_data_len == 0)
1261         return -EOPNOTSUPP;
1262 
1263     hi_addr = host_interest_item_address(HI_ITEM(hi_board_data));
1264 
1265     ret = ath10k_hif_diag_read(ar, hi_addr, &addr, sizeof(addr));
1266     if (ret) {
1267         ath10k_warn(ar, "failed to read hi_board_data address: %d\n",
1268                 ret);
1269         return ret;
1270     }
1271 
1272     ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), ar->debug.cal_data,
1273                    ar->hw_params.cal_data_len);
1274     if (ret) {
1275         ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
1276         return ret;
1277     }
1278 
1279     return 0;
1280 }
1281 
1282 static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
1283 {
1284     struct ath10k *ar = inode->i_private;
1285 
1286     mutex_lock(&ar->conf_mutex);
1287 
1288     if (ar->state == ATH10K_STATE_ON ||
1289         ar->state == ATH10K_STATE_UTF) {
1290         ath10k_debug_cal_data_fetch(ar);
1291     }
1292 
1293     file->private_data = ar;
1294     mutex_unlock(&ar->conf_mutex);
1295 
1296     return 0;
1297 }
1298 
1299 static ssize_t ath10k_debug_cal_data_read(struct file *file,
1300                       char __user *user_buf,
1301                       size_t count, loff_t *ppos)
1302 {
1303     struct ath10k *ar = file->private_data;
1304 
1305     mutex_lock(&ar->conf_mutex);
1306 
1307     count = simple_read_from_buffer(user_buf, count, ppos,
1308                     ar->debug.cal_data,
1309                     ar->hw_params.cal_data_len);
1310 
1311     mutex_unlock(&ar->conf_mutex);
1312 
1313     return count;
1314 }
1315 
1316 static ssize_t ath10k_write_ani_enable(struct file *file,
1317                        const char __user *user_buf,
1318                        size_t count, loff_t *ppos)
1319 {
1320     struct ath10k *ar = file->private_data;
1321     int ret;
1322     u8 enable;
1323 
1324     if (kstrtou8_from_user(user_buf, count, 0, &enable))
1325         return -EINVAL;
1326 
1327     mutex_lock(&ar->conf_mutex);
1328 
1329     if (ar->ani_enabled == enable) {
1330         ret = count;
1331         goto exit;
1332     }
1333 
1334     ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->ani_enable,
1335                     enable);
1336     if (ret) {
1337         ath10k_warn(ar, "ani_enable failed from debugfs: %d\n", ret);
1338         goto exit;
1339     }
1340     ar->ani_enabled = enable;
1341 
1342     ret = count;
1343 
1344 exit:
1345     mutex_unlock(&ar->conf_mutex);
1346 
1347     return ret;
1348 }
1349 
1350 static ssize_t ath10k_read_ani_enable(struct file *file, char __user *user_buf,
1351                       size_t count, loff_t *ppos)
1352 {
1353     struct ath10k *ar = file->private_data;
1354     size_t len;
1355     char buf[32];
1356 
1357     len = scnprintf(buf, sizeof(buf), "%d\n", ar->ani_enabled);
1358 
1359     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1360 }
1361 
1362 static const struct file_operations fops_ani_enable = {
1363     .read = ath10k_read_ani_enable,
1364     .write = ath10k_write_ani_enable,
1365     .open = simple_open,
1366     .owner = THIS_MODULE,
1367     .llseek = default_llseek,
1368 };
1369 
1370 static const struct file_operations fops_cal_data = {
1371     .open = ath10k_debug_cal_data_open,
1372     .read = ath10k_debug_cal_data_read,
1373     .owner = THIS_MODULE,
1374     .llseek = default_llseek,
1375 };
1376 
1377 static ssize_t ath10k_read_nf_cal_period(struct file *file,
1378                      char __user *user_buf,
1379                      size_t count, loff_t *ppos)
1380 {
1381     struct ath10k *ar = file->private_data;
1382     size_t len;
1383     char buf[32];
1384 
1385     len = scnprintf(buf, sizeof(buf), "%d\n", ar->debug.nf_cal_period);
1386 
1387     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1388 }
1389 
1390 static ssize_t ath10k_write_nf_cal_period(struct file *file,
1391                       const char __user *user_buf,
1392                       size_t count, loff_t *ppos)
1393 {
1394     struct ath10k *ar = file->private_data;
1395     unsigned long period;
1396     int ret;
1397 
1398     ret = kstrtoul_from_user(user_buf, count, 0, &period);
1399     if (ret)
1400         return ret;
1401 
1402     if (period > WMI_PDEV_PARAM_CAL_PERIOD_MAX)
1403         return -EINVAL;
1404 
1405     /* there's no way to switch back to the firmware default */
1406     if (period == 0)
1407         return -EINVAL;
1408 
1409     mutex_lock(&ar->conf_mutex);
1410 
1411     ar->debug.nf_cal_period = period;
1412 
1413     if (ar->state != ATH10K_STATE_ON) {
1414         /* firmware is not running, nothing else to do */
1415         ret = count;
1416         goto exit;
1417     }
1418 
1419     ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->cal_period,
1420                     ar->debug.nf_cal_period);
1421     if (ret) {
1422         ath10k_warn(ar, "cal period cfg failed from debugfs: %d\n",
1423                 ret);
1424         goto exit;
1425     }
1426 
1427     ret = count;
1428 
1429 exit:
1430     mutex_unlock(&ar->conf_mutex);
1431 
1432     return ret;
1433 }
1434 
1435 static const struct file_operations fops_nf_cal_period = {
1436     .read = ath10k_read_nf_cal_period,
1437     .write = ath10k_write_nf_cal_period,
1438     .open = simple_open,
1439     .owner = THIS_MODULE,
1440     .llseek = default_llseek,
1441 };
1442 
1443 #define ATH10K_TPC_CONFIG_BUF_SIZE  (1024 * 1024)
1444 
1445 static int ath10k_debug_tpc_stats_request(struct ath10k *ar)
1446 {
1447     int ret;
1448     unsigned long time_left;
1449 
1450     lockdep_assert_held(&ar->conf_mutex);
1451 
1452     reinit_completion(&ar->debug.tpc_complete);
1453 
1454     ret = ath10k_wmi_pdev_get_tpc_config(ar, WMI_TPC_CONFIG_PARAM);
1455     if (ret) {
1456         ath10k_warn(ar, "failed to request tpc config: %d\n", ret);
1457         return ret;
1458     }
1459 
1460     time_left = wait_for_completion_timeout(&ar->debug.tpc_complete,
1461                         1 * HZ);
1462     if (time_left == 0)
1463         return -ETIMEDOUT;
1464 
1465     return 0;
1466 }
1467 
1468 void ath10k_debug_tpc_stats_process(struct ath10k *ar,
1469                     struct ath10k_tpc_stats *tpc_stats)
1470 {
1471     spin_lock_bh(&ar->data_lock);
1472 
1473     kfree(ar->debug.tpc_stats);
1474     ar->debug.tpc_stats = tpc_stats;
1475     complete(&ar->debug.tpc_complete);
1476 
1477     spin_unlock_bh(&ar->data_lock);
1478 }
1479 
1480 void
1481 ath10k_debug_tpc_stats_final_process(struct ath10k *ar,
1482                      struct ath10k_tpc_stats_final *tpc_stats)
1483 {
1484     spin_lock_bh(&ar->data_lock);
1485 
1486     kfree(ar->debug.tpc_stats_final);
1487     ar->debug.tpc_stats_final = tpc_stats;
1488     complete(&ar->debug.tpc_complete);
1489 
1490     spin_unlock_bh(&ar->data_lock);
1491 }
1492 
1493 static void ath10k_tpc_stats_print(struct ath10k_tpc_stats *tpc_stats,
1494                    unsigned int j, char *buf, size_t *len)
1495 {
1496     int i;
1497     size_t buf_len;
1498     static const char table_str[][5] = { "CDD",
1499                          "STBC",
1500                          "TXBF" };
1501     static const char pream_str[][6] = { "CCK",
1502                          "OFDM",
1503                          "HT20",
1504                          "HT40",
1505                          "VHT20",
1506                          "VHT40",
1507                          "VHT80",
1508                          "HTCUP" };
1509 
1510     buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1511     *len += scnprintf(buf + *len, buf_len - *len,
1512               "********************************\n");
1513     *len += scnprintf(buf + *len, buf_len - *len,
1514               "******************* %s POWER TABLE ****************\n",
1515               table_str[j]);
1516     *len += scnprintf(buf + *len, buf_len - *len,
1517               "********************************\n");
1518     *len += scnprintf(buf + *len, buf_len - *len,
1519               "No.  Preamble Rate_code ");
1520 
1521     for (i = 0; i < tpc_stats->num_tx_chain; i++)
1522         *len += scnprintf(buf + *len, buf_len - *len,
1523                   "tpc_value%d ", i);
1524 
1525     *len += scnprintf(buf + *len, buf_len - *len, "\n");
1526 
1527     for (i = 0; i < tpc_stats->rate_max; i++) {
1528         *len += scnprintf(buf + *len, buf_len - *len,
1529                   "%8d %s 0x%2x %s\n", i,
1530                   pream_str[tpc_stats->tpc_table[j].pream_idx[i]],
1531                   tpc_stats->tpc_table[j].rate_code[i],
1532                   tpc_stats->tpc_table[j].tpc_value[i]);
1533     }
1534 
1535     *len += scnprintf(buf + *len, buf_len - *len,
1536               "***********************************\n");
1537 }
1538 
1539 static void ath10k_tpc_stats_fill(struct ath10k *ar,
1540                   struct ath10k_tpc_stats *tpc_stats,
1541                   char *buf)
1542 {
1543     int j;
1544     size_t len, buf_len;
1545 
1546     len = 0;
1547     buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1548 
1549     spin_lock_bh(&ar->data_lock);
1550 
1551     if (!tpc_stats) {
1552         ath10k_warn(ar, "failed to get tpc stats\n");
1553         goto unlock;
1554     }
1555 
1556     len += scnprintf(buf + len, buf_len - len, "\n");
1557     len += scnprintf(buf + len, buf_len - len,
1558              "*************************************\n");
1559     len += scnprintf(buf + len, buf_len - len,
1560              "TPC config for channel %4d mode %d\n",
1561              tpc_stats->chan_freq,
1562              tpc_stats->phy_mode);
1563     len += scnprintf(buf + len, buf_len - len,
1564              "*************************************\n");
1565     len += scnprintf(buf + len, buf_len - len,
1566              "CTL       =  0x%2x Reg. Domain        = %2d\n",
1567              tpc_stats->ctl,
1568              tpc_stats->reg_domain);
1569     len += scnprintf(buf + len, buf_len - len,
1570              "Antenna Gain  = %2d Reg. Max Antenna Gain =  %2d\n",
1571              tpc_stats->twice_antenna_gain,
1572              tpc_stats->twice_antenna_reduction);
1573     len += scnprintf(buf + len, buf_len - len,
1574              "Power Limit   = %2d Reg. Max Power        = %2d\n",
1575              tpc_stats->power_limit,
1576              tpc_stats->twice_max_rd_power / 2);
1577     len += scnprintf(buf + len, buf_len - len,
1578              "Num tx chains = %2d Num supported rates   = %2d\n",
1579              tpc_stats->num_tx_chain,
1580              tpc_stats->rate_max);
1581 
1582     for (j = 0; j < WMI_TPC_FLAG; j++) {
1583         switch (j) {
1584         case WMI_TPC_TABLE_TYPE_CDD:
1585             if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1586                 len += scnprintf(buf + len, buf_len - len,
1587                          "CDD not supported\n");
1588                 break;
1589             }
1590 
1591             ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1592             break;
1593         case WMI_TPC_TABLE_TYPE_STBC:
1594             if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1595                 len += scnprintf(buf + len, buf_len - len,
1596                          "STBC not supported\n");
1597                 break;
1598             }
1599 
1600             ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1601             break;
1602         case WMI_TPC_TABLE_TYPE_TXBF:
1603             if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1604                 len += scnprintf(buf + len, buf_len - len,
1605                          "TXBF not supported\n***************************\n");
1606                 break;
1607             }
1608 
1609             ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1610             break;
1611         default:
1612             len += scnprintf(buf + len, buf_len - len,
1613                      "Invalid Type\n");
1614             break;
1615         }
1616     }
1617 
1618 unlock:
1619     spin_unlock_bh(&ar->data_lock);
1620 
1621     if (len >= buf_len)
1622         buf[len - 1] = 0;
1623     else
1624         buf[len] = 0;
1625 }
1626 
1627 static int ath10k_tpc_stats_open(struct inode *inode, struct file *file)
1628 {
1629     struct ath10k *ar = inode->i_private;
1630     void *buf = NULL;
1631     int ret;
1632 
1633     mutex_lock(&ar->conf_mutex);
1634 
1635     if (ar->state != ATH10K_STATE_ON) {
1636         ret = -ENETDOWN;
1637         goto err_unlock;
1638     }
1639 
1640     buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
1641     if (!buf) {
1642         ret = -ENOMEM;
1643         goto err_unlock;
1644     }
1645 
1646     ret = ath10k_debug_tpc_stats_request(ar);
1647     if (ret) {
1648         ath10k_warn(ar, "failed to request tpc config stats: %d\n",
1649                 ret);
1650         goto err_free;
1651     }
1652 
1653     ath10k_tpc_stats_fill(ar, ar->debug.tpc_stats, buf);
1654     file->private_data = buf;
1655 
1656     mutex_unlock(&ar->conf_mutex);
1657     return 0;
1658 
1659 err_free:
1660     vfree(buf);
1661 
1662 err_unlock:
1663     mutex_unlock(&ar->conf_mutex);
1664     return ret;
1665 }
1666 
1667 static int ath10k_tpc_stats_release(struct inode *inode, struct file *file)
1668 {
1669     vfree(file->private_data);
1670 
1671     return 0;
1672 }
1673 
1674 static ssize_t ath10k_tpc_stats_read(struct file *file, char __user *user_buf,
1675                      size_t count, loff_t *ppos)
1676 {
1677     const char *buf = file->private_data;
1678     size_t len = strlen(buf);
1679 
1680     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1681 }
1682 
1683 static const struct file_operations fops_tpc_stats = {
1684     .open = ath10k_tpc_stats_open,
1685     .release = ath10k_tpc_stats_release,
1686     .read = ath10k_tpc_stats_read,
1687     .owner = THIS_MODULE,
1688     .llseek = default_llseek,
1689 };
1690 
1691 int ath10k_debug_start(struct ath10k *ar)
1692 {
1693     int ret;
1694 
1695     lockdep_assert_held(&ar->conf_mutex);
1696 
1697     ret = ath10k_debug_htt_stats_req(ar);
1698     if (ret)
1699         /* continue normally anyway, this isn't serious */
1700         ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1701                 ret);
1702 
1703     if (ar->debug.fw_dbglog_mask) {
1704         ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1705                         ATH10K_DBGLOG_LEVEL_WARN);
1706         if (ret)
1707             /* not serious */
1708             ath10k_warn(ar, "failed to enable dbglog during start: %d",
1709                     ret);
1710     }
1711 
1712     if (ar->pktlog_filter) {
1713         ret = ath10k_wmi_pdev_pktlog_enable(ar,
1714                             ar->pktlog_filter);
1715         if (ret)
1716             /* not serious */
1717             ath10k_warn(ar,
1718                     "failed to enable pktlog filter %x: %d\n",
1719                     ar->pktlog_filter, ret);
1720     } else {
1721         ret = ath10k_wmi_pdev_pktlog_disable(ar);
1722         if (ret)
1723             /* not serious */
1724             ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1725     }
1726 
1727     if (ar->debug.nf_cal_period &&
1728         !test_bit(ATH10K_FW_FEATURE_NON_BMI,
1729               ar->normal_mode_fw.fw_file.fw_features)) {
1730         ret = ath10k_wmi_pdev_set_param(ar,
1731                         ar->wmi.pdev_param->cal_period,
1732                         ar->debug.nf_cal_period);
1733         if (ret)
1734             /* not serious */
1735             ath10k_warn(ar, "cal period cfg failed from debug start: %d\n",
1736                     ret);
1737     }
1738 
1739     return ret;
1740 }
1741 
1742 void ath10k_debug_stop(struct ath10k *ar)
1743 {
1744     lockdep_assert_held(&ar->conf_mutex);
1745 
1746     if (!test_bit(ATH10K_FW_FEATURE_NON_BMI,
1747               ar->normal_mode_fw.fw_file.fw_features))
1748         ath10k_debug_cal_data_fetch(ar);
1749 
1750     /* Must not use _sync to avoid deadlock, we do that in
1751      * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1752      * warning from del_timer().
1753      */
1754     if (ar->debug.htt_stats_mask != 0)
1755         cancel_delayed_work(&ar->debug.htt_stats_dwork);
1756 
1757     ath10k_wmi_pdev_pktlog_disable(ar);
1758 }
1759 
1760 static ssize_t ath10k_write_simulate_radar(struct file *file,
1761                        const char __user *user_buf,
1762                        size_t count, loff_t *ppos)
1763 {
1764     struct ath10k *ar = file->private_data;
1765     struct ath10k_vif *arvif;
1766 
1767     /* Just check for the first vif alone, as all the vifs will be
1768      * sharing the same channel and if the channel is disabled, all the
1769      * vifs will share the same 'is_started' state.
1770      */
1771     arvif = list_first_entry(&ar->arvifs, typeof(*arvif), list);
1772     if (!arvif->is_started)
1773         return -EINVAL;
1774 
1775     ieee80211_radar_detected(ar->hw);
1776 
1777     return count;
1778 }
1779 
1780 static const struct file_operations fops_simulate_radar = {
1781     .write = ath10k_write_simulate_radar,
1782     .open = simple_open,
1783     .owner = THIS_MODULE,
1784     .llseek = default_llseek,
1785 };
1786 
1787 #define ATH10K_DFS_STAT(s, p) (\
1788     len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1789              ar->debug.dfs_stats.p))
1790 
1791 #define ATH10K_DFS_POOL_STAT(s, p) (\
1792     len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1793              ar->debug.dfs_pool_stats.p))
1794 
1795 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1796                      size_t count, loff_t *ppos)
1797 {
1798     int retval = 0, len = 0;
1799     const int size = 8000;
1800     struct ath10k *ar = file->private_data;
1801     char *buf;
1802 
1803     buf = kzalloc(size, GFP_KERNEL);
1804     if (buf == NULL)
1805         return -ENOMEM;
1806 
1807     if (!ar->dfs_detector) {
1808         len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1809         goto exit;
1810     }
1811 
1812     ar->debug.dfs_pool_stats =
1813             ar->dfs_detector->get_stats(ar->dfs_detector);
1814 
1815     len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1816 
1817     ATH10K_DFS_STAT("reported phy errors", phy_errors);
1818     ATH10K_DFS_STAT("pulse events reported", pulses_total);
1819     ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1820     ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1821     ATH10K_DFS_STAT("Radars detected", radar_detected);
1822 
1823     len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1824     ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1825     ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1826     ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1827     ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1828     ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1829     ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1830     ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1831 
1832 exit:
1833     if (len > size)
1834         len = size;
1835 
1836     retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1837     kfree(buf);
1838 
1839     return retval;
1840 }
1841 
1842 static const struct file_operations fops_dfs_stats = {
1843     .read = ath10k_read_dfs_stats,
1844     .open = simple_open,
1845     .owner = THIS_MODULE,
1846     .llseek = default_llseek,
1847 };
1848 
1849 static ssize_t ath10k_write_pktlog_filter(struct file *file,
1850                       const char __user *ubuf,
1851                       size_t count, loff_t *ppos)
1852 {
1853     struct ath10k *ar = file->private_data;
1854     u32 filter;
1855     int ret;
1856 
1857     if (kstrtouint_from_user(ubuf, count, 0, &filter))
1858         return -EINVAL;
1859 
1860     mutex_lock(&ar->conf_mutex);
1861 
1862     if (ar->state != ATH10K_STATE_ON) {
1863         ar->pktlog_filter = filter;
1864         ret = count;
1865         goto out;
1866     }
1867 
1868     if (filter == ar->pktlog_filter) {
1869         ret = count;
1870         goto out;
1871     }
1872 
1873     if (filter) {
1874         ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
1875         if (ret) {
1876             ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
1877                     ar->pktlog_filter, ret);
1878             goto out;
1879         }
1880     } else {
1881         ret = ath10k_wmi_pdev_pktlog_disable(ar);
1882         if (ret) {
1883             ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1884             goto out;
1885         }
1886     }
1887 
1888     ar->pktlog_filter = filter;
1889     ret = count;
1890 
1891 out:
1892     mutex_unlock(&ar->conf_mutex);
1893     return ret;
1894 }
1895 
1896 static ssize_t ath10k_read_pktlog_filter(struct file *file, char __user *ubuf,
1897                      size_t count, loff_t *ppos)
1898 {
1899     char buf[32];
1900     struct ath10k *ar = file->private_data;
1901     int len = 0;
1902 
1903     mutex_lock(&ar->conf_mutex);
1904     len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
1905             ar->pktlog_filter);
1906     mutex_unlock(&ar->conf_mutex);
1907 
1908     return simple_read_from_buffer(ubuf, count, ppos, buf, len);
1909 }
1910 
1911 static const struct file_operations fops_pktlog_filter = {
1912     .read = ath10k_read_pktlog_filter,
1913     .write = ath10k_write_pktlog_filter,
1914     .open = simple_open
1915 };
1916 
1917 static ssize_t ath10k_write_quiet_period(struct file *file,
1918                      const char __user *ubuf,
1919                      size_t count, loff_t *ppos)
1920 {
1921     struct ath10k *ar = file->private_data;
1922     u32 period;
1923 
1924     if (kstrtouint_from_user(ubuf, count, 0, &period))
1925         return -EINVAL;
1926 
1927     if (period < ATH10K_QUIET_PERIOD_MIN) {
1928         ath10k_warn(ar, "Quiet period %u can not be lesser than 25ms\n",
1929                 period);
1930         return -EINVAL;
1931     }
1932     mutex_lock(&ar->conf_mutex);
1933     ar->thermal.quiet_period = period;
1934     ath10k_thermal_set_throttling(ar);
1935     mutex_unlock(&ar->conf_mutex);
1936 
1937     return count;
1938 }
1939 
1940 static ssize_t ath10k_read_quiet_period(struct file *file, char __user *ubuf,
1941                     size_t count, loff_t *ppos)
1942 {
1943     char buf[32];
1944     struct ath10k *ar = file->private_data;
1945     int len = 0;
1946 
1947     mutex_lock(&ar->conf_mutex);
1948     len = scnprintf(buf, sizeof(buf) - len, "%d\n",
1949             ar->thermal.quiet_period);
1950     mutex_unlock(&ar->conf_mutex);
1951 
1952     return simple_read_from_buffer(ubuf, count, ppos, buf, len);
1953 }
1954 
1955 static const struct file_operations fops_quiet_period = {
1956     .read = ath10k_read_quiet_period,
1957     .write = ath10k_write_quiet_period,
1958     .open = simple_open
1959 };
1960 
1961 static ssize_t ath10k_write_btcoex(struct file *file,
1962                    const char __user *ubuf,
1963                    size_t count, loff_t *ppos)
1964 {
1965     struct ath10k *ar = file->private_data;
1966     char buf[32];
1967     size_t buf_size;
1968     int ret;
1969     bool val;
1970     u32 pdev_param;
1971 
1972     buf_size = min(count, (sizeof(buf) - 1));
1973     if (copy_from_user(buf, ubuf, buf_size))
1974         return -EFAULT;
1975 
1976     buf[buf_size] = '\0';
1977 
1978     if (strtobool(buf, &val) != 0)
1979         return -EINVAL;
1980 
1981     if (!ar->coex_support)
1982         return -EOPNOTSUPP;
1983 
1984     mutex_lock(&ar->conf_mutex);
1985 
1986     if (ar->state != ATH10K_STATE_ON &&
1987         ar->state != ATH10K_STATE_RESTARTED) {
1988         ret = -ENETDOWN;
1989         goto exit;
1990     }
1991 
1992     if (!(test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags) ^ val)) {
1993         ret = count;
1994         goto exit;
1995     }
1996 
1997     pdev_param = ar->wmi.pdev_param->enable_btcoex;
1998     if (test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
1999              ar->running_fw->fw_file.fw_features)) {
2000         ret = ath10k_wmi_pdev_set_param(ar, pdev_param, val);
2001         if (ret) {
2002             ath10k_warn(ar, "failed to enable btcoex: %d\n", ret);
2003             ret = count;
2004             goto exit;
2005         }
2006     } else {
2007         ath10k_info(ar, "restarting firmware due to btcoex change");
2008         ath10k_core_start_recovery(ar);
2009     }
2010 
2011     if (val)
2012         set_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2013     else
2014         clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2015 
2016     ret = count;
2017 
2018 exit:
2019     mutex_unlock(&ar->conf_mutex);
2020 
2021     return ret;
2022 }
2023 
2024 static ssize_t ath10k_read_btcoex(struct file *file, char __user *ubuf,
2025                   size_t count, loff_t *ppos)
2026 {
2027     char buf[32];
2028     struct ath10k *ar = file->private_data;
2029     int len = 0;
2030 
2031     mutex_lock(&ar->conf_mutex);
2032     len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2033             test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags));
2034     mutex_unlock(&ar->conf_mutex);
2035 
2036     return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2037 }
2038 
2039 static const struct file_operations fops_btcoex = {
2040     .read = ath10k_read_btcoex,
2041     .write = ath10k_write_btcoex,
2042     .open = simple_open
2043 };
2044 
2045 static ssize_t ath10k_write_enable_extd_tx_stats(struct file *file,
2046                          const char __user *ubuf,
2047                          size_t count, loff_t *ppos)
2048 {
2049     struct ath10k *ar = file->private_data;
2050     u32 filter;
2051     int ret;
2052 
2053     if (kstrtouint_from_user(ubuf, count, 0, &filter))
2054         return -EINVAL;
2055 
2056     mutex_lock(&ar->conf_mutex);
2057 
2058     if (ar->state != ATH10K_STATE_ON) {
2059         ar->debug.enable_extd_tx_stats = filter;
2060         ret = count;
2061         goto out;
2062     }
2063 
2064     if (filter == ar->debug.enable_extd_tx_stats) {
2065         ret = count;
2066         goto out;
2067     }
2068 
2069     ar->debug.enable_extd_tx_stats = filter;
2070     ret = count;
2071 
2072 out:
2073     mutex_unlock(&ar->conf_mutex);
2074     return ret;
2075 }
2076 
2077 static ssize_t ath10k_read_enable_extd_tx_stats(struct file *file,
2078                         char __user *ubuf,
2079                         size_t count, loff_t *ppos)
2080 
2081 {
2082     char buf[32];
2083     struct ath10k *ar = file->private_data;
2084     int len = 0;
2085 
2086     mutex_lock(&ar->conf_mutex);
2087     len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
2088             ar->debug.enable_extd_tx_stats);
2089     mutex_unlock(&ar->conf_mutex);
2090 
2091     return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2092 }
2093 
2094 static const struct file_operations fops_enable_extd_tx_stats = {
2095     .read = ath10k_read_enable_extd_tx_stats,
2096     .write = ath10k_write_enable_extd_tx_stats,
2097     .open = simple_open
2098 };
2099 
2100 static ssize_t ath10k_write_peer_stats(struct file *file,
2101                        const char __user *ubuf,
2102                        size_t count, loff_t *ppos)
2103 {
2104     struct ath10k *ar = file->private_data;
2105     char buf[32];
2106     size_t buf_size;
2107     int ret;
2108     bool val;
2109 
2110     buf_size = min(count, (sizeof(buf) - 1));
2111     if (copy_from_user(buf, ubuf, buf_size))
2112         return -EFAULT;
2113 
2114     buf[buf_size] = '\0';
2115 
2116     if (strtobool(buf, &val) != 0)
2117         return -EINVAL;
2118 
2119     mutex_lock(&ar->conf_mutex);
2120 
2121     if (ar->state != ATH10K_STATE_ON &&
2122         ar->state != ATH10K_STATE_RESTARTED) {
2123         ret = -ENETDOWN;
2124         goto exit;
2125     }
2126 
2127     if (!(test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) ^ val)) {
2128         ret = count;
2129         goto exit;
2130     }
2131 
2132     if (val)
2133         set_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2134     else
2135         clear_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2136 
2137     ath10k_info(ar, "restarting firmware due to Peer stats change");
2138 
2139     ath10k_core_start_recovery(ar);
2140     ret = count;
2141 
2142 exit:
2143     mutex_unlock(&ar->conf_mutex);
2144     return ret;
2145 }
2146 
2147 static ssize_t ath10k_read_peer_stats(struct file *file, char __user *ubuf,
2148                       size_t count, loff_t *ppos)
2149 
2150 {
2151     char buf[32];
2152     struct ath10k *ar = file->private_data;
2153     int len = 0;
2154 
2155     mutex_lock(&ar->conf_mutex);
2156     len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2157             test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags));
2158     mutex_unlock(&ar->conf_mutex);
2159 
2160     return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2161 }
2162 
2163 static const struct file_operations fops_peer_stats = {
2164     .read = ath10k_read_peer_stats,
2165     .write = ath10k_write_peer_stats,
2166     .open = simple_open
2167 };
2168 
2169 static ssize_t ath10k_debug_fw_checksums_read(struct file *file,
2170                           char __user *user_buf,
2171                           size_t count, loff_t *ppos)
2172 {
2173     struct ath10k *ar = file->private_data;
2174     size_t len = 0, buf_len = 4096;
2175     ssize_t ret_cnt;
2176     char *buf;
2177 
2178     buf = kzalloc(buf_len, GFP_KERNEL);
2179     if (!buf)
2180         return -ENOMEM;
2181 
2182     mutex_lock(&ar->conf_mutex);
2183 
2184     len += scnprintf(buf + len, buf_len - len,
2185              "firmware-N.bin\t\t%08x\n",
2186              crc32_le(0, ar->normal_mode_fw.fw_file.firmware->data,
2187                   ar->normal_mode_fw.fw_file.firmware->size));
2188     len += scnprintf(buf + len, buf_len - len,
2189              "athwlan\t\t\t%08x\n",
2190              crc32_le(0, ar->normal_mode_fw.fw_file.firmware_data,
2191                   ar->normal_mode_fw.fw_file.firmware_len));
2192     len += scnprintf(buf + len, buf_len - len,
2193              "otp\t\t\t%08x\n",
2194              crc32_le(0, ar->normal_mode_fw.fw_file.otp_data,
2195                   ar->normal_mode_fw.fw_file.otp_len));
2196     len += scnprintf(buf + len, buf_len - len,
2197              "codeswap\t\t%08x\n",
2198              crc32_le(0, ar->normal_mode_fw.fw_file.codeswap_data,
2199                   ar->normal_mode_fw.fw_file.codeswap_len));
2200     len += scnprintf(buf + len, buf_len - len,
2201              "board-N.bin\t\t%08x\n",
2202              crc32_le(0, ar->normal_mode_fw.board->data,
2203                   ar->normal_mode_fw.board->size));
2204     len += scnprintf(buf + len, buf_len - len,
2205              "board\t\t\t%08x\n",
2206              crc32_le(0, ar->normal_mode_fw.board_data,
2207                   ar->normal_mode_fw.board_len));
2208 
2209     ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
2210 
2211     mutex_unlock(&ar->conf_mutex);
2212 
2213     kfree(buf);
2214     return ret_cnt;
2215 }
2216 
2217 static const struct file_operations fops_fw_checksums = {
2218     .read = ath10k_debug_fw_checksums_read,
2219     .open = simple_open,
2220     .owner = THIS_MODULE,
2221     .llseek = default_llseek,
2222 };
2223 
2224 static ssize_t ath10k_sta_tid_stats_mask_read(struct file *file,
2225                           char __user *user_buf,
2226                           size_t count, loff_t *ppos)
2227 {
2228     struct ath10k *ar = file->private_data;
2229     char buf[32];
2230     size_t len;
2231 
2232     len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->sta_tid_stats_mask);
2233     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
2234 }
2235 
2236 static ssize_t ath10k_sta_tid_stats_mask_write(struct file *file,
2237                            const char __user *user_buf,
2238                            size_t count, loff_t *ppos)
2239 {
2240     struct ath10k *ar = file->private_data;
2241     char buf[32];
2242     ssize_t len;
2243     u32 mask;
2244 
2245     len = min(count, sizeof(buf) - 1);
2246     if (copy_from_user(buf, user_buf, len))
2247         return -EFAULT;
2248 
2249     buf[len] = '\0';
2250     if (kstrtoint(buf, 0, &mask))
2251         return -EINVAL;
2252 
2253     ar->sta_tid_stats_mask = mask;
2254 
2255     return len;
2256 }
2257 
2258 static const struct file_operations fops_sta_tid_stats_mask = {
2259     .read = ath10k_sta_tid_stats_mask_read,
2260     .write = ath10k_sta_tid_stats_mask_write,
2261     .open = simple_open,
2262     .owner = THIS_MODULE,
2263     .llseek = default_llseek,
2264 };
2265 
2266 static int ath10k_debug_tpc_stats_final_request(struct ath10k *ar)
2267 {
2268     int ret;
2269     unsigned long time_left;
2270 
2271     lockdep_assert_held(&ar->conf_mutex);
2272 
2273     reinit_completion(&ar->debug.tpc_complete);
2274 
2275     ret = ath10k_wmi_pdev_get_tpc_table_cmdid(ar, WMI_TPC_CONFIG_PARAM);
2276     if (ret) {
2277         ath10k_warn(ar, "failed to request tpc table cmdid: %d\n", ret);
2278         return ret;
2279     }
2280 
2281     time_left = wait_for_completion_timeout(&ar->debug.tpc_complete,
2282                         1 * HZ);
2283     if (time_left == 0)
2284         return -ETIMEDOUT;
2285 
2286     return 0;
2287 }
2288 
2289 static int ath10k_tpc_stats_final_open(struct inode *inode, struct file *file)
2290 {
2291     struct ath10k *ar = inode->i_private;
2292     void *buf;
2293     int ret;
2294 
2295     mutex_lock(&ar->conf_mutex);
2296 
2297     if (ar->state != ATH10K_STATE_ON) {
2298         ret = -ENETDOWN;
2299         goto err_unlock;
2300     }
2301 
2302     buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
2303     if (!buf) {
2304         ret = -ENOMEM;
2305         goto err_unlock;
2306     }
2307 
2308     ret = ath10k_debug_tpc_stats_final_request(ar);
2309     if (ret) {
2310         ath10k_warn(ar, "failed to request tpc stats final: %d\n",
2311                 ret);
2312         goto err_free;
2313     }
2314 
2315     ath10k_tpc_stats_fill(ar, ar->debug.tpc_stats, buf);
2316     file->private_data = buf;
2317 
2318     mutex_unlock(&ar->conf_mutex);
2319     return 0;
2320 
2321 err_free:
2322     vfree(buf);
2323 
2324 err_unlock:
2325     mutex_unlock(&ar->conf_mutex);
2326     return ret;
2327 }
2328 
2329 static int ath10k_tpc_stats_final_release(struct inode *inode,
2330                       struct file *file)
2331 {
2332     vfree(file->private_data);
2333 
2334     return 0;
2335 }
2336 
2337 static ssize_t ath10k_tpc_stats_final_read(struct file *file,
2338                        char __user *user_buf,
2339                        size_t count, loff_t *ppos)
2340 {
2341     const char *buf = file->private_data;
2342     unsigned int len = strlen(buf);
2343 
2344     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
2345 }
2346 
2347 static const struct file_operations fops_tpc_stats_final = {
2348     .open = ath10k_tpc_stats_final_open,
2349     .release = ath10k_tpc_stats_final_release,
2350     .read = ath10k_tpc_stats_final_read,
2351     .owner = THIS_MODULE,
2352     .llseek = default_llseek,
2353 };
2354 
2355 static ssize_t ath10k_write_warm_hw_reset(struct file *file,
2356                       const char __user *user_buf,
2357                       size_t count, loff_t *ppos)
2358 {
2359     struct ath10k *ar = file->private_data;
2360     int ret;
2361     bool val;
2362 
2363     if (kstrtobool_from_user(user_buf, count, &val))
2364         return -EFAULT;
2365 
2366     if (!val)
2367         return -EINVAL;
2368 
2369     mutex_lock(&ar->conf_mutex);
2370 
2371     if (ar->state != ATH10K_STATE_ON) {
2372         ret = -ENETDOWN;
2373         goto exit;
2374     }
2375 
2376     ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pdev_reset,
2377                     WMI_RST_MODE_WARM_RESET);
2378 
2379     if (ret) {
2380         ath10k_warn(ar, "failed to enable warm hw reset: %d\n", ret);
2381         goto exit;
2382     }
2383 
2384     ret = count;
2385 
2386 exit:
2387     mutex_unlock(&ar->conf_mutex);
2388     return ret;
2389 }
2390 
2391 static const struct file_operations fops_warm_hw_reset = {
2392     .write = ath10k_write_warm_hw_reset,
2393     .open = simple_open,
2394     .owner = THIS_MODULE,
2395     .llseek = default_llseek,
2396 };
2397 
2398 static void ath10k_peer_ps_state_disable(void *data,
2399                      struct ieee80211_sta *sta)
2400 {
2401     struct ath10k *ar = data;
2402     struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
2403 
2404     spin_lock_bh(&ar->data_lock);
2405     arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
2406     spin_unlock_bh(&ar->data_lock);
2407 }
2408 
2409 static ssize_t ath10k_write_ps_state_enable(struct file *file,
2410                         const char __user *user_buf,
2411                         size_t count, loff_t *ppos)
2412 {
2413     struct ath10k *ar = file->private_data;
2414     int ret;
2415     u32 param;
2416     u8 ps_state_enable;
2417 
2418     if (kstrtou8_from_user(user_buf, count, 0, &ps_state_enable))
2419         return -EINVAL;
2420 
2421     if (ps_state_enable > 1)
2422         return -EINVAL;
2423 
2424     mutex_lock(&ar->conf_mutex);
2425 
2426     if (ar->ps_state_enable == ps_state_enable) {
2427         ret = count;
2428         goto exit;
2429     }
2430 
2431     param = ar->wmi.pdev_param->peer_sta_ps_statechg_enable;
2432     ret = ath10k_wmi_pdev_set_param(ar, param, ps_state_enable);
2433     if (ret) {
2434         ath10k_warn(ar, "failed to enable ps_state_enable: %d\n",
2435                 ret);
2436         goto exit;
2437     }
2438     ar->ps_state_enable = ps_state_enable;
2439 
2440     if (!ar->ps_state_enable)
2441         ieee80211_iterate_stations_atomic(ar->hw,
2442                           ath10k_peer_ps_state_disable,
2443                           ar);
2444 
2445     ret = count;
2446 
2447 exit:
2448     mutex_unlock(&ar->conf_mutex);
2449 
2450     return ret;
2451 }
2452 
2453 static ssize_t ath10k_read_ps_state_enable(struct file *file,
2454                        char __user *user_buf,
2455                        size_t count, loff_t *ppos)
2456 {
2457     struct ath10k *ar = file->private_data;
2458     int len = 0;
2459     char buf[32];
2460 
2461     mutex_lock(&ar->conf_mutex);
2462     len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2463             ar->ps_state_enable);
2464     mutex_unlock(&ar->conf_mutex);
2465 
2466     return simple_read_from_buffer(user_buf, count, ppos, buf, len);
2467 }
2468 
2469 static const struct file_operations fops_ps_state_enable = {
2470     .read = ath10k_read_ps_state_enable,
2471     .write = ath10k_write_ps_state_enable,
2472     .open = simple_open,
2473     .owner = THIS_MODULE,
2474     .llseek = default_llseek,
2475 };
2476 
2477 static ssize_t ath10k_write_reset_htt_stats(struct file *file,
2478                         const char __user *user_buf,
2479                         size_t count, loff_t *ppos)
2480 {
2481     struct ath10k *ar = file->private_data;
2482     unsigned long reset;
2483     int ret;
2484 
2485     ret = kstrtoul_from_user(user_buf, count, 0, &reset);
2486     if (ret)
2487         return ret;
2488 
2489     if (reset == 0 || reset > 0x1ffff)
2490         return -EINVAL;
2491 
2492     mutex_lock(&ar->conf_mutex);
2493 
2494     ar->debug.reset_htt_stats = reset;
2495 
2496     ret = ath10k_debug_htt_stats_req(ar);
2497     if (ret)
2498         goto out;
2499 
2500     ar->debug.reset_htt_stats = 0;
2501     ret = count;
2502 
2503 out:
2504     mutex_unlock(&ar->conf_mutex);
2505     return ret;
2506 }
2507 
2508 static const struct file_operations fops_reset_htt_stats = {
2509     .write = ath10k_write_reset_htt_stats,
2510     .owner = THIS_MODULE,
2511     .open = simple_open,
2512     .llseek = default_llseek,
2513 };
2514 
2515 int ath10k_debug_create(struct ath10k *ar)
2516 {
2517     ar->debug.cal_data = vzalloc(ATH10K_DEBUG_CAL_DATA_LEN);
2518     if (!ar->debug.cal_data)
2519         return -ENOMEM;
2520 
2521     INIT_LIST_HEAD(&ar->debug.fw_stats.pdevs);
2522     INIT_LIST_HEAD(&ar->debug.fw_stats.vdevs);
2523     INIT_LIST_HEAD(&ar->debug.fw_stats.peers);
2524     INIT_LIST_HEAD(&ar->debug.fw_stats.peers_extd);
2525 
2526     return 0;
2527 }
2528 
2529 void ath10k_debug_destroy(struct ath10k *ar)
2530 {
2531     vfree(ar->debug.cal_data);
2532     ar->debug.cal_data = NULL;
2533 
2534     ath10k_debug_fw_stats_reset(ar);
2535 
2536     kfree(ar->debug.tpc_stats);
2537     kfree(ar->debug.tpc_stats_final);
2538 }
2539 
2540 int ath10k_debug_register(struct ath10k *ar)
2541 {
2542     ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
2543                            ar->hw->wiphy->debugfsdir);
2544     if (IS_ERR_OR_NULL(ar->debug.debugfs_phy)) {
2545         if (IS_ERR(ar->debug.debugfs_phy))
2546             return PTR_ERR(ar->debug.debugfs_phy);
2547 
2548         return -ENOMEM;
2549     }
2550 
2551     INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
2552               ath10k_debug_htt_stats_dwork);
2553 
2554     init_completion(&ar->debug.tpc_complete);
2555     init_completion(&ar->debug.fw_stats_complete);
2556 
2557     debugfs_create_file("fw_stats", 0400, ar->debug.debugfs_phy, ar,
2558                 &fops_fw_stats);
2559 
2560     debugfs_create_file("fw_reset_stats", 0400, ar->debug.debugfs_phy, ar,
2561                 &fops_fw_reset_stats);
2562 
2563     debugfs_create_file("wmi_services", 0400, ar->debug.debugfs_phy, ar,
2564                 &fops_wmi_services);
2565 
2566     debugfs_create_file("simulate_fw_crash", 0600, ar->debug.debugfs_phy, ar,
2567                 &fops_simulate_fw_crash);
2568 
2569     debugfs_create_file("reg_addr", 0600, ar->debug.debugfs_phy, ar,
2570                 &fops_reg_addr);
2571 
2572     debugfs_create_file("reg_value", 0600, ar->debug.debugfs_phy, ar,
2573                 &fops_reg_value);
2574 
2575     debugfs_create_file("mem_value", 0600, ar->debug.debugfs_phy, ar,
2576                 &fops_mem_value);
2577 
2578     debugfs_create_file("chip_id", 0400, ar->debug.debugfs_phy, ar,
2579                 &fops_chip_id);
2580 
2581     debugfs_create_file("htt_stats_mask", 0600, ar->debug.debugfs_phy, ar,
2582                 &fops_htt_stats_mask);
2583 
2584     debugfs_create_file("htt_max_amsdu_ampdu", 0600, ar->debug.debugfs_phy, ar,
2585                 &fops_htt_max_amsdu_ampdu);
2586 
2587     debugfs_create_file("fw_dbglog", 0600, ar->debug.debugfs_phy, ar,
2588                 &fops_fw_dbglog);
2589 
2590     if (!test_bit(ATH10K_FW_FEATURE_NON_BMI,
2591               ar->normal_mode_fw.fw_file.fw_features)) {
2592         debugfs_create_file("cal_data", 0400, ar->debug.debugfs_phy, ar,
2593                     &fops_cal_data);
2594 
2595         debugfs_create_file("nf_cal_period", 0600, ar->debug.debugfs_phy, ar,
2596                     &fops_nf_cal_period);
2597     }
2598 
2599     debugfs_create_file("ani_enable", 0600, ar->debug.debugfs_phy, ar,
2600                 &fops_ani_enable);
2601 
2602     if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
2603         debugfs_create_file("dfs_simulate_radar", 0200, ar->debug.debugfs_phy,
2604                     ar, &fops_simulate_radar);
2605 
2606         debugfs_create_bool("dfs_block_radar_events", 0200,
2607                     ar->debug.debugfs_phy,
2608                     &ar->dfs_block_radar_events);
2609 
2610         debugfs_create_file("dfs_stats", 0400, ar->debug.debugfs_phy, ar,
2611                     &fops_dfs_stats);
2612     }
2613 
2614     debugfs_create_file("pktlog_filter", 0644, ar->debug.debugfs_phy, ar,
2615                 &fops_pktlog_filter);
2616 
2617     if (test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
2618         debugfs_create_file("quiet_period", 0644, ar->debug.debugfs_phy, ar,
2619                     &fops_quiet_period);
2620 
2621     debugfs_create_file("tpc_stats", 0400, ar->debug.debugfs_phy, ar,
2622                 &fops_tpc_stats);
2623 
2624     if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
2625         debugfs_create_file("btcoex", 0644, ar->debug.debugfs_phy, ar,
2626                     &fops_btcoex);
2627 
2628     if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
2629         debugfs_create_file("peer_stats", 0644, ar->debug.debugfs_phy, ar,
2630                     &fops_peer_stats);
2631 
2632         debugfs_create_file("enable_extd_tx_stats", 0644,
2633                     ar->debug.debugfs_phy, ar,
2634                     &fops_enable_extd_tx_stats);
2635     }
2636 
2637     debugfs_create_file("fw_checksums", 0400, ar->debug.debugfs_phy, ar,
2638                 &fops_fw_checksums);
2639 
2640     if (IS_ENABLED(CONFIG_MAC80211_DEBUGFS))
2641         debugfs_create_file("sta_tid_stats_mask", 0600,
2642                     ar->debug.debugfs_phy,
2643                     ar, &fops_sta_tid_stats_mask);
2644 
2645     if (test_bit(WMI_SERVICE_TPC_STATS_FINAL, ar->wmi.svc_map))
2646         debugfs_create_file("tpc_stats_final", 0400,
2647                     ar->debug.debugfs_phy, ar,
2648                     &fops_tpc_stats_final);
2649 
2650     if (test_bit(WMI_SERVICE_RESET_CHIP, ar->wmi.svc_map))
2651         debugfs_create_file("warm_hw_reset", 0600,
2652                     ar->debug.debugfs_phy, ar,
2653                     &fops_warm_hw_reset);
2654 
2655     debugfs_create_file("ps_state_enable", 0600, ar->debug.debugfs_phy, ar,
2656                 &fops_ps_state_enable);
2657 
2658     debugfs_create_file("reset_htt_stats", 0200, ar->debug.debugfs_phy, ar,
2659                 &fops_reset_htt_stats);
2660 
2661     return 0;
2662 }
2663 
2664 void ath10k_debug_unregister(struct ath10k *ar)
2665 {
2666     cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
2667 }
2668 
2669 #endif /* CONFIG_ATH10K_DEBUGFS */
2670 
2671 #ifdef CONFIG_ATH10K_DEBUG
2672 void __ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
2673           const char *fmt, ...)
2674 {
2675     struct va_format vaf;
2676     va_list args;
2677 
2678     va_start(args, fmt);
2679 
2680     vaf.fmt = fmt;
2681     vaf.va = &args;
2682 
2683     if (ath10k_debug_mask & mask)
2684         dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
2685 
2686     trace_ath10k_log_dbg(ar, mask, &vaf);
2687 
2688     va_end(args);
2689 }
2690 EXPORT_SYMBOL(__ath10k_dbg);
2691 
2692 void ath10k_dbg_dump(struct ath10k *ar,
2693              enum ath10k_debug_mask mask,
2694              const char *msg, const char *prefix,
2695              const void *buf, size_t len)
2696 {
2697     char linebuf[256];
2698     size_t linebuflen;
2699     const void *ptr;
2700 
2701     if (ath10k_debug_mask & mask) {
2702         if (msg)
2703             __ath10k_dbg(ar, mask, "%s\n", msg);
2704 
2705         for (ptr = buf; (ptr - buf) < len; ptr += 16) {
2706             linebuflen = 0;
2707             linebuflen += scnprintf(linebuf + linebuflen,
2708                         sizeof(linebuf) - linebuflen,
2709                         "%s%08x: ",
2710                         (prefix ? prefix : ""),
2711                         (unsigned int)(ptr - buf));
2712             hex_dump_to_buffer(ptr, len - (ptr - buf), 16, 1,
2713                        linebuf + linebuflen,
2714                        sizeof(linebuf) - linebuflen, true);
2715             dev_printk(KERN_DEBUG, ar->dev, "%s\n", linebuf);
2716         }
2717     }
2718 
2719     /* tracing code doesn't like null strings :/ */
2720     trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
2721                   buf, len);
2722 }
2723 EXPORT_SYMBOL(ath10k_dbg_dump);
2724 
2725 #endif /* CONFIG_ATH10K_DEBUG */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!