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                     config_enabled(CONFIG_ATH10K_DEBUG),
 143                     config_enabled(CONFIG_ATH10K_DEBUGFS),
 144                     config_enabled(CONFIG_ATH10K_TRACING),
 145                     config_enabled(CONFIG_ATH10K_DFS_CERTIFIED),
 146                     config_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[64];
1232
1233         len = scnprintf(buf, sizeof(buf), "0x%08x %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[64];
1246         unsigned int log_level, mask;
1247
1248         simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
1249
1250         /* make sure that buf is null terminated */
1251         buf[sizeof(buf) - 1] = 0;
1252
1253         ret = sscanf(buf, "%x %u", &mask, &log_level);
1254
1255         if (!ret)
1256                 return -EINVAL;
1257
1258         if (ret == 1)
1259                 /* default if user did not specify */
1260                 log_level = ATH10K_DBGLOG_LEVEL_WARN;
1261
1262         mutex_lock(&ar->conf_mutex);
1263
1264         ar->debug.fw_dbglog_mask = mask;
1265         ar->debug.fw_dbglog_level = log_level;
1266
1267         if (ar->state == ATH10K_STATE_ON) {
1268                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1269                                             ar->debug.fw_dbglog_level);
1270                 if (ret) {
1271                         ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1272                                     ret);
1273                         goto exit;
1274                 }
1275         }
1276
1277         ret = count;
1278
1279 exit:
1280         mutex_unlock(&ar->conf_mutex);
1281
1282         return ret;
1283 }
1284
1285 /* TODO:  Would be nice to always support ethtool stats, would need to
1286  * move the stats storage out of ath10k_debug, or always have ath10k_debug
1287  * struct available..
1288  */
1289
1290 /* This generally cooresponds to the debugfs fw_stats file */
1291 static const char ath10k_gstrings_stats[][ETH_GSTRING_LEN] = {
1292         "tx_pkts_nic",
1293         "tx_bytes_nic",
1294         "rx_pkts_nic",
1295         "rx_bytes_nic",
1296         "d_noise_floor",
1297         "d_cycle_count",
1298         "d_phy_error",
1299         "d_rts_bad",
1300         "d_rts_good",
1301         "d_tx_power", /* in .5 dbM I think */
1302         "d_rx_crc_err", /* fcs_bad */
1303         "d_no_beacon",
1304         "d_tx_mpdus_queued",
1305         "d_tx_msdu_queued",
1306         "d_tx_msdu_dropped",
1307         "d_local_enqued",
1308         "d_local_freed",
1309         "d_tx_ppdu_hw_queued",
1310         "d_tx_ppdu_reaped",
1311         "d_tx_fifo_underrun",
1312         "d_tx_ppdu_abort",
1313         "d_tx_mpdu_requed",
1314         "d_tx_excessive_retries",
1315         "d_tx_hw_rate",
1316         "d_tx_dropped_sw_retries",
1317         "d_tx_illegal_rate",
1318         "d_tx_continuous_xretries",
1319         "d_tx_timeout",
1320         "d_tx_mpdu_txop_limit",
1321         "d_pdev_resets",
1322         "d_rx_mid_ppdu_route_change",
1323         "d_rx_status",
1324         "d_rx_extra_frags_ring0",
1325         "d_rx_extra_frags_ring1",
1326         "d_rx_extra_frags_ring2",
1327         "d_rx_extra_frags_ring3",
1328         "d_rx_msdu_htt",
1329         "d_rx_mpdu_htt",
1330         "d_rx_msdu_stack",
1331         "d_rx_mpdu_stack",
1332         "d_rx_phy_err",
1333         "d_rx_phy_err_drops",
1334         "d_rx_mpdu_errors", /* FCS, MIC, ENC */
1335         "d_fw_crash_count",
1336         "d_fw_warm_reset_count",
1337         "d_fw_cold_reset_count",
1338 };
1339
1340 #define ATH10K_SSTATS_LEN ARRAY_SIZE(ath10k_gstrings_stats)
1341
1342 void ath10k_debug_get_et_strings(struct ieee80211_hw *hw,
1343                                  struct ieee80211_vif *vif,
1344                                  u32 sset, u8 *data)
1345 {
1346         if (sset == ETH_SS_STATS)
1347                 memcpy(data, *ath10k_gstrings_stats,
1348                        sizeof(ath10k_gstrings_stats));
1349 }
1350
1351 int ath10k_debug_get_et_sset_count(struct ieee80211_hw *hw,
1352                                    struct ieee80211_vif *vif, int sset)
1353 {
1354         if (sset == ETH_SS_STATS)
1355                 return ATH10K_SSTATS_LEN;
1356
1357         return 0;
1358 }
1359
1360 void ath10k_debug_get_et_stats(struct ieee80211_hw *hw,
1361                                struct ieee80211_vif *vif,
1362                                struct ethtool_stats *stats, u64 *data)
1363 {
1364         struct ath10k *ar = hw->priv;
1365         static const struct ath10k_fw_stats_pdev zero_stats = {};
1366         const struct ath10k_fw_stats_pdev *pdev_stats;
1367         int i = 0, ret;
1368
1369         mutex_lock(&ar->conf_mutex);
1370
1371         if (ar->state == ATH10K_STATE_ON) {
1372                 ret = ath10k_debug_fw_stats_request(ar);
1373                 if (ret) {
1374                         /* just print a warning and try to use older results */
1375                         ath10k_warn(ar,
1376                                     "failed to get fw stats for ethtool: %d\n",
1377                                     ret);
1378                 }
1379         }
1380
1381         pdev_stats = list_first_entry_or_null(&ar->debug.fw_stats.pdevs,
1382                                               struct ath10k_fw_stats_pdev,
1383                                               list);
1384         if (!pdev_stats) {
1385                 /* no results available so just return zeroes */
1386                 pdev_stats = &zero_stats;
1387         }
1388
1389         spin_lock_bh(&ar->data_lock);
1390
1391         data[i++] = pdev_stats->hw_reaped; /* ppdu reaped */
1392         data[i++] = 0; /* tx bytes */
1393         data[i++] = pdev_stats->htt_mpdus;
1394         data[i++] = 0; /* rx bytes */
1395         data[i++] = pdev_stats->ch_noise_floor;
1396         data[i++] = pdev_stats->cycle_count;
1397         data[i++] = pdev_stats->phy_err_count;
1398         data[i++] = pdev_stats->rts_bad;
1399         data[i++] = pdev_stats->rts_good;
1400         data[i++] = pdev_stats->chan_tx_power;
1401         data[i++] = pdev_stats->fcs_bad;
1402         data[i++] = pdev_stats->no_beacons;
1403         data[i++] = pdev_stats->mpdu_enqued;
1404         data[i++] = pdev_stats->msdu_enqued;
1405         data[i++] = pdev_stats->wmm_drop;
1406         data[i++] = pdev_stats->local_enqued;
1407         data[i++] = pdev_stats->local_freed;
1408         data[i++] = pdev_stats->hw_queued;
1409         data[i++] = pdev_stats->hw_reaped;
1410         data[i++] = pdev_stats->underrun;
1411         data[i++] = pdev_stats->tx_abort;
1412         data[i++] = pdev_stats->mpdus_requed;
1413         data[i++] = pdev_stats->tx_ko;
1414         data[i++] = pdev_stats->data_rc;
1415         data[i++] = pdev_stats->sw_retry_failure;
1416         data[i++] = pdev_stats->illgl_rate_phy_err;
1417         data[i++] = pdev_stats->pdev_cont_xretry;
1418         data[i++] = pdev_stats->pdev_tx_timeout;
1419         data[i++] = pdev_stats->txop_ovf;
1420         data[i++] = pdev_stats->pdev_resets;
1421         data[i++] = pdev_stats->mid_ppdu_route_change;
1422         data[i++] = pdev_stats->status_rcvd;
1423         data[i++] = pdev_stats->r0_frags;
1424         data[i++] = pdev_stats->r1_frags;
1425         data[i++] = pdev_stats->r2_frags;
1426         data[i++] = pdev_stats->r3_frags;
1427         data[i++] = pdev_stats->htt_msdus;
1428         data[i++] = pdev_stats->htt_mpdus;
1429         data[i++] = pdev_stats->loc_msdus;
1430         data[i++] = pdev_stats->loc_mpdus;
1431         data[i++] = pdev_stats->phy_errs;
1432         data[i++] = pdev_stats->phy_err_drop;
1433         data[i++] = pdev_stats->mpdu_errs;
1434         data[i++] = ar->stats.fw_crash_counter;
1435         data[i++] = ar->stats.fw_warm_reset_counter;
1436         data[i++] = ar->stats.fw_cold_reset_counter;
1437
1438         spin_unlock_bh(&ar->data_lock);
1439
1440         mutex_unlock(&ar->conf_mutex);
1441
1442         WARN_ON(i != ATH10K_SSTATS_LEN);
1443 }
1444
1445 static const struct file_operations fops_fw_dbglog = {
1446         .read = ath10k_read_fw_dbglog,
1447         .write = ath10k_write_fw_dbglog,
1448         .open = simple_open,
1449         .owner = THIS_MODULE,
1450         .llseek = default_llseek,
1451 };
1452
1453 static int ath10k_debug_cal_data_open(struct inode *inode, struct file *file)
1454 {
1455         struct ath10k *ar = inode->i_private;
1456         void *buf;
1457         u32 hi_addr;
1458         __le32 addr;
1459         int ret;
1460
1461         mutex_lock(&ar->conf_mutex);
1462
1463         if (ar->state != ATH10K_STATE_ON &&
1464             ar->state != ATH10K_STATE_UTF) {
1465                 ret = -ENETDOWN;
1466                 goto err;
1467         }
1468
1469         buf = vmalloc(ar->hw_params.cal_data_len);
1470         if (!buf) {
1471                 ret = -ENOMEM;
1472                 goto err;
1473         }
1474
1475         hi_addr = host_interest_item_address(HI_ITEM(hi_board_data));
1476
1477         ret = ath10k_hif_diag_read(ar, hi_addr, &addr, sizeof(addr));
1478         if (ret) {
1479                 ath10k_warn(ar, "failed to read hi_board_data address: %d\n", ret);
1480                 goto err_vfree;
1481         }
1482
1483         ret = ath10k_hif_diag_read(ar, le32_to_cpu(addr), buf,
1484                                    ar->hw_params.cal_data_len);
1485         if (ret) {
1486                 ath10k_warn(ar, "failed to read calibration data: %d\n", ret);
1487                 goto err_vfree;
1488         }
1489
1490         file->private_data = buf;
1491
1492         mutex_unlock(&ar->conf_mutex);
1493
1494         return 0;
1495
1496 err_vfree:
1497         vfree(buf);
1498
1499 err:
1500         mutex_unlock(&ar->conf_mutex);
1501
1502         return ret;
1503 }
1504
1505 static ssize_t ath10k_debug_cal_data_read(struct file *file,
1506                                           char __user *user_buf,
1507                                           size_t count, loff_t *ppos)
1508 {
1509         struct ath10k *ar = file->private_data;
1510         void *buf = file->private_data;
1511
1512         return simple_read_from_buffer(user_buf, count, ppos,
1513                                        buf, ar->hw_params.cal_data_len);
1514 }
1515
1516 static int ath10k_debug_cal_data_release(struct inode *inode,
1517                                          struct file *file)
1518 {
1519         vfree(file->private_data);
1520
1521         return 0;
1522 }
1523
1524 static ssize_t ath10k_write_ani_enable(struct file *file,
1525                                        const char __user *user_buf,
1526                                        size_t count, loff_t *ppos)
1527 {
1528         struct ath10k *ar = file->private_data;
1529         int ret;
1530         u8 enable;
1531
1532         if (kstrtou8_from_user(user_buf, count, 0, &enable))
1533                 return -EINVAL;
1534
1535         mutex_lock(&ar->conf_mutex);
1536
1537         if (ar->ani_enabled == enable) {
1538                 ret = count;
1539                 goto exit;
1540         }
1541
1542         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->ani_enable,
1543                                         enable);
1544         if (ret) {
1545                 ath10k_warn(ar, "ani_enable failed from debugfs: %d\n", ret);
1546                 goto exit;
1547         }
1548         ar->ani_enabled = enable;
1549
1550         ret = count;
1551
1552 exit:
1553         mutex_unlock(&ar->conf_mutex);
1554
1555         return ret;
1556 }
1557
1558 static ssize_t ath10k_read_ani_enable(struct file *file, char __user *user_buf,
1559                                       size_t count, loff_t *ppos)
1560 {
1561         struct ath10k *ar = file->private_data;
1562         int len = 0;
1563         char buf[32];
1564
1565         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
1566                         ar->ani_enabled);
1567
1568         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1569 }
1570
1571 static const struct file_operations fops_ani_enable = {
1572         .read = ath10k_read_ani_enable,
1573         .write = ath10k_write_ani_enable,
1574         .open = simple_open,
1575         .owner = THIS_MODULE,
1576         .llseek = default_llseek,
1577 };
1578
1579 static const struct file_operations fops_cal_data = {
1580         .open = ath10k_debug_cal_data_open,
1581         .read = ath10k_debug_cal_data_read,
1582         .release = ath10k_debug_cal_data_release,
1583         .owner = THIS_MODULE,
1584         .llseek = default_llseek,
1585 };
1586
1587 static ssize_t ath10k_read_nf_cal_period(struct file *file,
1588                                          char __user *user_buf,
1589                                          size_t count, loff_t *ppos)
1590 {
1591         struct ath10k *ar = file->private_data;
1592         unsigned int len;
1593         char buf[32];
1594
1595         len = scnprintf(buf, sizeof(buf), "%d\n",
1596                         ar->debug.nf_cal_period);
1597
1598         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1599 }
1600
1601 static ssize_t ath10k_write_nf_cal_period(struct file *file,
1602                                           const char __user *user_buf,
1603                                           size_t count, loff_t *ppos)
1604 {
1605         struct ath10k *ar = file->private_data;
1606         unsigned long period;
1607         int ret;
1608
1609         ret = kstrtoul_from_user(user_buf, count, 0, &period);
1610         if (ret)
1611                 return ret;
1612
1613         if (period > WMI_PDEV_PARAM_CAL_PERIOD_MAX)
1614                 return -EINVAL;
1615
1616         /* there's no way to switch back to the firmware default */
1617         if (period == 0)
1618                 return -EINVAL;
1619
1620         mutex_lock(&ar->conf_mutex);
1621
1622         ar->debug.nf_cal_period = period;
1623
1624         if (ar->state != ATH10K_STATE_ON) {
1625                 /* firmware is not running, nothing else to do */
1626                 ret = count;
1627                 goto exit;
1628         }
1629
1630         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->cal_period,
1631                                         ar->debug.nf_cal_period);
1632         if (ret) {
1633                 ath10k_warn(ar, "cal period cfg failed from debugfs: %d\n",
1634                             ret);
1635                 goto exit;
1636         }
1637
1638         ret = count;
1639
1640 exit:
1641         mutex_unlock(&ar->conf_mutex);
1642
1643         return ret;
1644 }
1645
1646 static const struct file_operations fops_nf_cal_period = {
1647         .read = ath10k_read_nf_cal_period,
1648         .write = ath10k_write_nf_cal_period,
1649         .open = simple_open,
1650         .owner = THIS_MODULE,
1651         .llseek = default_llseek,
1652 };
1653
1654 #define ATH10K_TPC_CONFIG_BUF_SIZE      (1024 * 1024)
1655
1656 static int ath10k_debug_tpc_stats_request(struct ath10k *ar)
1657 {
1658         int ret;
1659         unsigned long time_left;
1660
1661         lockdep_assert_held(&ar->conf_mutex);
1662
1663         reinit_completion(&ar->debug.tpc_complete);
1664
1665         ret = ath10k_wmi_pdev_get_tpc_config(ar, WMI_TPC_CONFIG_PARAM);
1666         if (ret) {
1667                 ath10k_warn(ar, "failed to request tpc config: %d\n", ret);
1668                 return ret;
1669         }
1670
1671         time_left = wait_for_completion_timeout(&ar->debug.tpc_complete,
1672                                                 1 * HZ);
1673         if (time_left == 0)
1674                 return -ETIMEDOUT;
1675
1676         return 0;
1677 }
1678
1679 void ath10k_debug_tpc_stats_process(struct ath10k *ar,
1680                                     struct ath10k_tpc_stats *tpc_stats)
1681 {
1682         spin_lock_bh(&ar->data_lock);
1683
1684         kfree(ar->debug.tpc_stats);
1685         ar->debug.tpc_stats = tpc_stats;
1686         complete(&ar->debug.tpc_complete);
1687
1688         spin_unlock_bh(&ar->data_lock);
1689 }
1690
1691 static void ath10k_tpc_stats_print(struct ath10k_tpc_stats *tpc_stats,
1692                                    unsigned int j, char *buf, unsigned int *len)
1693 {
1694         unsigned int i, buf_len;
1695         static const char table_str[][5] = { "CDD",
1696                                              "STBC",
1697                                              "TXBF" };
1698         static const char pream_str[][6] = { "CCK",
1699                                              "OFDM",
1700                                              "HT20",
1701                                              "HT40",
1702                                              "VHT20",
1703                                              "VHT40",
1704                                              "VHT80",
1705                                              "HTCUP" };
1706
1707         buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1708         *len += scnprintf(buf + *len, buf_len - *len,
1709                           "********************************\n");
1710         *len += scnprintf(buf + *len, buf_len - *len,
1711                           "******************* %s POWER TABLE ****************\n",
1712                           table_str[j]);
1713         *len += scnprintf(buf + *len, buf_len - *len,
1714                           "********************************\n");
1715         *len += scnprintf(buf + *len, buf_len - *len,
1716                           "No.  Preamble Rate_code tpc_value1 tpc_value2 tpc_value3\n");
1717
1718         for (i = 0; i < tpc_stats->rate_max; i++) {
1719                 *len += scnprintf(buf + *len, buf_len - *len,
1720                                   "%8d %s 0x%2x %s\n", i,
1721                                   pream_str[tpc_stats->tpc_table[j].pream_idx[i]],
1722                                   tpc_stats->tpc_table[j].rate_code[i],
1723                                   tpc_stats->tpc_table[j].tpc_value[i]);
1724         }
1725
1726         *len += scnprintf(buf + *len, buf_len - *len,
1727                           "***********************************\n");
1728 }
1729
1730 static void ath10k_tpc_stats_fill(struct ath10k *ar,
1731                                   struct ath10k_tpc_stats *tpc_stats,
1732                                   char *buf)
1733 {
1734         unsigned int len, j, buf_len;
1735
1736         len = 0;
1737         buf_len = ATH10K_TPC_CONFIG_BUF_SIZE;
1738
1739         spin_lock_bh(&ar->data_lock);
1740
1741         if (!tpc_stats) {
1742                 ath10k_warn(ar, "failed to get tpc stats\n");
1743                 goto unlock;
1744         }
1745
1746         len += scnprintf(buf + len, buf_len - len, "\n");
1747         len += scnprintf(buf + len, buf_len - len,
1748                          "*************************************\n");
1749         len += scnprintf(buf + len, buf_len - len,
1750                          "TPC config for channel %4d mode %d\n",
1751                          tpc_stats->chan_freq,
1752                          tpc_stats->phy_mode);
1753         len += scnprintf(buf + len, buf_len - len,
1754                          "*************************************\n");
1755         len += scnprintf(buf + len, buf_len - len,
1756                          "CTL           =  0x%2x Reg. Domain            = %2d\n",
1757                          tpc_stats->ctl,
1758                          tpc_stats->reg_domain);
1759         len += scnprintf(buf + len, buf_len - len,
1760                          "Antenna Gain  = %2d Reg. Max Antenna Gain     =  %2d\n",
1761                          tpc_stats->twice_antenna_gain,
1762                          tpc_stats->twice_antenna_reduction);
1763         len += scnprintf(buf + len, buf_len - len,
1764                          "Power Limit   = %2d Reg. Max Power            = %2d\n",
1765                          tpc_stats->power_limit,
1766                          tpc_stats->twice_max_rd_power / 2);
1767         len += scnprintf(buf + len, buf_len - len,
1768                          "Num tx chains = %2d Num supported rates       = %2d\n",
1769                          tpc_stats->num_tx_chain,
1770                          tpc_stats->rate_max);
1771
1772         for (j = 0; j < tpc_stats->num_tx_chain ; j++) {
1773                 switch (j) {
1774                 case WMI_TPC_TABLE_TYPE_CDD:
1775                         if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1776                                 len += scnprintf(buf + len, buf_len - len,
1777                                                  "CDD not supported\n");
1778                                 break;
1779                         }
1780
1781                         ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1782                         break;
1783                 case WMI_TPC_TABLE_TYPE_STBC:
1784                         if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1785                                 len += scnprintf(buf + len, buf_len - len,
1786                                                  "STBC not supported\n");
1787                                 break;
1788                         }
1789
1790                         ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1791                         break;
1792                 case WMI_TPC_TABLE_TYPE_TXBF:
1793                         if (tpc_stats->flag[j] == ATH10K_TPC_TABLE_TYPE_FLAG) {
1794                                 len += scnprintf(buf + len, buf_len - len,
1795                                                  "TXBF not supported\n***************************\n");
1796                                 break;
1797                         }
1798
1799                         ath10k_tpc_stats_print(tpc_stats, j, buf, &len);
1800                         break;
1801                 default:
1802                         len += scnprintf(buf + len, buf_len - len,
1803                                          "Invalid Type\n");
1804                         break;
1805                 }
1806         }
1807
1808 unlock:
1809         spin_unlock_bh(&ar->data_lock);
1810
1811         if (len >= buf_len)
1812                 buf[len - 1] = 0;
1813         else
1814                 buf[len] = 0;
1815 }
1816
1817 static int ath10k_tpc_stats_open(struct inode *inode, struct file *file)
1818 {
1819         struct ath10k *ar = inode->i_private;
1820         void *buf = NULL;
1821         int ret;
1822
1823         mutex_lock(&ar->conf_mutex);
1824
1825         if (ar->state != ATH10K_STATE_ON) {
1826                 ret = -ENETDOWN;
1827                 goto err_unlock;
1828         }
1829
1830         buf = vmalloc(ATH10K_TPC_CONFIG_BUF_SIZE);
1831         if (!buf) {
1832                 ret = -ENOMEM;
1833                 goto err_unlock;
1834         }
1835
1836         ret = ath10k_debug_tpc_stats_request(ar);
1837         if (ret) {
1838                 ath10k_warn(ar, "failed to request tpc config stats: %d\n",
1839                             ret);
1840                 goto err_free;
1841         }
1842
1843         ath10k_tpc_stats_fill(ar, ar->debug.tpc_stats, buf);
1844         file->private_data = buf;
1845
1846         mutex_unlock(&ar->conf_mutex);
1847         return 0;
1848
1849 err_free:
1850         vfree(buf);
1851
1852 err_unlock:
1853         mutex_unlock(&ar->conf_mutex);
1854         return ret;
1855 }
1856
1857 static int ath10k_tpc_stats_release(struct inode *inode, struct file *file)
1858 {
1859         vfree(file->private_data);
1860
1861         return 0;
1862 }
1863
1864 static ssize_t ath10k_tpc_stats_read(struct file *file, char __user *user_buf,
1865                                      size_t count, loff_t *ppos)
1866 {
1867         const char *buf = file->private_data;
1868         unsigned int len = strlen(buf);
1869
1870         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1871 }
1872
1873 static const struct file_operations fops_tpc_stats = {
1874         .open = ath10k_tpc_stats_open,
1875         .release = ath10k_tpc_stats_release,
1876         .read = ath10k_tpc_stats_read,
1877         .owner = THIS_MODULE,
1878         .llseek = default_llseek,
1879 };
1880
1881 int ath10k_debug_start(struct ath10k *ar)
1882 {
1883         int ret;
1884
1885         lockdep_assert_held(&ar->conf_mutex);
1886
1887         ret = ath10k_debug_htt_stats_req(ar);
1888         if (ret)
1889                 /* continue normally anyway, this isn't serious */
1890                 ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1891                             ret);
1892
1893         if (ar->debug.fw_dbglog_mask) {
1894                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask,
1895                                             ATH10K_DBGLOG_LEVEL_WARN);
1896                 if (ret)
1897                         /* not serious */
1898                         ath10k_warn(ar, "failed to enable dbglog during start: %d",
1899                                     ret);
1900         }
1901
1902         if (ar->debug.pktlog_filter) {
1903                 ret = ath10k_wmi_pdev_pktlog_enable(ar,
1904                                                     ar->debug.pktlog_filter);
1905                 if (ret)
1906                         /* not serious */
1907                         ath10k_warn(ar,
1908                                     "failed to enable pktlog filter %x: %d\n",
1909                                     ar->debug.pktlog_filter, ret);
1910         } else {
1911                 ret = ath10k_wmi_pdev_pktlog_disable(ar);
1912                 if (ret)
1913                         /* not serious */
1914                         ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
1915         }
1916
1917         if (ar->debug.nf_cal_period) {
1918                 ret = ath10k_wmi_pdev_set_param(ar,
1919                                                 ar->wmi.pdev_param->cal_period,
1920                                                 ar->debug.nf_cal_period);
1921                 if (ret)
1922                         /* not serious */
1923                         ath10k_warn(ar, "cal period cfg failed from debug start: %d\n",
1924                                     ret);
1925         }
1926
1927         return ret;
1928 }
1929
1930 void ath10k_debug_stop(struct ath10k *ar)
1931 {
1932         lockdep_assert_held(&ar->conf_mutex);
1933
1934         /* Must not use _sync to avoid deadlock, we do that in
1935          * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1936          * warning from del_timer(). */
1937         if (ar->debug.htt_stats_mask != 0)
1938                 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1939
1940         ath10k_wmi_pdev_pktlog_disable(ar);
1941 }
1942
1943 static ssize_t ath10k_write_simulate_radar(struct file *file,
1944                                            const char __user *user_buf,
1945                                            size_t count, loff_t *ppos)
1946 {
1947         struct ath10k *ar = file->private_data;
1948
1949         ieee80211_radar_detected(ar->hw);
1950
1951         return count;
1952 }
1953
1954 static const struct file_operations fops_simulate_radar = {
1955         .write = ath10k_write_simulate_radar,
1956         .open = simple_open,
1957         .owner = THIS_MODULE,
1958         .llseek = default_llseek,
1959 };
1960
1961 #define ATH10K_DFS_STAT(s, p) (\
1962         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1963                          ar->debug.dfs_stats.p))
1964
1965 #define ATH10K_DFS_POOL_STAT(s, p) (\
1966         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1967                          ar->debug.dfs_pool_stats.p))
1968
1969 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1970                                      size_t count, loff_t *ppos)
1971 {
1972         int retval = 0, len = 0;
1973         const int size = 8000;
1974         struct ath10k *ar = file->private_data;
1975         char *buf;
1976
1977         buf = kzalloc(size, GFP_KERNEL);
1978         if (buf == NULL)
1979                 return -ENOMEM;
1980
1981         if (!ar->dfs_detector) {
1982                 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1983                 goto exit;
1984         }
1985
1986         ar->debug.dfs_pool_stats =
1987                         ar->dfs_detector->get_stats(ar->dfs_detector);
1988
1989         len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1990
1991         ATH10K_DFS_STAT("reported phy errors", phy_errors);
1992         ATH10K_DFS_STAT("pulse events reported", pulses_total);
1993         ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1994         ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1995         ATH10K_DFS_STAT("Radars detected", radar_detected);
1996
1997         len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1998         ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1999         ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
2000         ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
2001         ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
2002         ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
2003         ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
2004         ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
2005
2006 exit:
2007         if (len > size)
2008                 len = size;
2009
2010         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
2011         kfree(buf);
2012
2013         return retval;
2014 }
2015
2016 static const struct file_operations fops_dfs_stats = {
2017         .read = ath10k_read_dfs_stats,
2018         .open = simple_open,
2019         .owner = THIS_MODULE,
2020         .llseek = default_llseek,
2021 };
2022
2023 static ssize_t ath10k_write_pktlog_filter(struct file *file,
2024                                           const char __user *ubuf,
2025                                           size_t count, loff_t *ppos)
2026 {
2027         struct ath10k *ar = file->private_data;
2028         u32 filter;
2029         int ret;
2030
2031         if (kstrtouint_from_user(ubuf, count, 0, &filter))
2032                 return -EINVAL;
2033
2034         mutex_lock(&ar->conf_mutex);
2035
2036         if (ar->state != ATH10K_STATE_ON) {
2037                 ar->debug.pktlog_filter = filter;
2038                 ret = count;
2039                 goto out;
2040         }
2041
2042         if (filter == ar->debug.pktlog_filter) {
2043                 ret = count;
2044                 goto out;
2045         }
2046
2047         if (filter) {
2048                 ret = ath10k_wmi_pdev_pktlog_enable(ar, filter);
2049                 if (ret) {
2050                         ath10k_warn(ar, "failed to enable pktlog filter %x: %d\n",
2051                                     ar->debug.pktlog_filter, ret);
2052                         goto out;
2053                 }
2054         } else {
2055                 ret = ath10k_wmi_pdev_pktlog_disable(ar);
2056                 if (ret) {
2057                         ath10k_warn(ar, "failed to disable pktlog: %d\n", ret);
2058                         goto out;
2059                 }
2060         }
2061
2062         ar->debug.pktlog_filter = filter;
2063         ret = count;
2064
2065 out:
2066         mutex_unlock(&ar->conf_mutex);
2067         return ret;
2068 }
2069
2070 static ssize_t ath10k_read_pktlog_filter(struct file *file, char __user *ubuf,
2071                                          size_t count, loff_t *ppos)
2072 {
2073         char buf[32];
2074         struct ath10k *ar = file->private_data;
2075         int len = 0;
2076
2077         mutex_lock(&ar->conf_mutex);
2078         len = scnprintf(buf, sizeof(buf) - len, "%08x\n",
2079                         ar->debug.pktlog_filter);
2080         mutex_unlock(&ar->conf_mutex);
2081
2082         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2083 }
2084
2085 static const struct file_operations fops_pktlog_filter = {
2086         .read = ath10k_read_pktlog_filter,
2087         .write = ath10k_write_pktlog_filter,
2088         .open = simple_open
2089 };
2090
2091 static ssize_t ath10k_write_quiet_period(struct file *file,
2092                                          const char __user *ubuf,
2093                                          size_t count, loff_t *ppos)
2094 {
2095         struct ath10k *ar = file->private_data;
2096         u32 period;
2097
2098         if (kstrtouint_from_user(ubuf, count, 0, &period))
2099                 return -EINVAL;
2100
2101         if (period < ATH10K_QUIET_PERIOD_MIN) {
2102                 ath10k_warn(ar, "Quiet period %u can not be lesser than 25ms\n",
2103                             period);
2104                 return -EINVAL;
2105         }
2106         mutex_lock(&ar->conf_mutex);
2107         ar->thermal.quiet_period = period;
2108         ath10k_thermal_set_throttling(ar);
2109         mutex_unlock(&ar->conf_mutex);
2110
2111         return count;
2112 }
2113
2114 static ssize_t ath10k_read_quiet_period(struct file *file, char __user *ubuf,
2115                                         size_t count, loff_t *ppos)
2116 {
2117         char buf[32];
2118         struct ath10k *ar = file->private_data;
2119         int len = 0;
2120
2121         mutex_lock(&ar->conf_mutex);
2122         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2123                         ar->thermal.quiet_period);
2124         mutex_unlock(&ar->conf_mutex);
2125
2126         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2127 }
2128
2129 static const struct file_operations fops_quiet_period = {
2130         .read = ath10k_read_quiet_period,
2131         .write = ath10k_write_quiet_period,
2132         .open = simple_open
2133 };
2134
2135 static ssize_t ath10k_write_btcoex(struct file *file,
2136                                    const char __user *ubuf,
2137                                    size_t count, loff_t *ppos)
2138 {
2139         struct ath10k *ar = file->private_data;
2140         char buf[32];
2141         size_t buf_size;
2142         int ret;
2143         bool val;
2144         u32 pdev_param;
2145
2146         buf_size = min(count, (sizeof(buf) - 1));
2147         if (copy_from_user(buf, ubuf, buf_size))
2148                 return -EFAULT;
2149
2150         buf[buf_size] = '\0';
2151
2152         if (strtobool(buf, &val) != 0)
2153                 return -EINVAL;
2154
2155         mutex_lock(&ar->conf_mutex);
2156
2157         if (ar->state != ATH10K_STATE_ON &&
2158             ar->state != ATH10K_STATE_RESTARTED) {
2159                 ret = -ENETDOWN;
2160                 goto exit;
2161         }
2162
2163         if (!(test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags) ^ val)) {
2164                 ret = count;
2165                 goto exit;
2166         }
2167
2168         pdev_param = ar->wmi.pdev_param->enable_btcoex;
2169         if (test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
2170                      ar->running_fw->fw_file.fw_features)) {
2171                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, val);
2172                 if (ret) {
2173                         ath10k_warn(ar, "failed to enable btcoex: %d\n", ret);
2174                         ret = count;
2175                         goto exit;
2176                 }
2177         } else {
2178                 ath10k_info(ar, "restarting firmware due to btcoex change");
2179                 queue_work(ar->workqueue, &ar->restart_work);
2180         }
2181
2182         if (val)
2183                 set_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2184         else
2185                 clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
2186
2187         ret = count;
2188
2189 exit:
2190         mutex_unlock(&ar->conf_mutex);
2191
2192         return ret;
2193 }
2194
2195 static ssize_t ath10k_read_btcoex(struct file *file, char __user *ubuf,
2196                                   size_t count, loff_t *ppos)
2197 {
2198         char buf[32];
2199         struct ath10k *ar = file->private_data;
2200         int len = 0;
2201
2202         mutex_lock(&ar->conf_mutex);
2203         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2204                         test_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags));
2205         mutex_unlock(&ar->conf_mutex);
2206
2207         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2208 }
2209
2210 static const struct file_operations fops_btcoex = {
2211         .read = ath10k_read_btcoex,
2212         .write = ath10k_write_btcoex,
2213         .open = simple_open
2214 };
2215
2216 static ssize_t ath10k_write_peer_stats(struct file *file,
2217                                        const char __user *ubuf,
2218                                        size_t count, loff_t *ppos)
2219 {
2220         struct ath10k *ar = file->private_data;
2221         char buf[32];
2222         size_t buf_size;
2223         int ret;
2224         bool val;
2225
2226         buf_size = min(count, (sizeof(buf) - 1));
2227         if (copy_from_user(buf, ubuf, buf_size))
2228                 return -EFAULT;
2229
2230         buf[buf_size] = '\0';
2231
2232         if (strtobool(buf, &val) != 0)
2233                 return -EINVAL;
2234
2235         mutex_lock(&ar->conf_mutex);
2236
2237         if (ar->state != ATH10K_STATE_ON &&
2238             ar->state != ATH10K_STATE_RESTARTED) {
2239                 ret = -ENETDOWN;
2240                 goto exit;
2241         }
2242
2243         if (!(test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) ^ val)) {
2244                 ret = count;
2245                 goto exit;
2246         }
2247
2248         if (val)
2249                 set_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2250         else
2251                 clear_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2252
2253         ath10k_info(ar, "restarting firmware due to Peer stats change");
2254
2255         queue_work(ar->workqueue, &ar->restart_work);
2256         ret = count;
2257
2258 exit:
2259         mutex_unlock(&ar->conf_mutex);
2260         return ret;
2261 }
2262
2263 static ssize_t ath10k_read_peer_stats(struct file *file, char __user *ubuf,
2264                                       size_t count, loff_t *ppos)
2265
2266 {
2267         char buf[32];
2268         struct ath10k *ar = file->private_data;
2269         int len = 0;
2270
2271         mutex_lock(&ar->conf_mutex);
2272         len = scnprintf(buf, sizeof(buf) - len, "%d\n",
2273                         test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags));
2274         mutex_unlock(&ar->conf_mutex);
2275
2276         return simple_read_from_buffer(ubuf, count, ppos, buf, len);
2277 }
2278
2279 static const struct file_operations fops_peer_stats = {
2280         .read = ath10k_read_peer_stats,
2281         .write = ath10k_write_peer_stats,
2282         .open = simple_open
2283 };
2284
2285 static ssize_t ath10k_debug_fw_checksums_read(struct file *file,
2286                                               char __user *user_buf,
2287                                               size_t count, loff_t *ppos)
2288 {
2289         struct ath10k *ar = file->private_data;
2290         unsigned int len = 0, buf_len = 4096;
2291         ssize_t ret_cnt;
2292         char *buf;
2293
2294         buf = kzalloc(buf_len, GFP_KERNEL);
2295         if (!buf)
2296                 return -ENOMEM;
2297
2298         mutex_lock(&ar->conf_mutex);
2299
2300         len += scnprintf(buf + len, buf_len - len,
2301                          "firmware-N.bin\t\t%08x\n",
2302                          crc32_le(0, ar->normal_mode_fw.fw_file.firmware->data,
2303                                   ar->normal_mode_fw.fw_file.firmware->size));
2304         len += scnprintf(buf + len, buf_len - len,
2305                          "athwlan\t\t\t%08x\n",
2306                          crc32_le(0, ar->normal_mode_fw.fw_file.firmware_data,
2307                                   ar->normal_mode_fw.fw_file.firmware_len));
2308         len += scnprintf(buf + len, buf_len - len,
2309                          "otp\t\t\t%08x\n",
2310                          crc32_le(0, ar->normal_mode_fw.fw_file.otp_data,
2311                                   ar->normal_mode_fw.fw_file.otp_len));
2312         len += scnprintf(buf + len, buf_len - len,
2313                          "codeswap\t\t%08x\n",
2314                          crc32_le(0, ar->normal_mode_fw.fw_file.codeswap_data,
2315                                   ar->normal_mode_fw.fw_file.codeswap_len));
2316         len += scnprintf(buf + len, buf_len - len,
2317                          "board-N.bin\t\t%08x\n",
2318                          crc32_le(0, ar->normal_mode_fw.board->data,
2319                                   ar->normal_mode_fw.board->size));
2320         len += scnprintf(buf + len, buf_len - len,
2321                          "board\t\t\t%08x\n",
2322                          crc32_le(0, ar->normal_mode_fw.board_data,
2323                                   ar->normal_mode_fw.board_len));
2324
2325         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
2326
2327         mutex_unlock(&ar->conf_mutex);
2328
2329         kfree(buf);
2330         return ret_cnt;
2331 }
2332
2333 static const struct file_operations fops_fw_checksums = {
2334         .read = ath10k_debug_fw_checksums_read,
2335         .open = simple_open,
2336         .owner = THIS_MODULE,
2337         .llseek = default_llseek,
2338 };
2339
2340 int ath10k_debug_create(struct ath10k *ar)
2341 {
2342         ar->debug.fw_crash_data = vzalloc(sizeof(*ar->debug.fw_crash_data));
2343         if (!ar->debug.fw_crash_data)
2344                 return -ENOMEM;
2345
2346         INIT_LIST_HEAD(&ar->debug.fw_stats.pdevs);
2347         INIT_LIST_HEAD(&ar->debug.fw_stats.vdevs);
2348         INIT_LIST_HEAD(&ar->debug.fw_stats.peers);
2349         INIT_LIST_HEAD(&ar->debug.fw_stats.peers_extd);
2350
2351         return 0;
2352 }
2353
2354 void ath10k_debug_destroy(struct ath10k *ar)
2355 {
2356         vfree(ar->debug.fw_crash_data);
2357         ar->debug.fw_crash_data = NULL;
2358
2359         ath10k_debug_fw_stats_reset(ar);
2360
2361         kfree(ar->debug.tpc_stats);
2362 }
2363
2364 int ath10k_debug_register(struct ath10k *ar)
2365 {
2366         ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
2367                                                    ar->hw->wiphy->debugfsdir);
2368         if (IS_ERR_OR_NULL(ar->debug.debugfs_phy)) {
2369                 if (IS_ERR(ar->debug.debugfs_phy))
2370                         return PTR_ERR(ar->debug.debugfs_phy);
2371
2372                 return -ENOMEM;
2373         }
2374
2375         INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
2376                           ath10k_debug_htt_stats_dwork);
2377
2378         init_completion(&ar->debug.tpc_complete);
2379         init_completion(&ar->debug.fw_stats_complete);
2380
2381         debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
2382                             &fops_fw_stats);
2383
2384         debugfs_create_file("fw_reset_stats", S_IRUSR, ar->debug.debugfs_phy,
2385                             ar, &fops_fw_reset_stats);
2386
2387         debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
2388                             &fops_wmi_services);
2389
2390         debugfs_create_file("simulate_fw_crash", S_IRUSR | S_IWUSR,
2391                             ar->debug.debugfs_phy, ar, &fops_simulate_fw_crash);
2392
2393         debugfs_create_file("fw_crash_dump", S_IRUSR, ar->debug.debugfs_phy,
2394                             ar, &fops_fw_crash_dump);
2395
2396         debugfs_create_file("reg_addr", S_IRUSR | S_IWUSR,
2397                             ar->debug.debugfs_phy, ar, &fops_reg_addr);
2398
2399         debugfs_create_file("reg_value", S_IRUSR | S_IWUSR,
2400                             ar->debug.debugfs_phy, ar, &fops_reg_value);
2401
2402         debugfs_create_file("mem_value", S_IRUSR | S_IWUSR,
2403                             ar->debug.debugfs_phy, ar, &fops_mem_value);
2404
2405         debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
2406                             ar, &fops_chip_id);
2407
2408         debugfs_create_file("htt_stats_mask", S_IRUSR | S_IWUSR,
2409                             ar->debug.debugfs_phy, ar, &fops_htt_stats_mask);
2410
2411         debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
2412                             ar->debug.debugfs_phy, ar,
2413                             &fops_htt_max_amsdu_ampdu);
2414
2415         debugfs_create_file("fw_dbglog", S_IRUSR | S_IWUSR,
2416                             ar->debug.debugfs_phy, ar, &fops_fw_dbglog);
2417
2418         debugfs_create_file("cal_data", S_IRUSR, ar->debug.debugfs_phy,
2419                             ar, &fops_cal_data);
2420
2421         debugfs_create_file("ani_enable", S_IRUSR | S_IWUSR,
2422                             ar->debug.debugfs_phy, ar, &fops_ani_enable);
2423
2424         debugfs_create_file("nf_cal_period", S_IRUSR | S_IWUSR,
2425                             ar->debug.debugfs_phy, ar, &fops_nf_cal_period);
2426
2427         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
2428                 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
2429                                     ar->debug.debugfs_phy, ar,
2430                                     &fops_simulate_radar);
2431
2432                 debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
2433                                     ar->debug.debugfs_phy,
2434                                     &ar->dfs_block_radar_events);
2435
2436                 debugfs_create_file("dfs_stats", S_IRUSR,
2437                                     ar->debug.debugfs_phy, ar,
2438                                     &fops_dfs_stats);
2439         }
2440
2441         debugfs_create_file("pktlog_filter", S_IRUGO | S_IWUSR,
2442                             ar->debug.debugfs_phy, ar, &fops_pktlog_filter);
2443
2444         debugfs_create_file("quiet_period", S_IRUGO | S_IWUSR,
2445                             ar->debug.debugfs_phy, ar, &fops_quiet_period);
2446
2447         debugfs_create_file("tpc_stats", S_IRUSR,
2448                             ar->debug.debugfs_phy, ar, &fops_tpc_stats);
2449
2450         if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map))
2451                 debugfs_create_file("btcoex", S_IRUGO | S_IWUSR,
2452                                     ar->debug.debugfs_phy, ar, &fops_btcoex);
2453
2454         if (test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
2455                 debugfs_create_file("peer_stats", S_IRUGO | S_IWUSR,
2456                                     ar->debug.debugfs_phy, ar,
2457                                     &fops_peer_stats);
2458
2459         debugfs_create_file("fw_checksums", S_IRUSR,
2460                             ar->debug.debugfs_phy, ar, &fops_fw_checksums);
2461
2462         return 0;
2463 }
2464
2465 void ath10k_debug_unregister(struct ath10k *ar)
2466 {
2467         cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
2468 }
2469
2470 #endif /* CONFIG_ATH10K_DEBUGFS */
2471
2472 #ifdef CONFIG_ATH10K_DEBUG
2473 void ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
2474                 const char *fmt, ...)
2475 {
2476         struct va_format vaf;
2477         va_list args;
2478
2479         va_start(args, fmt);
2480
2481         vaf.fmt = fmt;
2482         vaf.va = &args;
2483
2484         if (ath10k_debug_mask & mask)
2485                 dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
2486
2487         trace_ath10k_log_dbg(ar, mask, &vaf);
2488
2489         va_end(args);
2490 }
2491 EXPORT_SYMBOL(ath10k_dbg);
2492
2493 void ath10k_dbg_dump(struct ath10k *ar,
2494                      enum ath10k_debug_mask mask,
2495                      const char *msg, const char *prefix,
2496                      const void *buf, size_t len)
2497 {
2498         char linebuf[256];
2499         unsigned int linebuflen;
2500         const void *ptr;
2501
2502         if (ath10k_debug_mask & mask) {
2503                 if (msg)
2504                         ath10k_dbg(ar, mask, "%s\n", msg);
2505
2506                 for (ptr = buf; (ptr - buf) < len; ptr += 16) {
2507                         linebuflen = 0;
2508                         linebuflen += scnprintf(linebuf + linebuflen,
2509                                                 sizeof(linebuf) - linebuflen,
2510                                                 "%s%08x: ",
2511                                                 (prefix ? prefix : ""),
2512                                                 (unsigned int)(ptr - buf));
2513                         hex_dump_to_buffer(ptr, len - (ptr - buf), 16, 1,
2514                                            linebuf + linebuflen,
2515                                            sizeof(linebuf) - linebuflen, true);
2516                         dev_printk(KERN_DEBUG, ar->dev, "%s\n", linebuf);
2517                 }
2518         }
2519
2520         /* tracing code doesn't like null strings :/ */
2521         trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
2522                                   buf, len);
2523 }
2524 EXPORT_SYMBOL(ath10k_dbg_dump);
2525
2526 #endif /* CONFIG_ATH10K_DEBUG */