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