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