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