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