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