drivers/net/wireless/ath/ath10k/debug.c

   1 // SPDX-License-Identifier: ISC
   2 /*
   3  * Copyright (c) 2005-2011 Atheros Communications Inc.
   4  * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
   5  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/debugfs.h>
  10 #include <linux/vmalloc.h>
  11 #include <linux/crc32.h>
  12 #include <linux/firmware.h>
  13 #include <linux/kstrtox.h>
  14
  15 #include "core.h"
  16 #include "debug.h"
  17 #include "hif.h"
  18 #include "wmi-ops.h"
  19
  20 /* ms */
  21 #define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
  22
  23 #define ATH10K_DEBUG_CAL_DATA_LEN 12064
  24
  25 void ath10k_info(struct ath10k *ar, const char *fmt, ...)
  26 {
  27         struct va_format vaf = {
  28                 .fmt = fmt,
  29         };
  30         va_list args;
  31
  32         va_start(args, fmt);
  33         vaf.va = &args;
  34         dev_info(ar->dev, "%pV", &vaf);
  35         trace_ath10k_log_info(ar, &vaf);
  36         va_end(args);
  37 }
  38 EXPORT_SYMBOL(ath10k_info);
  39
  40 void ath10k_debug_print_hwfw_info(struct ath10k *ar)
  41 {
  42         const struct firmware *firmware;
  43         char fw_features[128] = {};
  44         u32 crc = 0;
  45
  46         ath10k_core_get_fw_features_str(ar, fw_features, sizeof(fw_features));
  47
  48         ath10k_info(ar, "%s target 0x%08x chip_id 0x%08x sub %04x:%04x",
  49                     ar->hw_params.name,
  50                     ar->target_version,
  51                     ar->bus_param.chip_id,
  52                     ar->id.subsystem_vendor, ar->id.subsystem_device);
  53
  54         ath10k_info(ar, "kconfig debug %d debugfs %d tracing %d dfs %d testmode %d\n",
  55                     IS_ENABLED(CONFIG_ATH10K_DEBUG),
  56                     IS_ENABLED(CONFIG_ATH10K_DEBUGFS),
  57                     IS_ENABLED(CONFIG_ATH10K_TRACING),
  58                     IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED),
  59                     IS_ENABLED(CONFIG_NL80211_TESTMODE));
  60
  61         firmware = ar->normal_mode_fw.fw_file.firmware;
  62         if (firmware)
  63                 crc = crc32_le(0, firmware->data, firmware->size);
  64
  65         ath10k_info(ar, "firmware ver %s api %d features %s crc32 %08x\n",
  66                     ar->hw->wiphy->fw_version,
  67                     ar->fw_api,
  68                     fw_features,
  69                     crc);
  70 }
  71
  72 void ath10k_debug_print_board_info(struct ath10k *ar)
  73 {
  74         char boardinfo[100];
  75         const struct firmware *board;
  76         u32 crc;
  77
  78         if (ar->id.bmi_ids_valid)
  79                 scnprintf(boardinfo, sizeof(boardinfo), "%d:%d",
  80                           ar->id.bmi_chip_id, ar->id.bmi_board_id);
  81         else
  82                 scnprintf(boardinfo, sizeof(boardinfo), "N/A");
  83
  84         board = ar->normal_mode_fw.board;
  85         if (!IS_ERR_OR_NULL(board))
  86                 crc = crc32_le(0, board->data, board->size);
  87         else
  88                 crc = 0;
  89
  90         ath10k_info(ar, "board_file api %d bmi_id %s crc32 %08x",
  91                     ar->bd_api,
  92                     boardinfo,
  93                     crc);
  94 }
  95
  96 void ath10k_debug_print_boot_info(struct ath10k *ar)
  97 {
  98         ath10k_info(ar, "htt-ver %d.%d wmi-op %d htt-op %d cal %s max-sta %d raw %d hwcrypto %d\n",
  99                     ar->htt.target_version_major,
 100                     ar->htt.target_version_minor,
 101                     ar->normal_mode_fw.fw_file.wmi_op_version,
 102                     ar->normal_mode_fw.fw_file.htt_op_version,
 103                     ath10k_cal_mode_str(ar->cal_mode),
 104                     ar->max_num_stations,
 105                     test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags),
 106                     !test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags));
 107 }
 108
 109 void ath10k_print_driver_info(struct ath10k *ar)
 110 {
 111         ath10k_debug_print_hwfw_info(ar);
 112         ath10k_debug_print_board_info(ar);
 113         ath10k_debug_print_boot_info(ar);
 114 }
 115 EXPORT_SYMBOL(ath10k_print_driver_info);
 116
 117 void ath10k_err(struct ath10k *ar, const char *fmt, ...)
 118 {
 119         struct va_format vaf = {
 120                 .fmt = fmt,
 121         };
 122         va_list args;
 123
 124         va_start(args, fmt);
 125         vaf.va = &args;
 126         dev_err(ar->dev, "%pV", &vaf);
 127         trace_ath10k_log_err(ar, &vaf);
 128         va_end(args);
 129 }
 130 EXPORT_SYMBOL(ath10k_err);
 131
 132 void ath10k_warn(struct ath10k *ar, const char *fmt, ...)
 133 {
 134         struct va_format vaf = {
 135                 .fmt = fmt,
 136         };
 137         va_list args;
 138
 139         va_start(args, fmt);
 140         vaf.va = &args;
 141         dev_warn_ratelimited(ar->dev, "%pV", &vaf);
 142         trace_ath10k_log_warn(ar, &vaf);
 143
 144         va_end(args);
 145 }
 146 EXPORT_SYMBOL(ath10k_warn);
 147
 148 #ifdef CONFIG_ATH10K_DEBUGFS
 149
 150 static ssize_t ath10k_read_wmi_services(struct file *file,
 151                                         char __user *user_buf,
 152                                         size_t count, loff_t *ppos)
 153 {
 154         struct ath10k *ar = file->private_data;
 155         char *buf;
 156         size_t len = 0, buf_len = 8192;
 157         const char *name;
 158         ssize_t ret_cnt;
 159         bool enabled;
 160         int i;
 161
 162         buf = kzalloc(buf_len, GFP_KERNEL);
 163         if (!buf)
 164                 return -ENOMEM;
 165
 166         mutex_lock(&ar->conf_mutex);
 167
 168         spin_lock_bh(&ar->data_lock);
 169         for (i = 0; i < WMI_SERVICE_MAX; i++) {
 170                 enabled = test_bit(i, ar->wmi.svc_map);
 171                 name = wmi_service_name(i);
 172
 173                 if (!name) {
 174                         if (enabled)
 175                                 len += scnprintf(buf + len, buf_len - len,
 176                                                  "%-40s %s (bit %d)\n",
 177                                                  "unknown", "enabled", i);
 178
 179                         continue;
 180                 }
 181
 182                 len += scnprintf(buf + len, buf_len - len,
 183                                  "%-40s %s\n",
 184                                  name, enabled ? "enabled" : "-");
 185         }
 186         spin_unlock_bh(&ar->data_lock);
 187
 188         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 189
 190         mutex_unlock(&ar->conf_mutex);
 191
 192         kfree(buf);
 193         return ret_cnt;
 194 }
 195
 196 static const struct file_operations fops_wmi_services = {
 197         .read = ath10k_read_wmi_services,
 198         .open = simple_open,
 199         .owner = THIS_MODULE,
 200         .llseek = default_llseek,
 201 };
 202
 203 static void ath10k_fw_stats_pdevs_free(struct list_head *head)
 204 {
 205         struct ath10k_fw_stats_pdev *i, *tmp;
 206
 207         list_for_each_entry_safe(i, tmp, head, list) {
 208                 list_del(&i->list);
 209                 kfree(i);
 210         }
 211 }
 212
 213 static void ath10k_fw_stats_vdevs_free(struct list_head *head)
 214 {
 215         struct ath10k_fw_stats_vdev *i, *tmp;
 216
 217         list_for_each_entry_safe(i, tmp, head, list) {
 218                 list_del(&i->list);
 219                 kfree(i);
 220         }
 221 }
 222
 223 static void ath10k_fw_stats_peers_free(struct list_head *head)
 224 {
 225         struct ath10k_fw_stats_peer *i, *tmp;
 226
 227         list_for_each_entry_safe(i, tmp, head, list) {
 228                 list_del(&i->list);
 229                 kfree(i);
 230         }
 231 }
 232
 233 static void ath10k_fw_extd_stats_peers_free(struct list_head *head)
 234 {
 235         struct ath10k_fw_extd_stats_peer *i, *tmp;
 236
 237         list_for_each_entry_safe(i, tmp, head, list) {
 238                 list_del(&i->list);
 239                 kfree(i);
 240         }
 241 }
 242
 243 static void ath10k_debug_fw_stats_reset(struct ath10k *ar)
 244 {
 245         spin_lock_bh(&ar->data_lock);
 246         ar->debug.fw_stats_done = false;
 247         ar->debug.fw_stats.extended = false;
 248         ath10k_fw_stats_pdevs_free(&ar->debug.fw_stats.pdevs);
 249         ath10k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
 250         ath10k_fw_stats_peers_free(&ar->debug.fw_stats.peers);
 251         ath10k_fw_extd_stats_peers_free(&ar->debug.fw_stats.peers_extd);
 252         spin_unlock_bh(&ar->data_lock);
 253 }
 254
 255 void ath10k_debug_fw_stats_process(struct ath10k *ar, struct sk_buff *skb)
 256 {
 257         struct ath10k_fw_stats stats = {};
 258         bool is_start, is_started, is_end;
 259         size_t num_peers;
 260         size_t num_vdevs;
 261         int ret;
 262
 263         INIT_LIST_HEAD(&stats.pdevs);
 264         INIT_LIST_HEAD(&stats.vdevs);
 265         INIT_LIST_HEAD(&stats.peers);
 266         INIT_LIST_HEAD(&stats.peers_extd);
 267
 268         spin_lock_bh(&ar->data_lock);
 269         ret = ath10k_wmi_pull_fw_stats(ar, skb, &stats);
 270         if (ret) {
 271                 ath10k_warn(ar, "failed to pull fw stats: %d\n", ret);
 272                 goto free;
 273         }
 274
 275         /* Stat data may exceed htc-wmi buffer limit. In such case firmware
 276          * splits the stats data and delivers it in a ping-pong fashion of
 277          * request cmd-update event.
 278          *
 279          * However there is no explicit end-of-data. Instead start-of-data is
 280          * used as an implicit one. This works as follows:
 281          *  a) discard stat update events until one with pdev stats is
 282          *     delivered - this skips session started at end of (b)
 283          *  b) consume stat update events until another one with pdev stats is
 284          *     delivered which is treated as end-of-data and is itself discarded
 285          */
 286         if (ath10k_peer_stats_enabled(ar))
 287                 ath10k_sta_update_rx_duration(ar, &stats);
 288
 289         if (ar->debug.fw_stats_done) {
 290                 if (!ath10k_peer_stats_enabled(ar))
 291                         ath10k_warn(ar, "received unsolicited stats update event\n");
 292
 293                 goto free;
 294         }
 295
 296         num_peers = ath10k_wmi_fw_stats_num_peers(&ar->debug.fw_stats.peers);
 297         num_vdevs = ath10k_wmi_fw_stats_num_vdevs(&ar->debug.fw_stats.vdevs);
 298         is_start = (list_empty(&ar->debug.fw_stats.pdevs) &&
 299                     !list_empty(&stats.pdevs));
 300         is_end = (!list_empty(&ar->debug.fw_stats.pdevs) &&
 301                   !list_empty(&stats.pdevs));
 302
 303         if (is_start)
 304                 list_splice_tail_init(&stats.pdevs, &ar->debug.fw_stats.pdevs);
 305
 306         if (is_end)
 307                 ar->debug.fw_stats_done = true;
 308
 309         if (stats.extended)
 310                 ar->debug.fw_stats.extended = true;
 311
 312         is_started = !list_empty(&ar->debug.fw_stats.pdevs);
 313
 314         if (is_started && !is_end) {
 315                 if (num_peers >= ATH10K_MAX_NUM_PEER_IDS) {
 316                         /* Although this is unlikely impose a sane limit to
 317                          * prevent firmware from DoS-ing the host.
 318                          */
 319                         ath10k_fw_stats_peers_free(&ar->debug.fw_stats.peers);
 320                         ath10k_fw_extd_stats_peers_free(&ar->debug.fw_stats.peers_extd);
 321                         ath10k_warn(ar, "dropping fw peer stats\n");
 322                         goto free;
 323                 }
 324
 325                 if (num_vdevs >= BITS_PER_LONG) {
 326                         ath10k_fw_stats_vdevs_free(&ar->debug.fw_stats.vdevs);
 327                         ath10k_warn(ar, "dropping fw vdev stats\n");
 328                         goto free;
 329                 }
 330
 331                 if (!list_empty(&stats.peers))
 332                         list_splice_tail_init(&stats.peers_extd,
 333                                               &ar->debug.fw_stats.peers_extd);
 334
 335                 list_splice_tail_init(&stats.peers, &ar->debug.fw_stats.peers);
 336                 list_splice_tail_init(&stats.vdevs, &ar->debug.fw_stats.vdevs);
 337         }
 338
 339         complete(&ar->debug.fw_stats_complete);
 340
 341 free:
 342         /* In some cases lists have been spliced and cleared. Free up
 343          * resources if that is not the case.
 344          */
 345         ath10k_fw_stats_pdevs_free(&stats.pdevs);
 346         ath10k_fw_stats_vdevs_free(&stats.vdevs);
 347         ath10k_fw_stats_peers_free(&stats.peers);
 348         ath10k_fw_extd_stats_peers_free(&stats.peers_extd);
 349
 350         spin_unlock_bh(&ar->data_lock);
 351 }
 352
 353 int ath10k_debug_fw_stats_request(struct ath10k *ar)
 354 {
 355         unsigned long timeout, time_left;
 356         int ret;
 357
 358         lockdep_assert_held(&ar->conf_mutex);
 359
 360         timeout = jiffies + msecs_to_jiffies(1 * HZ);
 361
 362         ath10k_debug_fw_stats_reset(ar);
 363
 364         for (;;) {
 365                 if (time_after(jiffies, timeout))
 366                         return -ETIMEDOUT;
 367
 368                 reinit_completion(&ar->debug.fw_stats_complete);
 369
 370                 ret = ath10k_wmi_request_stats(ar, ar->fw_stats_req_mask);
 371                 if (ret) {
 372                         ath10k_warn(ar, "could not request stats (%d)\n", ret);
 373                         return ret;
 374                 }
 375
 376                 time_left =
 377                 wait_for_completion_timeout(&ar->debug.fw_stats_complete,
 378                                             1 * HZ);
 379                 if (!time_left)
 380                         return -ETIMEDOUT;
 381
 382                 spin_lock_bh(&ar->data_lock);
 383                 if (ar->debug.fw_stats_done) {
 384                         spin_unlock_bh(&ar->data_lock);
 385                         break;
 386                 }
 387                 spin_unlock_bh(&ar->data_lock);
 388         }
 389
 390         return 0;
 391 }
 392
 393 static int ath10k_fw_stats_open(struct inode *inode, struct file *file)
 394 {
 395         struct ath10k *ar = inode->i_private;
 396         void *buf = NULL;
 397         int ret;
 398
 399         mutex_lock(&ar->conf_mutex);
 400
 401         if (ar->state != ATH10K_STATE_ON) {
 402                 ret = -ENETDOWN;
 403                 goto err_unlock;
 404         }
 405
 406         buf = vmalloc(ATH10K_FW_STATS_BUF_SIZE);
 407         if (!buf) {
 408                 ret = -ENOMEM;
 409                 goto err_unlock;
 410         }
 411
 412         ret = ath10k_debug_fw_stats_request(ar);
 413         if (ret) {
 414                 ath10k_warn(ar, "failed to request fw stats: %d\n", ret);
 415                 goto err_free;
 416         }
 417
 418         ret = ath10k_wmi_fw_stats_fill(ar, &ar->debug.fw_stats, buf);
 419         if (ret) {
 420                 ath10k_warn(ar, "failed to fill fw stats: %d\n", ret);
 421                 goto err_free;
 422         }
 423
 424         file->private_data = buf;
 425
 426         mutex_unlock(&ar->conf_mutex);
 427         return 0;
 428
 429 err_free:
 430         vfree(buf);
 431
 432 err_unlock:
 433         mutex_unlock(&ar->conf_mutex);
 434         return ret;
 435 }
 436
 437 static int ath10k_fw_stats_release(struct inode *inode, struct file *file)
 438 {
 439         vfree(file->private_data);
 440
 441         return 0;
 442 }
 443
 444 static ssize_t ath10k_fw_stats_read(struct file *file, char __user *user_buf,
 445                                     size_t count, loff_t *ppos)
 446 {
 447         const char *buf = file->private_data;
 448         size_t len = strlen(buf);
 449
 450         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 451 }
 452
 453 static const struct file_operations fops_fw_stats = {
 454         .open = ath10k_fw_stats_open,
 455         .release = ath10k_fw_stats_release,
 456         .read = ath10k_fw_stats_read,
 457         .owner = THIS_MODULE,
 458         .llseek = default_llseek,
 459 };
 460
 461 static ssize_t ath10k_debug_fw_reset_stats_read(struct file *file,
 462                                                 char __user *user_buf,
 463                                                 size_t count, loff_t *ppos)
 464 {
 465         struct ath10k *ar = file->private_data;
 466         int ret;
 467         size_t len = 0, buf_len = 500;
 468         char *buf;
 469
 470         buf = kmalloc(buf_len, GFP_KERNEL);
 471         if (!buf)
 472                 return -ENOMEM;
 473
 474         spin_lock_bh(&ar->data_lock);
 475
 476         len += scnprintf(buf + len, buf_len - len,
 477                          "fw_crash_counter\t\t%d\n", ar->stats.fw_crash_counter);
 478         len += scnprintf(buf + len, buf_len - len,
 479                          "fw_warm_reset_counter\t\t%d\n",
 480                          ar->stats.fw_warm_reset_counter);
 481         len += scnprintf(buf + len, buf_len - len,
 482                          "fw_cold_reset_counter\t\t%d\n",
 483                          ar->stats.fw_cold_reset_counter);
 484
 485         spin_unlock_bh(&ar->data_lock);
 486
 487         ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 488
 489         kfree(buf);
 490
 491         return ret;
 492 }
 493
 494 static const struct file_operations fops_fw_reset_stats = {
 495         .open = simple_open,
 496         .read = ath10k_debug_fw_reset_stats_read,
 497         .owner = THIS_MODULE,
 498         .llseek = default_llseek,
 499 };
 500
 501 /* This is a clean assert crash in firmware. */
 502 static int ath10k_debug_fw_assert(struct ath10k *ar)
 503 {
 504         struct wmi_vdev_install_key_cmd *cmd;
 505         struct sk_buff *skb;
 506
 507         skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd) + 16);
 508         if (!skb)
 509                 return -ENOMEM;
 510
 511         cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
 512         memset(cmd, 0, sizeof(*cmd));
 513
 514         /* big enough number so that firmware asserts */
 515         cmd->vdev_id = __cpu_to_le32(0x7ffe);
 516
 517         return ath10k_wmi_cmd_send(ar, skb,
 518                                    ar->wmi.cmd->vdev_install_key_cmdid);
 519 }
 520
 521 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
 522                                              char __user *user_buf,
 523                                              size_t count, loff_t *ppos)
 524 {
 525         const char buf[] =
 526                 "To simulate firmware crash write one of the keywords to this file:\n"
 527                 "`soft` - this will send WMI_FORCE_FW_HANG_ASSERT to firmware if FW supports that command.\n"
 528                 "`hard` - this will send to firmware command with illegal parameters causing firmware crash.\n"
 529                 "`assert` - this will send special illegal parameter to firmware to cause assert failure and crash.\n"
 530                 "`hw-restart` - this will simply queue hw restart without fw/hw actually crashing.\n";
 531
 532         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
 533 }
 534
 535 /* Simulate firmware crash:
 536  * 'soft': Call wmi command causing firmware hang. This firmware hang is
 537  * recoverable by warm firmware reset.
 538  * 'hard': Force firmware crash by setting any vdev parameter for not allowed
 539  * vdev id. This is hard firmware crash because it is recoverable only by cold
 540  * firmware reset.
 541  */
 542 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
 543                                               const char __user *user_buf,
 544                                               size_t count, loff_t *ppos)
 545 {
 546         struct ath10k *ar = file->private_data;
 547         char buf[32] = {0};
 548         ssize_t rc;
 549         int ret;
 550
 551         /* filter partial writes and invalid commands */
 552         if (*ppos != 0 || count >= sizeof(buf) || count == 0)
 553                 return -EINVAL;
 554
 555         rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
 556         if (rc < 0)
 557                 return rc;
 558
 559         /* drop the possible '\n' from the end */
 560         if (buf[*ppos - 1] == '\n')
 561                 buf[*ppos - 1] = '\0';
 562
 563         mutex_lock(&ar->conf_mutex);
 564
 565         if (ar->state != ATH10K_STATE_ON &&
 566             ar->state != ATH10K_STATE_RESTARTED) {
 567                 ret = -ENETDOWN;
 568                 goto exit;
 569         }
 570
 571         if (!strcmp(buf, "soft")) {
 572                 ath10k_info(ar, "simulating soft firmware crash\n");
 573                 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
 574         } else if (!strcmp(buf, "hard")) {
 575                 ath10k_info(ar, "simulating hard firmware crash\n");
 576                 /* 0x7fff is vdev id, and it is always out of range for all
 577                  * firmware variants in order to force a firmware crash.
 578                  */
 579                 ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
 580                                                 ar->wmi.vdev_param->rts_threshold,
 581                                                 0);
 582         } else if (!strcmp(buf, "assert")) {
 583                 ath10k_info(ar, "simulating firmware assert crash\n");
 584                 ret = ath10k_debug_fw_assert(ar);
 585         } else if (!strcmp(buf, "hw-restart")) {
 586                 ath10k_info(ar, "user requested hw restart\n");
 587                 ath10k_core_start_recovery(ar);
 588                 ret = 0;
 589         } else {
 590                 ret = -EINVAL;
 591                 goto exit;
 592         }
 593
 594         if (ret) {
 595                 ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
 596                 goto exit;
 597         }
 598
 599         ret = count;
 600
 601 exit:
 602         mutex_unlock(&ar->conf_mutex);
 603         return ret;
 604 }
 605
 606 static const struct file_operations fops_simulate_fw_crash = {
 607         .read = ath10k_read_simulate_fw_crash,
 608         .write = ath10k_write_simulate_fw_crash,
 609         .open = simple_open,
 610         .owner = THIS_MODULE,
 611         .llseek = default_llseek,
 612 };
 613
 614 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
 615                                    size_t count, loff_t *ppos)
 616 {
 617         struct ath10k *ar = file->private_data;
 618         size_t len;
 619         char buf[50];
 620
 621         len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->bus_param.chip_id);
 622
 623         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 624 }
 625
 626 static const struct file_operations fops_chip_id = {
 627         .read = ath10k_read_chip_id,
 628         .open = simple_open,
 629         .owner = THIS_MODULE,
 630         .llseek = default_llseek,
 631 };
 632
 633 static ssize_t ath10k_reg_addr_read(struct file *file,
 634                                     char __user *user_buf,
 635                                     size_t count, loff_t *ppos)
 636 {
 637         struct ath10k *ar = file->private_data;
 638         u8 buf[32];
 639         size_t len = 0;
 640         u32 reg_addr;
 641
 642         mutex_lock(&ar->conf_mutex);
 643         reg_addr = ar->debug.reg_addr;
 644         mutex_unlock(&ar->conf_mutex);
 645
 646         len += scnprintf(buf + len, sizeof(buf) - len, "0x%x\n", reg_addr);
 647
 648         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 649 }
 650
 651 static ssize_t ath10k_reg_addr_write(struct file *file,
 652                                      const char __user *user_buf,
 653                                      size_t count, loff_t *ppos)
 654 {
 655         struct ath10k *ar = file->private_data;
 656         u32 reg_addr;
 657         int ret;
 658
 659         ret = kstrtou32_from_user(user_buf, count, 0, &reg_addr);
 660         if (ret)
 661                 return ret;
 662
 663         if (!IS_ALIGNED(reg_addr, 4))
 664                 return -EFAULT;
 665
 666         mutex_lock(&ar->conf_mutex);
 667         ar->debug.reg_addr = reg_addr;
 668         mutex_unlock(&ar->conf_mutex);
 669
 670         return count;
 671 }
 672
 673 static const struct file_operations fops_reg_addr = {
 674         .read = ath10k_reg_addr_read,
 675         .write = ath10k_reg_addr_write,
 676         .open = simple_open,
 677         .owner = THIS_MODULE,
 678         .llseek = default_llseek,
 679 };
 680
 681 static ssize_t ath10k_reg_value_read(struct file *file,
 682                                      char __user *user_buf,
 683                                      size_t count, loff_t *ppos)
 684 {
 685         struct ath10k *ar = file->private_data;
 686         u8 buf[48];
 687         size_t len;
 688         u32 reg_addr, reg_val;
 689         int ret;
 690
 691         mutex_lock(&ar->conf_mutex);
 692
 693         if (ar->state != ATH10K_STATE_ON &&
 694             ar->state != ATH10K_STATE_UTF) {
 695                 ret = -ENETDOWN;
 696                 goto exit;
 697         }
 698
 699         reg_addr = ar->debug.reg_addr;
 700
 701         reg_val = ath10k_hif_read32(ar, reg_addr);
 702         len = scnprintf(buf, sizeof(buf), "0x%08x:0x%08x\n", reg_addr, reg_val);
 703
 704         ret = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 705
 706 exit:
 707         mutex_unlock(&ar->conf_mutex);
 708
 709         return ret;
 710 }
 711
 712 static ssize_t ath10k_reg_value_write(struct file *file,
 713                                       const char __user *user_buf,
 714                                       size_t count, loff_t *ppos)
 715 {
 716         struct ath10k *ar = file->private_data;
 717         u32 reg_addr, reg_val;
 718         int ret;
 719
 720         mutex_lock(&ar->conf_mutex);
 721
 722         if (ar->state != ATH10K_STATE_ON &&
 723             ar->state != ATH10K_STATE_UTF) {
 724                 ret = -ENETDOWN;
 725                 goto exit;
 726         }
 727
 728         reg_addr = ar->debug.reg_addr;
 729
 730         ret = kstrtou32_from_user(user_buf, count, 0, &reg_val);
 731         if (ret)
 732                 goto exit;
 733
 734         ath10k_hif_write32(ar, reg_addr, reg_val);
 735
 736         ret = count;
 737
 738 exit:
 739         mutex_unlock(&ar->conf_mutex);
 740
 741         return ret;
 742 }
 743
 744 static const struct file_operations fops_reg_value = {
 745         .read = ath10k_reg_value_read,
 746         .write = ath10k_reg_value_write,
 747         .open = simple_open,
 748         .owner = THIS_MODULE,
 749         .llseek = default_llseek,
 750 };
 751
 752 static ssize_t ath10k_mem_value_read(struct file *file,
 753                                      char __user *user_buf,
 754                                      size_t count, loff_t *ppos)
 755 {
 756         struct ath10k *ar = file->private_data;
 757         u8 *buf;
 758         int ret;
 759
 760         if (*ppos < 0)
 761                 return -EINVAL;
 762
 763         if (!count)
 764                 return 0;
 765
 766         mutex_lock(&ar->conf_mutex);
 767
 768         buf = vmalloc(count);
 769         if (!buf) {
 770                 ret = -ENOMEM;
 771                 goto exit;
 772         }
 773
 774         if (ar->state != ATH10K_STATE_ON &&
 775             ar->state != ATH10K_STATE_UTF) {
 776                 ret = -ENETDOWN;
 777                 goto exit;
 778         }
 779
 780         ret = ath10k_hif_diag_read(ar, *ppos, buf, count);
 781         if (ret) {
 782                 ath10k_warn(ar, "failed to read address 0x%08x via diagnose window from debugfs: %d\n",
 783                             (u32)(*ppos), ret);
 784                 goto exit;
 785         }
 786
 787         ret = copy_to_user(user_buf, buf, count);
 788         if (ret) {
 789                 ret = -EFAULT;
 790                 goto exit;
 791         }
 792
 793         count -= ret;
 794         *ppos += count;
 795         ret = count;
 796
 797 exit:
 798         vfree(buf);
 799         mutex_unlock(&ar->conf_mutex);
 800
 801         return ret;
 802 }
 803
 804 static ssize_t ath10k_mem_value_write(struct file *file,
 805                                       const char __user *user_buf,
 806                                       size_t count, loff_t *ppos)
 807 {
 808         struct ath10k *ar = file->private_data;
 809         u8 *buf;
 810         int ret;
 811
 812         if (*ppos < 0)
 813                 return -EINVAL;
 814
 815         if (!count)
 816                 return 0;
 817
 818         mutex_lock(&ar->conf_mutex);
 819
 820         buf = vmalloc(count);
 821         if (!buf) {
 822                 ret = -ENOMEM;
 823                 goto exit;
 824         }
 825
 826         if (ar->state != ATH10K_STATE_ON &&
 827             ar->state != ATH10K_STATE_UTF) {
 828                 ret = -ENETDOWN;
 829                 goto exit;
 830         }
 831
 832         ret = copy_from_user(buf, user_buf, count);
 833         if (ret) {
 834                 ret = -EFAULT;
 835                 goto exit;
 836         }
 837
 838         ret = ath10k_hif_diag_write(ar, *ppos, buf, count);
 839         if (ret) {
 840                 ath10k_warn(ar, "failed to write address 0x%08x via diagnose window from debugfs: %d\n",
 841                             (u32)(*ppos), ret);
 842                 goto exit;
 843         }
 844
 845         *ppos += count;
 846         ret = count;
 847
 848 exit:
 849         vfree(buf);
 850         mutex_unlock(&ar->conf_mutex);
 851
 852         return ret;
 853 }
 854
 855 static const struct file_operations fops_mem_value = {
 856         .read = ath10k_mem_value_read,
 857         .write = ath10k_mem_value_write,
 858         .open = simple_open,
 859         .owner = THIS_MODULE,
 860         .llseek = default_llseek,
 861 };
 862
 863 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
 864 {
 865         u64 cookie;
 866         int ret;
 867
 868         lockdep_assert_held(&ar->conf_mutex);
 869
 870         if (ar->debug.htt_stats_mask == 0)
 871                 /* htt stats are disabled */
 872                 return 0;
 873
 874         if (ar->state != ATH10K_STATE_ON)
 875                 return 0;
 876
 877         cookie = get_jiffies_64();
 878
 879         ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
 880                                        ar->debug.reset_htt_stats, cookie);
 881         if (ret) {
 882                 ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
 883                 return ret;
 884         }
 885
 886         queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
 887                            msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
 888
 889         return 0;
 890 }
 891
 892 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
 893 {
 894         struct ath10k *ar = container_of(work, struct ath10k,
 895                                          debug.htt_stats_dwork.work);
 896
 897         mutex_lock(&ar->conf_mutex);
 898
 899         ath10k_debug_htt_stats_req(ar);
 900
 901         mutex_unlock(&ar->conf_mutex);
 902 }
 903
 904 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
 905                                           char __user *user_buf,
 906                                           size_t count, loff_t *ppos)
 907 {
 908         struct ath10k *ar = file->private_data;
 909         char buf[32];
 910         size_t len;
 911
 912         len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
 913
 914         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 915 }
 916
 917 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
 918                                            const char __user *user_buf,
 919                                            size_t count, loff_t *ppos)
 920 {
 921         struct ath10k *ar = file->private_data;
 922         unsigned long mask;
 923         int ret;
 924
 925         ret = kstrtoul_from_user(user_buf, count, 0, &mask);
 926         if (ret)
 927                 return ret;
 928
 929         /* max 17 bit masks (for now) */
 930         if (mask > HTT_STATS_BIT_MASK)
 931                 return -E2BIG;
 932
 933         mutex_lock(&ar->conf_mutex);
 934
 935         ar->debug.htt_stats_mask = mask;
 936
 937         ret = ath10k_debug_htt_stats_req(ar);
 938         if (ret)
 939                 goto out;
 940
 941         ret = count;
 942
 943 out:
 944         mutex_unlock(&ar->conf_mutex);
 945
 946         return ret;
 947 }
 948
 949 static const struct file_operations fops_htt_stats_mask = {
 950         .read = ath10k_read_htt_stats_mask,
 951         .write = ath10k_write_htt_stats_mask,
 952         .open = simple_open,
 953         .owner = THIS_MODULE,
 954         .llseek = default_llseek,
 955 };
 956
 957 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
 958                                                char __user *user_buf,
 959                                                size_t count, loff_t *ppos)
 960 {
 961         struct ath10k *ar = file->private_data;
 962         char buf[64];
 963         u8 amsdu, ampdu;
 964         size_t len;
 965
 966         mutex_lock(&ar->conf_mutex);
 967
 968         amsdu = ar->htt.max_num_amsdu;
 969         ampdu = ar->htt.max_num_ampdu;
 970         mutex_unlock(&ar->conf_mutex);
 971
 972         len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
 973
 974         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 975 }
 976
 977 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
 978                                                 const char __user *user_buf,
 979                                                 size_t count, loff_t *ppos)
 980 {
 981         struct ath10k *ar = file->private_data;
 982         int res;
 983         char buf[64] = {0};
 984         unsigned int amsdu, ampdu;
 985
 986         res = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
 987                                      user_buf, count);
 988         if (res <= 0)
 989                 return res;
 990
 991         res = sscanf(buf, "%u %u", &amsdu, &ampdu);
 992
 993         if (res != 2)
 994                 return -EINVAL;
 995
 996         mutex_lock(&ar->conf_mutex);
 997
 998         res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
 999         if (res)
1000                 goto out;
1001
1002         res = count;
1003         ar->htt.max_num_amsdu = amsdu;
1004         ar->htt.max_num_ampdu = ampdu;
1005
1006 out:
1007         mutex_unlock(&ar->conf_mutex);
1008         return res;
1009 }
1010
1011 static const struct file_operations fops_htt_max_amsdu_ampdu = {
1012         .read = ath10k_read_htt_max_amsdu_ampdu,
1013         .write = ath10k_write_htt_max_amsdu_ampdu,
1014         .open = simple_open,
1015         .owner = THIS_MODULE,
1016         .llseek = default_llseek,
1017 };
1018
1019 static ssize_t ath10k_read_fw_dbglog(struct file *file,
1020                                      char __user *user_buf,
1021                                      size_t count, loff_t *ppos)
1022 {
1023         struct ath10k *ar = file->private_data;
1024         size_t len;
1025         char buf[96];
1026
1027         len = scnprintf(buf, sizeof(buf), "0x%16llx %u\n",
1028                         ar->debug.fw_dbglog_mask, ar->debug.fw_dbglog_level);
1029
1030         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1031 }
1032
1033 static ssize_t ath10k_write_fw_dbglog(struct file *file,
1034                                       const char __user *user_buf,
1035                                       size_t count, loff_t *ppos)
1036 {
1037         struct ath10k *ar = file->private_data;
1038         int ret;
1039         char buf[96] = {0};
1040         unsigned int log_level;
1041         u64 mask;
1042
1043         ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos,
1044                                      user_buf, count);
1045         if (ret <= 0)
1046                 return ret;
1047
1048         ret = sscanf(buf, "%llx %u", &mask, &log_level);
1049
1050         if (!ret)
1051                 return -EINVAL;
1052
1053         if (ret == 1)
1054                 /* default if user did not specify */
1055                 log_level = ATH10K_DBGLOG_LEVEL_WARN;
1056
1057         mutex_lock(&ar->conf_mutex);
1058
1059         ar->debug.fw_dbglog_mask = mask;
1060         ar->debug.fw_dbglog_level = log_level;
1061
1062         if (ar->state == ATH10K_STATE_ON) {
1063                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1064                                             ar->debug.fw_dbglog_level);
1065                 if (ret) {
1066                         ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1067                                     ret);
1068                         goto exit;
1069                 }
1070         }
1071
1072         ret = count;
1073
1074 exit:
1075         mutex_unlock(&ar->conf_mutex);
1076
1077         return ret;
1078 }
1079
1080 /* TODO:  Would be nice to always support ethtool stats, would need to
1081  * move the stats storage out of ath10k_debug, or always have ath10k_debug
1082  * struct available..
1083  */
1084
1085 /* This generally corresponds to the debugfs fw_stats file */
1086 static const char ath10k_gstrings_stats[][ETH_GSTRING_LEN] = {
1087         "tx_pkts_nic",
1088         "tx_bytes_nic",
1089         "rx_pkts_nic",
1090         "rx_bytes_nic",
1091         "d_noise_floor",
1092         "d_cycle_count",
1093         "d_phy_error",
1094         "d_rts_bad",
1095         "d_rts_good",
1096         "d_tx_power", /* in .5 dbM I think */
1097         "d_rx_crc_err", /* fcs_bad */
1098         "d_rx_crc_err_drop", /* frame with FCS error, dropped late in kernel */
1099         "d_no_beacon",
1100         "d_tx_mpdus_queued",
1101         "d_tx_msdu_queued",
1102         "d_tx_msdu_dropped",
1103         "d_local_enqued",
1104         "d_local_freed",
1105         "d_tx_ppdu_hw_queued",
1106         "d_tx_ppdu_reaped",
1107         "d_tx_fifo_underrun",
1108         "d_tx_ppdu_abort",
1109         "d_tx_mpdu_requeued",
1110         "d_tx_excessive_retries",
1111         "d_tx_hw_rate",
1112         "d_tx_dropped_sw_retries",
1113         "d_tx_illegal_rate",
1114         "d_tx_continuous_xretries",
1115         "d_tx_timeout",
1116         "d_tx_mpdu_txop_limit",
1117         "d_pdev_resets",
1118         "d_rx_mid_ppdu_route_change",
1119         "d_rx_status",
1120         "d_rx_extra_frags_ring0",
1121         "d_rx_extra_frags_ring1",
1122         "d_rx_extra_frags_ring2",
1123         "d_rx_extra_frags_ring3",
1124         "d_rx_msdu_htt",
1125         "d_rx_mpdu_htt",
1126         "d_rx_msdu_stack",
1127         "d_rx_mpdu_stack",
1128         "d_rx_phy_err",
1129         "d_rx_phy_err_drops",
1130         "d_rx_mpdu_errors", /* FCS, MIC, ENC */
1131         "d_fw_crash_count",
1132         "d_fw_warm_reset_count",
1133         "d_fw_cold_reset_count",
1134 };
1135
1136 #define ATH10K_SSTATS_LEN ARRAY_SIZE(ath10k_gstrings_stats)
1137
1138 void ath10k_debug_get_et_strings(struct ieee80211_hw *hw,
1139                                  struct ieee80211_vif *vif,
1140                                  u32 sset, u8 *data)
1141 {
1142         if (sset == ETH_SS_STATS)
1143                 memcpy(data, *ath10k_gstrings_stats,
1144                        sizeof(ath10k_gstrings_stats));
1145 }
1146
1147 int ath10k_debug_get_et_sset_count(struct ieee80211_hw *hw,
1148                                    struct ieee80211_vif *vif, int sset)
1149 {
1150         if (sset == ETH_SS_STATS)
1151                 return ATH10K_SSTATS_LEN;
1152
1153         return 0;
1154 }
1155
1156 void ath10k_debug_get_et_stats(struct ieee80211_hw *hw,
1157                                struct ieee80211_vif *vif,
1158                                struct ethtool_stats *stats, u64 *data)
1159 {
1160         struct ath10k *ar = hw->priv;
1161         static const struct ath10k_fw_stats_pdev zero_stats = {};
1162         const struct ath10k_fw_stats_pdev *pdev_stats;
1163         int i = 0, ret;
1164
1165         mutex_lock(&ar->conf_mutex);
1166
1167         if (ar->state == ATH10K_STATE_ON) {
1168                 ret = ath10k_debug_fw_stats_request(ar);
1169                 if (ret) {
1170                         /* just print a warning and try to use older results */
1171                         ath10k_warn(ar,
1172                                     "failed to get fw stats for ethtool: %d\n",
1173                                     ret);
1174                 }
1175         }
1176
1177         pdev_stats = list_first_entry_or_null(&ar->debug.fw_stats.pdevs,
1178                                               struct ath10k_fw_stats_pdev,
1179                                               list);
1180         if (!pdev_stats) {
1181                 /* no results available so just return zeroes */
1182                 pdev_stats = &zero_stats;
1183         }
1184
1185         spin_lock_bh(&ar->data_lock);
1186
1187         data[i++] = pdev_stats->hw_reaped; /* ppdu reaped */
1188         data[i++] = 0; /* tx bytes */
1189         data[i++] = pdev_stats->htt_mpdus;
1190         data[i++] = 0; /* rx bytes */
1191         data[i++] = pdev_stats->ch_noise_floor;
1192         data[i++] = pdev_stats->cycle_count;
1193         data[i++] = pdev_stats->phy_err_count;
1194         data[i++] = pdev_stats->rts_bad;
1195         data[i++] = pdev_stats->rts_good;
1196         data[i++] = pdev_stats->chan_tx_power;
1197         data[i++] = pdev_stats->fcs_bad;
1198         data[i++] = ar->stats.rx_crc_err_drop;
1199         data[i++] = pdev_stats->no_beacons;
1200         data[i++] = pdev_stats->mpdu_enqued;
1201         data[i++] = pdev_stats->msdu_enqued;
1202         data[i++] = pdev_stats->wmm_drop;
1203         data[i++] = pdev_stats->local_enqued;
1204         data[i++] = pdev_stats->local_freed;
1205         data[i++] = pdev_stats->hw_queued;
1206         data[i++] = pdev_stats->hw_reaped;
1207         data[i++] = pdev_stats->underrun;
1208         data[i++] = pdev_stats->tx_abort;
1209         data[i++] = pdev_stats->mpdus_requeued;
1210         data[i++] = pdev_stats->tx_ko;
1211         data[i++] = pdev_stats->data_rc;
1212         data[i++] = pdev_stats->sw_retry_failure;
1213         data[i++] = pdev_stats->illgl_rate_phy_err;
1214         data[i++] = pdev_stats->pdev_cont_xretry;
1215         data[i++] = pdev_stats->pdev_tx_timeout;
1216         data[i++] = pdev_stats->txop_ovf;
1217         data[i++] = pdev_stats->pdev_resets;
1218         data[i++] = pdev_stats->mid_ppdu_route_change;
1219         data[i++] = pdev_stats->status_rcvd;
1220         data[i++] = pdev_stats->r0_frags;
1221         data[i++] = pdev_stats->r1_frags;
1222         data[i++] = pdev_stats->r2_frags;
1223         data[i++] = pdev_stats->r3_frags;
1224         data[i++] = pdev_stats->htt_msdus;
1225         data[i++] = pdev_stats->htt_mpdus;
1226         data[i++] = pdev_stats->loc_msdus;
1227         data[i++] = pdev_stats->loc_mpdus;
1228         data[i++] = pdev_stats->phy_errs;
1229         data[i++] = pdev_stats->phy_err_drop;
1230         data[i++] = pdev_stats->mpdu_errs;
1231         data[i++] = ar->stats.fw_crash_counter;
1232         data[i++] = ar->stats.fw_warm_reset_counter;
1233         data[i++] = ar->stats.fw_cold_reset_counter;
1234
1235         spin_unlock_bh(&ar->data_lock);
1236
1237         mutex_unlock(&ar->conf_mutex);
1238
1239         WARN_ON(i != ATH10K_SSTATS_LEN);
1240 }
1241
1242 static const struct file_operations fops_fw_dbglog = {
1243         .read = ath10k_read_fw_dbglog,
1244         .write = ath10k_write_fw_dbglog,
1245         .open = simple_open,
1246         .owner = THIS_MODULE,
1247         .llseek = default_llseek,
1248 };
1249
1250 static int ath10k_debug_cal_data_fetch(struct ath10k *ar)
1251 {
1252         u32 hi_addr;
1253         __le32 addr;
1254         int ret;
1255
1256         lockdep_assert_held(&ar->conf_mutex);
1257
1258         if (WARN_ON(ar->hw_params.cal_data_len > ATH10K_DEBUG_CAL_DATA_LEN))
1259                 return -EINVAL;
1260
1261         if (ar->hw_params.cal_data_len == 0)
1262                 return -EOPNOTSUPP;
1263
1264         hi_addr = host_interest_item_address(HI_ITEM(hi_board_data));
1265
1266         ret = ath10k_hif_diag_read(ar, hi_addr, &addr, sizeof(addr));
1267         if (ret) {
1268                 ath10k_warn(ar, "failed to read hi_board_data address: %d\n",
1269                             ret);
1270                 return ret;
1271         }
1272
1273         ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), ar->debug.cal_data,
1274                                    ar->hw_params.cal_data_len);
1275         if (ret) {
1276                 ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
1277                 return ret;
1278         }
1279
1280         return 0;
1281 }
1282
1283 static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
1284 {
1285         struct ath10k *ar = inode->i_private;
1286
1287         mutex_lock(&ar->conf_mutex);
1288
1289         if (ar->state == ATH10K_STATE_ON ||
1290             ar->state == ATH10K_STATE_UTF) {
1291                 ath10k_debug_cal_data_fetch(ar);
1292         }
1293
1294         file->private_data = ar;
1295         mutex_unlock(&ar->conf_mutex);
1296
1297         return 0;
1298 }
1299
1300 static ssize_t ath10k_debug_cal_data_read(struct file *file,
1301                                           char __user *user_buf,
1302                                           size_t count, loff_t *ppos)
1303 {
1304         struct ath10k *ar = file->private_data;
1305
1306         mutex_lock(&ar->conf_mutex);
1307
1308         count = simple_read_from_buffer(user_buf, count, ppos,
1309                                         ar->debug.cal_data,
1310                                         ar->hw_params.cal_data_len);
1311
1312         mutex_unlock(&ar->conf_mutex);
1313
1314         return count;
1315 }
1316
1317 static ssize_t ath10k_write_ani_enable(struct file *file,
1318                                        const char __user *user_buf,
1319                                        size_t count, loff_t *ppos)
1320 {
1321         struct ath10k *ar = file->private_data;
1322         int ret;
1323         u8 enable;
1324
1325         if (kstrtou8_from_user(user_buf, count, 0, &enable))
1326                 return -EINVAL;
1327
1328         mutex_lock(&ar->conf_mutex);
1329
1330         if (ar->ani_enabled == enable) {
1331                 ret = count;
1332                 goto exit;
1333         }
1334
1335         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->ani_enable,
1336                                         enable);
1337         if (ret) {
1338                 ath10k_warn(ar, "ani_enable failed from debugfs: %d\n", ret);
1339                 goto exit;
1340         }
1341         ar->ani_enabled = enable;
1342
1343         ret = count;
1344
1345 exit:
1346         mutex_unlock(&ar->conf_mutex);
1347
1348         return ret;
1349 }
1350
1351 static ssize_t ath10k_read_ani_enable(struct file *file, char __user *user_buf,
1352                                       size_t count, loff_t *ppos)
1353 {
1354         struct ath10k *ar = file->private_data;
1355         size_t len;
1356         char buf[32];
1357
1358         len = scnprintf(buf, sizeof(buf), "%d\n", ar->ani_enabled);
1359
1360         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1361 }
1362
1363 static const struct file_operations fops_ani_enable = {
1364         .read = ath10k_read_ani_enable,
1365         .write = ath10k_write_ani_enable,
1366         .open = simple_open,
1367         .owner = THIS_MODULE,
1368         .llseek = default_llseek,
1369 };
1370
1371 static const struct file_operations fops_cal_data = {
1372         .open = ath10k_debug_cal_data_open,
1373         .read = ath10k_debug_cal_data_read,
1374         .owner = THIS_MODULE,
1375         .llseek = default_llseek,
1376 };
1377
1378 static ssize_t ath10k_read_nf_cal_period(struct file *file,
1379                                          char __user *user_buf,
1380                                          size_t count, loff_t *ppos)
1381 {
1382         struct ath10k *ar = file->private_data;
1383         size_t len;
1384         char buf[32];
1385
1386         len = scnprintf(buf, sizeof(buf), "%d\n", ar->debug.nf_cal_period);
1387
1388         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1389 }
1390
1391 static ssize_t ath10k_write_nf_cal_period(struct file *file,
1392                                           const char __user *user_buf,
1393                                           size_t count, loff_t *ppos)
1394 {
1395         struct ath10k *ar = file->private_data;
1396         unsigned long period;
1397         int ret;
1398
1399         ret = kstrtoul_from_user(user_buf, count, 0, &period);
1400         if (ret)
1401                 return ret;
1402
1403         if (period > WMI_PDEV_PARAM_CAL_PERIOD_MAX)
1404                 return -EINVAL;
1405
1406         /* there's no way to switch back to the firmware default */
1407         if (period == 0)
1408                 return -EINVAL;
1409
1410         mutex_lock(&ar->conf_mutex);
1411
1412         ar->debug.nf_cal_period = period;
1413
1414         if (ar->state != ATH10K_STATE_ON) {
1415                 /* firmware is not running, nothing else to do */
1416                 ret = count;
1417                 goto exit;
1418         }
1419
1420         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->cal_period,
1421                                         ar->debug.nf_cal_period);
1422         if (ret) {
1423                 ath10k_warn(ar, "cal period cfg failed from debugfs: %d\n",
1424                             ret);
1425                 goto exit;
1426         }
1427
1428         ret = count;
1429
1430 exit:
1431         mutex_unlock(&ar->conf_mutex);
1432
1433         return ret;
1434 }
1435
1436 static const struct file_operations fops_nf_cal_period = {
1437         .read = ath10k_read_nf_cal_period,
1438         .write = ath10k_write_nf_cal_period,
1439         .open = simple_open,
1440         .owner = THIS_MODULE,
1441         .llseek = default_llseek,
1442 };
1443
1444 #define ATH10K_TPC_CONFIG_BUF_SIZE      (1024 * 1024)
1445
1446 static int ath10k_debug_tpc_stats_request(struct ath10k *ar)
1447 {
1448         int ret;
1449         unsigned long time_left;
1450
1451         lockdep_assert_held(&ar->conf_mutex);
1452
1453         reinit_completion(&ar->debug.tpc_complete);
1454
1455         ret = ath10k_wmi_pdev_get_tpc_config(ar, WMI_TPC_CONFIG_PARAM);
1456         if (ret) {
1457                 ath10k_warn(ar, "failed to request tpc config: %d\n", ret);
1458                 return ret;
1459         }
1460
1461         time_left = wait_for_completion_timeout(&ar->debug.tpc_complete,
1462                                                 1 * HZ);
1463         if (time_left == 0)
1464                 return -ETIMEDOUT;
1465
1466         return 0;
1467 }
1468
1469 void ath10k_debug_tpc_stats_process(struct ath10k *ar,
1470                                     struct ath10k_tpc_stats *tpc_stats)
1471 {
1472         spin_lock_bh(&ar->data_lock);
1473
1474         kfree(ar->debug.tpc_stats);
1475         ar->debug.tpc_stats = tpc_stats;
1476         complete(&ar->debug.tpc_complete);
1477
1478         spin_unlock_bh(&ar->data_lock);
1479 }
1480
1481 void
1482 ath10k_debug_tpc_stats_final_process(struct ath10k *ar,
1483                                      struct ath10k_tpc_stats_final *tpc_stats)
1484 {
1485         spin_lock_bh(&ar->data_lock);
1486
1487         kfree(ar->debug.tpc_stats_final);
1488         ar->debug.tpc_stats_final = tpc_stats;
1489         complete(&ar->debug.tpc_complete);
1490
1491         spin_unlock_bh(&ar->data_lock);
1492 }
1493
1494 static void ath10k_tpc_stats_print(struct ath10k_tpc_stats *tpc_stats,
1495                                    unsigned int j, char *buf, size_t *len)
1496 {
1497         int i;
1498         size_t buf_len;
1499         static const char table_str[][5] = { "CDD",
1500                                              "STBC",
1501                                              "TXBF" };
1502         static const char pream_str[][6] = { "CCK",
1503                                              "OFDM",
1504                                              "HT20",
1505                                              "HT40",
1506                                              "VHT20",
1507                                              "VHT40",
1508                                              "VHT80",
1509                                              "HTCUP" };
1510
1511         buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1512         *len += scnprintf(buf + *len, buf_len - *len,
1513                           "********************************\n");
1514         *len += scnprintf(buf + *len, buf_len - *len,
1515                           "******************* %s POWER TABLE ****************\n",
1516                           table_str[j]);
1517         *len += scnprintf(buf + *len, buf_len - *len,
1518                           "********************************\n");
1519         *len += scnprintf(buf + *len, buf_len - *len,
1520                           "No.  Preamble Rate_code ");
1521
1522         for (i = 0; i < tpc_stats->num_tx_chain; i++)
1523                 *len += scnprintf(buf + *len, buf_len - *len,
1524                                   "tpc_value%d ", i);
1525
1526         *len += scnprintf(buf + *len, buf_len - *len, "\n");
1527
1528         for (i = 0; i < tpc_stats->rate_max; i++) {
1529                 *len += scnprintf(buf + *len, buf_len - *len,
1530                                   "%8d %s 0x%2x %s\n", i,
1531                                   pream_str[tpc_stats->tpc_table[j].pream_idx[i]],
1532                                   tpc_stats->tpc_table[j].rate_code[i],
1533                                   tpc_stats->tpc_table[j].tpc_value[i]);
1534         }
1535
1536         *len += scnprintf(buf + *len, buf_len - *len,
1537                           "***********************************\n");
1538 }
1539
1540 static void ath10k_tpc_stats_fill(struct ath10k *ar,
1541                                   struct ath10k_tpc_stats *tpc_stats,
1542                                   char *buf)
1543 {
1544         int j;
1545         size_t len, buf_len;
1546
1547         len = 0;
1548         buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1549
1550         spin_lock_bh(&ar->data_lock);
1551
1552         if (!tpc_stats) {
1553                 ath10k_warn(ar, "failed to get tpc stats\n");
1554                 goto unlock;
1555         }
1556
1557         len += scnprintf(buf + len, buf_len - len, "\n");
1558         len += scnprintf(buf + len, buf_len - len,
1559                          "*************************************\n");
1560         len += scnprintf(buf + len, buf_len - len,
1561                          "TPC config for channel %4d mode %d\n",
1562                          tpc_stats->chan_freq,
1563                          tpc_stats->phy_mode);
1564         len += scnprintf(buf + len, buf_len - len,
1565                          "*************************************\n");
1566         len += scnprintf(buf + len, buf_len - len,
1567                          "CTL           =  0x%2x Reg. Domain            = %2d\n",
1568                          tpc_stats->ctl,
1569                          tpc_stats->reg_domain);
1570         len += scnprintf(buf + len, buf_len - len,
1571                          "Antenna Gain  = %2d Reg. Max Antenna Gain     =  %2d\n",
1572                          tpc_stats->twice_antenna_gain,
1573                          tpc_stats->twice_antenna_reduction);
1574         len += scnprintf(buf + len, buf_len - len,
1575                          "Power Limit   = %2d Reg. Max Power            = %2d\n",
1576                          tpc_stats->power_limit,
1577                          tpc_stats->twice_max_rd_power / 2);
1578         len += scnprintf(buf + len, buf_len - len,
1579                          "Num tx chains = %2d Num supported rates       = %2d\n",
1580                          tpc_stats->num_tx_chain,
1581                          tpc_stats->rate_max);
1582
1583         for (j = 0; j < WMI_TPC_FLAG; j++) {
1584                 switch (j) {
1585                 case WMI_TPC_TABLE_TYPE_CDD:
1586                         if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1587                                 len += scnprintf(buf + len, buf_len - len,
1588                                                  "CDD not supported\n");
1589                                 break;
1590                         }
1591
1592                         ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1593                         break;
1594                 case WMI_TPC_TABLE_TYPE_STBC:
1595                         if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1596                                 len += scnprintf(buf + len, buf_len - len,
1597                                                  "STBC not supported\n");
1598                                 break;
1599                         }
1600
1601                         ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1602                         break;
1603                 case WMI_TPC_TABLE_TYPE_TXBF:
1604                         if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1605                                 len += scnprintf(buf + len, buf_len - len,
1606                                                  "TXBF not supported\n***************************\n");
1607                                 break;
1608                         }
1609
1610                         ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1611                         break;
1612                 default:
1613                         len += scnprintf(buf + len, buf_len - len,
1614                                          "Invalid Type\n");
1615                         break;
1616                 }
1617         }
1618
1619 unlock:
1620         spin_unlock_bh(&ar->data_lock);
1621
1622         if (len >= buf_len)
1623                 buf[len - 1] = 0;
1624         else
1625                 buf[len] = 0;
1626 }
1627
1628 static int ath10k_tpc_stats_open(struct inode *inode, struct file *file)
1629 {
1630         struct ath10k *ar = inode->i_private;
1631         void *buf = NULL;
1632         int ret;
1633
1634         mutex_lock(&ar->conf_mutex);
1635
1636         if (ar->state != ATH10K_STATE_ON) {
1637                 ret = -ENETDOWN;
1638                 goto err_unlock;
1639         }
1640
1641         buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
1642         if (!buf) {
1643                 ret = -ENOMEM;
1644                 goto err_unlock;
1645         }
1646
1647         ret = ath10k_debug_tpc_stats_request(ar);
1648         if (ret) {
1649                 ath10k_warn(ar, "failed to request tpc config stats: %d\n",
1650                             ret);
1651                 goto err_free;
1652         }
1653
1654         ath10k_tpc_stats_fill(ar, ar->debug.tpc_stats, buf);
1655         file->private_data = buf;
1656
1657         mutex_unlock(&ar->conf_mutex);
1658         return 0;
1659
1660 err_free:
1661         vfree(buf);
1662
1663 err_unlock:
1664         mutex_unlock(&ar->conf_mutex);
1665         return ret;
1666 }
1667
1668 static int ath10k_tpc_stats_release(struct inode *inode, struct file *file)
1669 {
1670         vfree(file->private_data);
1671
1672         return 0;
1673 }
1674
1675 static ssize_t ath10k_tpc_stats_read(struct file *file, char __user *user_buf,
1676                                      size_t count, loff_t *ppos)
1677 {
1678         const char *buf = file->private_data;
1679         size_t len = strlen(buf);
1680
1681         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1682 }
1683
1684 static const struct file_operations fops_tpc_stats = {
1685         .open = ath10k_tpc_stats_open,
1686         .release = ath10k_tpc_stats_release,
1687         .read = ath10k_tpc_stats_read,
1688         .owner = THIS_MODULE,
1689         .llseek = default_llseek,
1690 };
1691
1692 int ath10k_debug_start(struct ath10k *ar)
1693 {
1694         int ret;
1695
1696         lockdep_assert_held(&ar->conf_mutex);
1697
1698         ret = ath10k_debug_htt_stats_req(ar);
1699         if (ret)
1700                 /* continue normally anyway, this isn't serious */
1701                 ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1702                             ret);
1703
1704         if (ar->debug.fw_dbglog_mask) {
1705                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1706                                             ATH10K_DBGLOG_LEVEL_WARN);
1707                 if (ret)
1708                         /* not serious */
1709                         ath10k_warn(ar, "failed to enable dbglog during start: %d",
1710                                     ret);
1711         }
1712
1713         if (ar->pktlog_filter) {
1714                 ret = ath10k_wmi_pdev_pktlog_enable(ar,
1715                                                     ar->pktlog_filter);
1716                 if (ret)
1717                         /* not serious */
1718                         ath10k_warn(ar,
1719                                     "failed to enable pktlog filter %x: %d\n",
1720                                     ar->pktlog_filter, ret);
1721         } else {
1722                 ret = ath10k_wmi_pdev_pktlog_disable(ar);
1723                 if (ret)
1724                         /* not serious */
1725                         ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1726         }
1727
1728         if (ar->debug.nf_cal_period &&
1729             !test_bit(ATH10K_FW_FEATURE_NON_BMI,
1730                       ar->normal_mode_fw.fw_file.fw_features)) {
1731                 ret = ath10k_wmi_pdev_set_param(ar,
1732                                                 ar->wmi.pdev_param->cal_period,
1733                                                 ar->debug.nf_cal_period);
1734                 if (ret)
1735                         /* not serious */
1736                         ath10k_warn(ar, "cal period cfg failed from debug start: %d\n",
1737                                     ret);
1738         }
1739
1740         return ret;
1741 }
1742
1743 void ath10k_debug_stop(struct ath10k *ar)
1744 {
1745         lockdep_assert_held(&ar->conf_mutex);
1746
1747         if (!test_bit(ATH10K_FW_FEATURE_NON_BMI,
1748                       ar->normal_mode_fw.fw_file.fw_features))
1749                 ath10k_debug_cal_data_fetch(ar);
1750
1751         /* Must not use _sync to avoid deadlock, we do that in
1752          * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1753          * warning from del_timer().
1754          */
1755         if (ar->debug.htt_stats_mask != 0)
1756                 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1757
1758         ath10k_wmi_pdev_pktlog_disable(ar);
1759 }
1760
1761 static ssize_t ath10k_write_simulate_radar(struct file *file,
1762                                            const char __user *user_buf,
1763                                            size_t count, loff_t *ppos)
1764 {
1765         struct ath10k *ar = file->private_data;
1766         struct ath10k_vif *arvif;
1767
1768         /* Just check for the first vif alone, as all the vifs will be
1769          * sharing the same channel and if the channel is disabled, all the
1770          * vifs will share the same 'is_started' state.
1771          */
1772         arvif = list_first_entry(&ar->arvifs, typeof(*arvif), list);
1773         if (!arvif->is_started)
1774                 return -EINVAL;
1775
1776         ieee80211_radar_detected(ar->hw);
1777
1778         return count;
1779 }
1780
1781 static const struct file_operations fops_simulate_radar = {
1782         .write = ath10k_write_simulate_radar,
1783         .open = simple_open,
1784         .owner = THIS_MODULE,
1785         .llseek = default_llseek,
1786 };
1787
1788 #define ATH10K_DFS_STAT(s, p) (\
1789         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1790                          ar->debug.dfs_stats.p))
1791
1792 #define ATH10K_DFS_POOL_STAT(s, p) (\
1793         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1794                          ar->debug.dfs_pool_stats.p))
1795
1796 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1797                                      size_t count, loff_t *ppos)
1798 {
1799         int retval = 0, len = 0;
1800         const int size = 8000;
1801         struct ath10k *ar = file->private_data;
1802         char *buf;
1803
1804         buf = kzalloc(size, GFP_KERNEL);
1805         if (buf == NULL)
1806                 return -ENOMEM;
1807
1808         if (!ar->dfs_detector) {
1809                 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1810                 goto exit;
1811         }
1812
1813         ar->debug.dfs_pool_stats =
1814                         ar->dfs_detector->get_stats(ar->dfs_detector);
1815
1816         len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1817
1818         ATH10K_DFS_STAT("reported phy errors", phy_errors);
1819         ATH10K_DFS_STAT("pulse events reported", pulses_total);
1820         ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1821         ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1822         ATH10K_DFS_STAT("Radars detected", radar_detected);
1823
1824         len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1825         ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1826         ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1827         ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1828         ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1829         ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1830         ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1831         ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1832
1833 exit:
1834         if (len > size)
1835                 len = size;
1836
1837         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1838         kfree(buf);
1839
1840         return retval;
1841 }
1842
1843 static const struct file_operations fops_dfs_stats = {
1844         .read = ath10k_read_dfs_stats,
1845         .open = simple_open,
1846         .owner = THIS_MODULE,
1847         .llseek = default_llseek,
1848 };
1849
1850 static ssize_t ath10k_write_pktlog_filter(struct file *file,
1851                                           const char __user *ubuf,
1852                                           size_t count, loff_t *ppos)
1853 {
1854         struct ath10k *ar = file->private_data;
1855         u32 filter;
1856         int ret;
1857
1858         if (kstrtouint_from_user(ubuf, count, 0, &filter))
1859                 return -EINVAL;
1860
1861         mutex_lock(&ar->conf_mutex);
1862
1863         if (ar->state != ATH10K_STATE_ON) {
1864                 ar->pktlog_filter = filter;
1865                 ret = count;
1866                 goto out;
1867         }
1868
1869         if (filter == ar->pktlog_filter) {
1870                 ret = count;
1871                 goto out;
1872         }
1873
1874         if (filter) {
1875                 ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
1876                 if (ret) {
1877                         ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
1878                                     ar->pktlog_filter, ret);
1879                         goto out;
1880                 }
1881         } else {
1882                 ret = ath10k_wmi_pdev_pktlog_disable(ar);
1883                 if (ret) {
1884                         ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1885                         goto out;
1886                 }
1887         }
1888
1889         ar->pktlog_filter = filter;
1890         ret = count;
1891
1892 out:
1893         mutex_unlock(&ar->conf_mutex);
1894         return ret;
1895 }
1896
1897 static ssize_t ath10k_read_pktlog_filter(struct file *file, char __user *ubuf,
1898                                          size_t count, loff_t *ppos)
1899 {
1900         char buf[32];
1901         struct ath10k *ar = file->private_data;
1902         int len = 0;
1903
1904         mutex_lock(&ar->conf_mutex);
1905         len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
1906                         ar->pktlog_filter);
1907         mutex_unlock(&ar->conf_mutex);
1908
1909         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
1910 }
1911
1912 static const struct file_operations fops_pktlog_filter = {
1913         .read = ath10k_read_pktlog_filter,
1914         .write = ath10k_write_pktlog_filter,
1915         .open = simple_open
1916 };
1917
1918 static ssize_t ath10k_write_quiet_period(struct file *file,
1919                                          const char __user *ubuf,
1920                                          size_t count, loff_t *ppos)
1921 {
1922         struct ath10k *ar = file->private_data;
1923         u32 period;
1924
1925         if (kstrtouint_from_user(ubuf, count, 0, &period))
1926                 return -EINVAL;
1927
1928         if (period < ATH10K_QUIET_PERIOD_MIN) {
1929                 ath10k_warn(ar, "Quiet period %u can not be lesser than 25ms\n",
1930                             period);
1931                 return -EINVAL;
1932         }
1933         mutex_lock(&ar->conf_mutex);
1934         ar->thermal.quiet_period = period;
1935         ath10k_thermal_set_throttling(ar);
1936         mutex_unlock(&ar->conf_mutex);
1937
1938         return count;
1939 }
1940
1941 static ssize_t ath10k_read_quiet_period(struct file *file, char __user *ubuf,
1942                                         size_t count, loff_t *ppos)
1943 {
1944         char buf[32];
1945         struct ath10k *ar = file->private_data;
1946         int len = 0;
1947
1948         mutex_lock(&ar->conf_mutex);
1949         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
1950                         ar->thermal.quiet_period);
1951         mutex_unlock(&ar->conf_mutex);
1952
1953         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
1954 }
1955
1956 static const struct file_operations fops_quiet_period = {
1957         .read = ath10k_read_quiet_period,
1958         .write = ath10k_write_quiet_period,
1959         .open = simple_open
1960 };
1961
1962 static ssize_t ath10k_write_btcoex(struct file *file,
1963                                    const char __user *ubuf,
1964                                    size_t count, loff_t *ppos)
1965 {
1966         struct ath10k *ar = file->private_data;
1967         char buf[32];
1968         size_t buf_size;
1969         int ret;
1970         bool val;
1971         u32 pdev_param;
1972
1973         buf_size = min(count, (sizeof(buf) - 1));
1974         if (copy_from_user(buf, ubuf, buf_size))
1975                 return -EFAULT;
1976
1977         buf[buf_size] = '\0';
1978
1979         if (kstrtobool(buf, &val) != 0)
1980                 return -EINVAL;
1981
1982         if (!ar->coex_support)
1983                 return -EOPNOTSUPP;
1984
1985         mutex_lock(&ar->conf_mutex);
1986
1987         if (ar->state != ATH10K_STATE_ON &&
1988             ar->state != ATH10K_STATE_RESTARTED) {
1989                 ret = -ENETDOWN;
1990                 goto exit;
1991         }
1992
1993         if (!(test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags) ^ val)) {
1994                 ret = count;
1995                 goto exit;
1996         }
1997
1998         pdev_param = ar->wmi.pdev_param->enable_btcoex;
1999         if (test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
2000                      ar->running_fw->fw_file.fw_features)) {
2001                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, val);
2002                 if (ret) {
2003                         ath10k_warn(ar, "failed to enable btcoex: %d\n", ret);
2004                         ret = count;
2005                         goto exit;
2006                 }
2007         } else {
2008                 ath10k_info(ar, "restarting firmware due to btcoex change");
2009                 ath10k_core_start_recovery(ar);
2010         }
2011
2012         if (val)
2013                 set_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2014         else
2015                 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2016
2017         ret = count;
2018
2019 exit:
2020         mutex_unlock(&ar->conf_mutex);
2021
2022         return ret;
2023 }
2024
2025 static ssize_t ath10k_read_btcoex(struct file *file, char __user *ubuf,
2026                                   size_t count, loff_t *ppos)
2027 {
2028         char buf[32];
2029         struct ath10k *ar = file->private_data;
2030         int len = 0;
2031
2032         mutex_lock(&ar->conf_mutex);
2033         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2034                         test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags));
2035         mutex_unlock(&ar->conf_mutex);
2036
2037         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2038 }
2039
2040 static const struct file_operations fops_btcoex = {
2041         .read = ath10k_read_btcoex,
2042         .write = ath10k_write_btcoex,
2043         .open = simple_open
2044 };
2045
2046 static ssize_t ath10k_write_enable_extd_tx_stats(struct file *file,
2047                                                  const char __user *ubuf,
2048                                                  size_t count, loff_t *ppos)
2049 {
2050         struct ath10k *ar = file->private_data;
2051         u32 filter;
2052         int ret;
2053
2054         if (kstrtouint_from_user(ubuf, count, 0, &filter))
2055                 return -EINVAL;
2056
2057         mutex_lock(&ar->conf_mutex);
2058
2059         if (ar->state != ATH10K_STATE_ON) {
2060                 ar->debug.enable_extd_tx_stats = filter;
2061                 ret = count;
2062                 goto out;
2063         }
2064
2065         if (filter == ar->debug.enable_extd_tx_stats) {
2066                 ret = count;
2067                 goto out;
2068         }
2069
2070         ar->debug.enable_extd_tx_stats = filter;
2071         ret = count;
2072
2073 out:
2074         mutex_unlock(&ar->conf_mutex);
2075         return ret;
2076 }
2077
2078 static ssize_t ath10k_read_enable_extd_tx_stats(struct file *file,
2079                                                 char __user *ubuf,
2080                                                 size_t count, loff_t *ppos)
2081
2082 {
2083         char buf[32];
2084         struct ath10k *ar = file->private_data;
2085         int len = 0;
2086
2087         mutex_lock(&ar->conf_mutex);
2088         len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
2089                         ar->debug.enable_extd_tx_stats);
2090         mutex_unlock(&ar->conf_mutex);
2091
2092         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2093 }
2094
2095 static const struct file_operations fops_enable_extd_tx_stats = {
2096         .read = ath10k_read_enable_extd_tx_stats,
2097         .write = ath10k_write_enable_extd_tx_stats,
2098         .open = simple_open
2099 };
2100
2101 static ssize_t ath10k_write_peer_stats(struct file *file,
2102                                        const char __user *ubuf,
2103                                        size_t count, loff_t *ppos)
2104 {
2105         struct ath10k *ar = file->private_data;
2106         char buf[32];
2107         size_t buf_size;
2108         int ret;
2109         bool val;
2110
2111         buf_size = min(count, (sizeof(buf) - 1));
2112         if (copy_from_user(buf, ubuf, buf_size))
2113                 return -EFAULT;
2114
2115         buf[buf_size] = '\0';
2116
2117         if (kstrtobool(buf, &val) != 0)
2118                 return -EINVAL;
2119
2120         mutex_lock(&ar->conf_mutex);
2121
2122         if (ar->state != ATH10K_STATE_ON &&
2123             ar->state != ATH10K_STATE_RESTARTED) {
2124                 ret = -ENETDOWN;
2125                 goto exit;
2126         }
2127
2128         if (!(test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) ^ val)) {
2129                 ret = count;
2130                 goto exit;
2131         }
2132
2133         if (val)
2134                 set_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2135         else
2136                 clear_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2137
2138         ath10k_info(ar, "restarting firmware due to Peer stats change");
2139
2140         ath10k_core_start_recovery(ar);
2141         ret = count;
2142
2143 exit:
2144         mutex_unlock(&ar->conf_mutex);
2145         return ret;
2146 }
2147
2148 static ssize_t ath10k_read_peer_stats(struct file *file, char __user *ubuf,
2149                                       size_t count, loff_t *ppos)
2150
2151 {
2152         char buf[32];
2153         struct ath10k *ar = file->private_data;
2154         int len = 0;
2155
2156         mutex_lock(&ar->conf_mutex);
2157         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2158                         test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags));
2159         mutex_unlock(&ar->conf_mutex);
2160
2161         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2162 }
2163
2164 static const struct file_operations fops_peer_stats = {
2165         .read = ath10k_read_peer_stats,
2166         .write = ath10k_write_peer_stats,
2167         .open = simple_open
2168 };
2169
2170 static ssize_t ath10k_debug_fw_checksums_read(struct file *file,
2171                                               char __user *user_buf,
2172                                               size_t count, loff_t *ppos)
2173 {
2174         struct ath10k *ar = file->private_data;
2175         size_t len = 0, buf_len = 4096;
2176         ssize_t ret_cnt;
2177         char *buf;
2178
2179         buf = kzalloc(buf_len, GFP_KERNEL);
2180         if (!buf)
2181                 return -ENOMEM;
2182
2183         mutex_lock(&ar->conf_mutex);
2184
2185         len += scnprintf(buf + len, buf_len - len,
2186                          "firmware-N.bin\t\t%08x\n",
2187                          crc32_le(0, ar->normal_mode_fw.fw_file.firmware->data,
2188                                   ar->normal_mode_fw.fw_file.firmware->size));
2189         len += scnprintf(buf + len, buf_len - len,
2190                          "athwlan\t\t\t%08x\n",
2191                          crc32_le(0, ar->normal_mode_fw.fw_file.firmware_data,
2192                                   ar->normal_mode_fw.fw_file.firmware_len));
2193         len += scnprintf(buf + len, buf_len - len,
2194                          "otp\t\t\t%08x\n",
2195                          crc32_le(0, ar->normal_mode_fw.fw_file.otp_data,
2196                                   ar->normal_mode_fw.fw_file.otp_len));
2197         len += scnprintf(buf + len, buf_len - len,
2198                          "codeswap\t\t%08x\n",
2199                          crc32_le(0, ar->normal_mode_fw.fw_file.codeswap_data,
2200                                   ar->normal_mode_fw.fw_file.codeswap_len));
2201         len += scnprintf(buf + len, buf_len - len,
2202                          "board-N.bin\t\t%08x\n",
2203                          crc32_le(0, ar->normal_mode_fw.board->data,
2204                                   ar->normal_mode_fw.board->size));
2205         len += scnprintf(buf + len, buf_len - len,
2206                          "board\t\t\t%08x\n",
2207                          crc32_le(0, ar->normal_mode_fw.board_data,
2208                                   ar->normal_mode_fw.board_len));
2209
2210         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
2211
2212         mutex_unlock(&ar->conf_mutex);
2213
2214         kfree(buf);
2215         return ret_cnt;
2216 }
2217
2218 static const struct file_operations fops_fw_checksums = {
2219         .read = ath10k_debug_fw_checksums_read,
2220         .open = simple_open,
2221         .owner = THIS_MODULE,
2222         .llseek = default_llseek,
2223 };
2224
2225 static ssize_t ath10k_sta_tid_stats_mask_read(struct file *file,
2226                                               char __user *user_buf,
2227                                               size_t count, loff_t *ppos)
2228 {
2229         struct ath10k *ar = file->private_data;
2230         char buf[32];
2231         size_t len;
2232
2233         len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->sta_tid_stats_mask);
2234         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
2235 }
2236
2237 static ssize_t ath10k_sta_tid_stats_mask_write(struct file *file,
2238                                                const char __user *user_buf,
2239                                                size_t count, loff_t *ppos)
2240 {
2241         struct ath10k *ar = file->private_data;
2242         char buf[32];
2243         ssize_t len;
2244         u32 mask;
2245
2246         len = min(count, sizeof(buf) - 1);
2247         if (copy_from_user(buf, user_buf, len))
2248                 return -EFAULT;
2249
2250         buf[len] = '\0';
2251         if (kstrtoint(buf, 0, &mask))
2252                 return -EINVAL;
2253
2254         ar->sta_tid_stats_mask = mask;
2255
2256         return len;
2257 }
2258
2259 static const struct file_operations fops_sta_tid_stats_mask = {
2260         .read = ath10k_sta_tid_stats_mask_read,
2261         .write = ath10k_sta_tid_stats_mask_write,
2262         .open = simple_open,
2263         .owner = THIS_MODULE,
2264         .llseek = default_llseek,
2265 };
2266
2267 static int ath10k_debug_tpc_stats_final_request(struct ath10k *ar)
2268 {
2269         int ret;
2270         unsigned long time_left;
2271
2272         lockdep_assert_held(&ar->conf_mutex);
2273
2274         reinit_completion(&ar->debug.tpc_complete);
2275
2276         ret = ath10k_wmi_pdev_get_tpc_table_cmdid(ar, WMI_TPC_CONFIG_PARAM);
2277         if (ret) {
2278                 ath10k_warn(ar, "failed to request tpc table cmdid: %d\n", ret);
2279                 return ret;
2280         }
2281
2282         time_left = wait_for_completion_timeout(&ar->debug.tpc_complete,
2283                                                 1 * HZ);
2284         if (time_left == 0)
2285                 return -ETIMEDOUT;
2286
2287         return 0;
2288 }
2289
2290 static int ath10k_tpc_stats_final_open(struct inode *inode, struct file *file)
2291 {
2292         struct ath10k *ar = inode->i_private;
2293         void *buf;
2294         int ret;
2295
2296         mutex_lock(&ar->conf_mutex);
2297
2298         if (ar->state != ATH10K_STATE_ON) {
2299                 ret = -ENETDOWN;
2300                 goto err_unlock;
2301         }
2302
2303         buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
2304         if (!buf) {
2305                 ret = -ENOMEM;
2306                 goto err_unlock;
2307         }
2308
2309         ret = ath10k_debug_tpc_stats_final_request(ar);
2310         if (ret) {
2311                 ath10k_warn(ar, "failed to request tpc stats final: %d\n",
2312                             ret);
2313                 goto err_free;
2314         }
2315
2316         ath10k_tpc_stats_fill(ar, ar->debug.tpc_stats, buf);
2317         file->private_data = buf;
2318
2319         mutex_unlock(&ar->conf_mutex);
2320         return 0;
2321
2322 err_free:
2323         vfree(buf);
2324
2325 err_unlock:
2326         mutex_unlock(&ar->conf_mutex);
2327         return ret;
2328 }
2329
2330 static int ath10k_tpc_stats_final_release(struct inode *inode,
2331                                           struct file *file)
2332 {
2333         vfree(file->private_data);
2334
2335         return 0;
2336 }
2337
2338 static ssize_t ath10k_tpc_stats_final_read(struct file *file,
2339                                            char __user *user_buf,
2340                                            size_t count, loff_t *ppos)
2341 {
2342         const char *buf = file->private_data;
2343         unsigned int len = strlen(buf);
2344
2345         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
2346 }
2347
2348 static const struct file_operations fops_tpc_stats_final = {
2349         .open = ath10k_tpc_stats_final_open,
2350         .release = ath10k_tpc_stats_final_release,
2351         .read = ath10k_tpc_stats_final_read,
2352         .owner = THIS_MODULE,
2353         .llseek = default_llseek,
2354 };
2355
2356 static ssize_t ath10k_write_warm_hw_reset(struct file *file,
2357                                           const char __user *user_buf,
2358                                           size_t count, loff_t *ppos)
2359 {
2360         struct ath10k *ar = file->private_data;
2361         int ret;
2362         bool val;
2363
2364         if (kstrtobool_from_user(user_buf, count, &val))
2365                 return -EFAULT;
2366
2367         if (!val)
2368                 return -EINVAL;
2369
2370         mutex_lock(&ar->conf_mutex);
2371
2372         if (ar->state != ATH10K_STATE_ON) {
2373                 ret = -ENETDOWN;
2374                 goto exit;
2375         }
2376
2377         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pdev_reset,
2378                                         WMI_RST_MODE_WARM_RESET);
2379
2380         if (ret) {
2381                 ath10k_warn(ar, "failed to enable warm hw reset: %d\n", ret);
2382                 goto exit;
2383         }
2384
2385         ret = count;
2386
2387 exit:
2388         mutex_unlock(&ar->conf_mutex);
2389         return ret;
2390 }
2391
2392 static const struct file_operations fops_warm_hw_reset = {
2393         .write = ath10k_write_warm_hw_reset,
2394         .open = simple_open,
2395         .owner = THIS_MODULE,
2396         .llseek = default_llseek,
2397 };
2398
2399 static void ath10k_peer_ps_state_disable(void *data,
2400                                          struct ieee80211_sta *sta)
2401 {
2402         struct ath10k *ar = data;
2403         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
2404
2405         spin_lock_bh(&ar->data_lock);
2406         arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
2407         spin_unlock_bh(&ar->data_lock);
2408 }
2409
2410 static ssize_t ath10k_write_ps_state_enable(struct file *file,
2411                                             const char __user *user_buf,
2412                                             size_t count, loff_t *ppos)
2413 {
2414         struct ath10k *ar = file->private_data;
2415         int ret;
2416         u32 param;
2417         u8 ps_state_enable;
2418
2419         if (kstrtou8_from_user(user_buf, count, 0, &ps_state_enable))
2420                 return -EINVAL;
2421
2422         if (ps_state_enable > 1)
2423                 return -EINVAL;
2424
2425         mutex_lock(&ar->conf_mutex);
2426
2427         if (ar->ps_state_enable == ps_state_enable) {
2428                 ret = count;
2429                 goto exit;
2430         }
2431
2432         param = ar->wmi.pdev_param->peer_sta_ps_statechg_enable;
2433         ret = ath10k_wmi_pdev_set_param(ar, param, ps_state_enable);
2434         if (ret) {
2435                 ath10k_warn(ar, "failed to enable ps_state_enable: %d\n",
2436                             ret);
2437                 goto exit;
2438         }
2439         ar->ps_state_enable = ps_state_enable;
2440
2441         if (!ar->ps_state_enable)
2442                 ieee80211_iterate_stations_atomic(ar->hw,
2443                                                   ath10k_peer_ps_state_disable,
2444                                                   ar);
2445
2446         ret = count;
2447
2448 exit:
2449         mutex_unlock(&ar->conf_mutex);
2450
2451         return ret;
2452 }
2453
2454 static ssize_t ath10k_read_ps_state_enable(struct file *file,
2455                                            char __user *user_buf,
2456                                            size_t count, loff_t *ppos)
2457 {
2458         struct ath10k *ar = file->private_data;
2459         int len = 0;
2460         char buf[32];
2461
2462         mutex_lock(&ar->conf_mutex);
2463         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2464                         ar->ps_state_enable);
2465         mutex_unlock(&ar->conf_mutex);
2466
2467         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
2468 }
2469
2470 static const struct file_operations fops_ps_state_enable = {
2471         .read = ath10k_read_ps_state_enable,
2472         .write = ath10k_write_ps_state_enable,
2473         .open = simple_open,
2474         .owner = THIS_MODULE,
2475         .llseek = default_llseek,
2476 };
2477
2478 static ssize_t ath10k_write_reset_htt_stats(struct file *file,
2479                                             const char __user *user_buf,
2480                                             size_t count, loff_t *ppos)
2481 {
2482         struct ath10k *ar = file->private_data;
2483         unsigned long reset;
2484         int ret;
2485
2486         ret = kstrtoul_from_user(user_buf, count, 0, &reset);
2487         if (ret)
2488                 return ret;
2489
2490         if (reset == 0 || reset > 0x1ffff)
2491                 return -EINVAL;
2492
2493         mutex_lock(&ar->conf_mutex);
2494
2495         ar->debug.reset_htt_stats = reset;
2496
2497         ret = ath10k_debug_htt_stats_req(ar);
2498         if (ret)
2499                 goto out;
2500
2501         ar->debug.reset_htt_stats = 0;
2502         ret = count;
2503
2504 out:
2505         mutex_unlock(&ar->conf_mutex);
2506         return ret;
2507 }
2508
2509 static const struct file_operations fops_reset_htt_stats = {
2510         .write = ath10k_write_reset_htt_stats,
2511         .owner = THIS_MODULE,
2512         .open = simple_open,
2513         .llseek = default_llseek,
2514 };
2515
2516 int ath10k_debug_create(struct ath10k *ar)
2517 {
2518         ar->debug.cal_data = vzalloc(ATH10K_DEBUG_CAL_DATA_LEN);
2519         if (!ar->debug.cal_data)
2520                 return -ENOMEM;
2521
2522         INIT_LIST_HEAD(&ar->debug.fw_stats.pdevs);
2523         INIT_LIST_HEAD(&ar->debug.fw_stats.vdevs);
2524         INIT_LIST_HEAD(&ar->debug.fw_stats.peers);
2525         INIT_LIST_HEAD(&ar->debug.fw_stats.peers_extd);
2526
2527         return 0;
2528 }
2529
2530 void ath10k_debug_destroy(struct ath10k *ar)
2531 {
2532         vfree(ar->debug.cal_data);
2533         ar->debug.cal_data = NULL;
2534
2535         ath10k_debug_fw_stats_reset(ar);
2536
2537         kfree(ar->debug.tpc_stats);
2538         kfree(ar->debug.tpc_stats_final);
2539 }
2540
2541 int ath10k_debug_register(struct ath10k *ar)
2542 {
2543         ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
2544                                                    ar->hw->wiphy->debugfsdir);
2545         if (IS_ERR_OR_NULL(ar->debug.debugfs_phy)) {
2546                 if (IS_ERR(ar->debug.debugfs_phy))
2547                         return PTR_ERR(ar->debug.debugfs_phy);
2548
2549                 return -ENOMEM;
2550         }
2551
2552         INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
2553                           ath10k_debug_htt_stats_dwork);
2554
2555         init_completion(&ar->debug.tpc_complete);
2556         init_completion(&ar->debug.fw_stats_complete);
2557
2558         debugfs_create_file("fw_stats", 0400, ar->debug.debugfs_phy, ar,
2559                             &fops_fw_stats);
2560
2561         debugfs_create_file("fw_reset_stats", 0400, ar->debug.debugfs_phy, ar,
2562                             &fops_fw_reset_stats);
2563
2564         debugfs_create_file("wmi_services", 0400, ar->debug.debugfs_phy, ar,
2565                             &fops_wmi_services);
2566
2567         debugfs_create_file("simulate_fw_crash", 0600, ar->debug.debugfs_phy, ar,
2568                             &fops_simulate_fw_crash);
2569
2570         debugfs_create_file("reg_addr", 0600, ar->debug.debugfs_phy, ar,
2571                             &fops_reg_addr);
2572
2573         debugfs_create_file("reg_value", 0600, ar->debug.debugfs_phy, ar,
2574                             &fops_reg_value);
2575
2576         debugfs_create_file("mem_value", 0600, ar->debug.debugfs_phy, ar,
2577                             &fops_mem_value);
2578
2579         debugfs_create_file("chip_id", 0400, ar->debug.debugfs_phy, ar,
2580                             &fops_chip_id);
2581
2582         debugfs_create_file("htt_stats_mask", 0600, ar->debug.debugfs_phy, ar,
2583                             &fops_htt_stats_mask);
2584
2585         debugfs_create_file("htt_max_amsdu_ampdu", 0600, ar->debug.debugfs_phy, ar,
2586                             &fops_htt_max_amsdu_ampdu);
2587
2588         debugfs_create_file("fw_dbglog", 0600, ar->debug.debugfs_phy, ar,
2589                             &fops_fw_dbglog);
2590
2591         if (!test_bit(ATH10K_FW_FEATURE_NON_BMI,
2592                       ar->normal_mode_fw.fw_file.fw_features)) {
2593                 debugfs_create_file("cal_data", 0400, ar->debug.debugfs_phy, ar,
2594                                     &fops_cal_data);
2595
2596                 debugfs_create_file("nf_cal_period", 0600, ar->debug.debugfs_phy, ar,
2597                                     &fops_nf_cal_period);
2598         }
2599
2600         debugfs_create_file("ani_enable", 0600, ar->debug.debugfs_phy, ar,
2601                             &fops_ani_enable);
2602
2603         if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
2604                 debugfs_create_file("dfs_simulate_radar", 0200, ar->debug.debugfs_phy,
2605                                     ar, &fops_simulate_radar);
2606
2607                 debugfs_create_bool("dfs_block_radar_events", 0200,
2608                                     ar->debug.debugfs_phy,
2609                                     &ar->dfs_block_radar_events);
2610
2611                 debugfs_create_file("dfs_stats", 0400, ar->debug.debugfs_phy, ar,
2612                                     &fops_dfs_stats);
2613         }
2614
2615         debugfs_create_file("pktlog_filter", 0644, ar->debug.debugfs_phy, ar,
2616                             &fops_pktlog_filter);
2617
2618         if (test_bit(WMI_SERVICE_THERM_THROT, ar->wmi.svc_map))
2619                 debugfs_create_file("quiet_period", 0644, ar->debug.debugfs_phy, ar,
2620                                     &fops_quiet_period);
2621
2622         debugfs_create_file("tpc_stats", 0400, ar->debug.debugfs_phy, ar,
2623                             &fops_tpc_stats);
2624
2625         if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
2626                 debugfs_create_file("btcoex", 0644, ar->debug.debugfs_phy, ar,
2627                                     &fops_btcoex);
2628
2629         if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map)) {
2630                 debugfs_create_file("peer_stats", 0644, ar->debug.debugfs_phy, ar,
2631                                     &fops_peer_stats);
2632
2633                 debugfs_create_file("enable_extd_tx_stats", 0644,
2634                                     ar->debug.debugfs_phy, ar,
2635                                     &fops_enable_extd_tx_stats);
2636         }
2637
2638         debugfs_create_file("fw_checksums", 0400, ar->debug.debugfs_phy, ar,
2639                             &fops_fw_checksums);
2640
2641         if (IS_ENABLED(CONFIG_MAC80211_DEBUGFS))
2642                 debugfs_create_file("sta_tid_stats_mask", 0600,
2643                                     ar->debug.debugfs_phy,
2644                                     ar, &fops_sta_tid_stats_mask);
2645
2646         if (test_bit(WMI_SERVICE_TPC_STATS_FINAL, ar->wmi.svc_map))
2647                 debugfs_create_file("tpc_stats_final", 0400,
2648                                     ar->debug.debugfs_phy, ar,
2649                                     &fops_tpc_stats_final);
2650
2651         if (test_bit(WMI_SERVICE_RESET_CHIP, ar->wmi.svc_map))
2652                 debugfs_create_file("warm_hw_reset", 0600,
2653                                     ar->debug.debugfs_phy, ar,
2654                                     &fops_warm_hw_reset);
2655
2656         debugfs_create_file("ps_state_enable", 0600, ar->debug.debugfs_phy, ar,
2657                             &fops_ps_state_enable);
2658
2659         debugfs_create_file("reset_htt_stats", 0200, ar->debug.debugfs_phy, ar,
2660                             &fops_reset_htt_stats);
2661
2662         return 0;
2663 }
2664
2665 void ath10k_debug_unregister(struct ath10k *ar)
2666 {
2667         cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
2668 }
2669
2670 #endif /* CONFIG_ATH10K_DEBUGFS */
2671
2672 #ifdef CONFIG_ATH10K_DEBUG
2673 void __ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
2674                   const char *fmt, ...)
2675 {
2676         struct va_format vaf;
2677         va_list args;
2678
2679         va_start(args, fmt);
2680
2681         vaf.fmt = fmt;
2682         vaf.va = &args;
2683
2684         if (ath10k_debug_mask & mask)
2685                 dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
2686
2687         trace_ath10k_log_dbg(ar, mask, &vaf);
2688
2689         va_end(args);
2690 }
2691 EXPORT_SYMBOL(__ath10k_dbg);
2692
2693 void ath10k_dbg_dump(struct ath10k *ar,
2694                      enum ath10k_debug_mask mask,
2695                      const char *msg, const char *prefix,
2696                      const void *buf, size_t len)
2697 {
2698         char linebuf[256];
2699         size_t linebuflen;
2700         const void *ptr;
2701
2702         if (ath10k_debug_mask & mask) {
2703                 if (msg)
2704                         __ath10k_dbg(ar, mask, "%s\n", msg);
2705
2706                 for (ptr = buf; (ptr - buf) < len; ptr += 16) {
2707                         linebuflen = 0;
2708                         linebuflen += scnprintf(linebuf + linebuflen,
2709                                                 sizeof(linebuf) - linebuflen,
2710                                                 "%s%08x: ",
2711                                                 (prefix ? prefix : ""),
2712                                                 (unsigned int)(ptr - buf));
2713                         hex_dump_to_buffer(ptr, len - (ptr - buf), 16, 1,
2714                                            linebuf + linebuflen,
2715                                            sizeof(linebuf) - linebuflen, true);
2716                         dev_printk(KERN_DEBUG, ar->dev, "%s\n", linebuf);
2717                 }
2718         }
2719
2720         /* tracing code doesn't like null strings :/ */
2721         trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
2722                                   buf, len);
2723 }
2724 EXPORT_SYMBOL(ath10k_dbg_dump);
2725
2726 #endif /* CONFIG_ATH10K_DEBUG */