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

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