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