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