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