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