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