drivers/net/wireless/ath/ath10k/debug.c

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