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/version.h>
  21 #include <linux/vermagic.h>
  22 #include <linux/vmalloc.h>
  23
  24 #include "core.h"
  25 #include "debug.h"
  26
  27 /* ms */
  28 #define ATH10K_DEBUG_HTT_STATS_INTERVAL 1000
  29
  30 #define ATH10K_FW_CRASH_DUMP_VERSION 1
  31
  32 /**
  33  * enum ath10k_fw_crash_dump_type - types of data in the dump file
  34  * @ATH10K_FW_CRASH_DUMP_REGDUMP: Register crash dump in binary format
  35  */
  36 enum ath10k_fw_crash_dump_type {
  37         ATH10K_FW_CRASH_DUMP_REGISTERS = 0,
  38
  39         ATH10K_FW_CRASH_DUMP_MAX,
  40 };
  41
  42 struct ath10k_tlv_dump_data {
  43         /* see ath10k_fw_crash_dump_type above */
  44         __le32 type;
  45
  46         /* in bytes */
  47         __le32 tlv_len;
  48
  49         /* pad to 32-bit boundaries as needed */
  50         u8 tlv_data[];
  51 } __packed;
  52
  53 struct ath10k_dump_file_data {
  54         /* dump file information */
  55
  56         /* "ATH10K-FW-DUMP" */
  57         char df_magic[16];
  58
  59         __le32 len;
  60
  61         /* file dump version */
  62         __le32 version;
  63
  64         /* some info we can get from ath10k struct that might help */
  65
  66         u8 uuid[16];
  67
  68         __le32 chip_id;
  69
  70         /* 0 for now, in place for later hardware */
  71         __le32 bus_type;
  72
  73         __le32 target_version;
  74         __le32 fw_version_major;
  75         __le32 fw_version_minor;
  76         __le32 fw_version_release;
  77         __le32 fw_version_build;
  78         __le32 phy_capability;
  79         __le32 hw_min_tx_power;
  80         __le32 hw_max_tx_power;
  81         __le32 ht_cap_info;
  82         __le32 vht_cap_info;
  83         __le32 num_rf_chains;
  84
  85         /* firmware version string */
  86         char fw_ver[ETHTOOL_FWVERS_LEN];
  87
  88         /* Kernel related information */
  89
  90         /* time-of-day stamp */
  91         __le64 tv_sec;
  92
  93         /* time-of-day stamp, nano-seconds */
  94         __le64 tv_nsec;
  95
  96         /* LINUX_VERSION_CODE */
  97         __le32 kernel_ver_code;
  98
  99         /* VERMAGIC_STRING */
 100         char kernel_ver[64];
 101
 102         /* room for growth w/out changing binary format */
 103         u8 unused[128];
 104
 105         /* struct ath10k_tlv_dump_data + more */
 106         u8 data[0];
 107 } __packed;
 108
 109 int ath10k_info(struct ath10k *ar, const char *fmt, ...)
 110 {
 111         struct va_format vaf = {
 112                 .fmt = fmt,
 113         };
 114         va_list args;
 115         int ret;
 116
 117         va_start(args, fmt);
 118         vaf.va = &args;
 119         ret = dev_info(ar->dev, "%pV", &vaf);
 120         trace_ath10k_log_info(ar, &vaf);
 121         va_end(args);
 122
 123         return ret;
 124 }
 125 EXPORT_SYMBOL(ath10k_info);
 126
 127 void ath10k_print_driver_info(struct ath10k *ar)
 128 {
 129         ath10k_info(ar, "%s (0x%08x, 0x%08x) fw %s api %d htt %d.%d\n",
 130                     ar->hw_params.name,
 131                     ar->target_version,
 132                     ar->chip_id,
 133                     ar->hw->wiphy->fw_version,
 134                     ar->fw_api,
 135                     ar->htt.target_version_major,
 136                     ar->htt.target_version_minor);
 137         ath10k_info(ar, "debug %d debugfs %d tracing %d dfs %d testmode %d\n",
 138                     config_enabled(CONFIG_ATH10K_DEBUG),
 139                     config_enabled(CONFIG_ATH10K_DEBUGFS),
 140                     config_enabled(CONFIG_ATH10K_TRACING),
 141                     config_enabled(CONFIG_ATH10K_DFS_CERTIFIED),
 142                     config_enabled(CONFIG_NL80211_TESTMODE));
 143 }
 144 EXPORT_SYMBOL(ath10k_print_driver_info);
 145
 146 int ath10k_err(struct ath10k *ar, const char *fmt, ...)
 147 {
 148         struct va_format vaf = {
 149                 .fmt = fmt,
 150         };
 151         va_list args;
 152         int ret;
 153
 154         va_start(args, fmt);
 155         vaf.va = &args;
 156         ret = dev_err(ar->dev, "%pV", &vaf);
 157         trace_ath10k_log_err(ar, &vaf);
 158         va_end(args);
 159
 160         return ret;
 161 }
 162 EXPORT_SYMBOL(ath10k_err);
 163
 164 int ath10k_warn(struct ath10k *ar, const char *fmt, ...)
 165 {
 166         struct va_format vaf = {
 167                 .fmt = fmt,
 168         };
 169         va_list args;
 170
 171         va_start(args, fmt);
 172         vaf.va = &args;
 173         dev_warn_ratelimited(ar->dev, "%pV", &vaf);
 174         trace_ath10k_log_warn(ar, &vaf);
 175
 176         va_end(args);
 177
 178         return 0;
 179 }
 180 EXPORT_SYMBOL(ath10k_warn);
 181
 182 #ifdef CONFIG_ATH10K_DEBUGFS
 183
 184 void ath10k_debug_read_service_map(struct ath10k *ar,
 185                                    void *service_map,
 186                                    size_t map_size)
 187 {
 188         memcpy(ar->debug.wmi_service_bitmap, service_map, map_size);
 189 }
 190
 191 static ssize_t ath10k_read_wmi_services(struct file *file,
 192                                         char __user *user_buf,
 193                                         size_t count, loff_t *ppos)
 194 {
 195         struct ath10k *ar = file->private_data;
 196         char *buf;
 197         unsigned int len = 0, buf_len = 4096;
 198         const char *name;
 199         ssize_t ret_cnt;
 200         bool enabled;
 201         int i;
 202
 203         buf = kzalloc(buf_len, GFP_KERNEL);
 204         if (!buf)
 205                 return -ENOMEM;
 206
 207         mutex_lock(&ar->conf_mutex);
 208
 209         if (len > buf_len)
 210                 len = buf_len;
 211
 212         for (i = 0; i < WMI_SERVICE_MAX; i++) {
 213                 enabled = test_bit(i, ar->debug.wmi_service_bitmap);
 214                 name = wmi_service_name(i);
 215
 216                 if (!name) {
 217                         if (enabled)
 218                                 len += scnprintf(buf + len, buf_len - len,
 219                                                  "%-40s %s (bit %d)\n",
 220                                                  "unknown", "enabled", i);
 221
 222                         continue;
 223                 }
 224
 225                 len += scnprintf(buf + len, buf_len - len,
 226                                  "%-40s %s\n",
 227                                  name, enabled ? "enabled" : "-");
 228         }
 229
 230         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 231
 232         mutex_unlock(&ar->conf_mutex);
 233
 234         kfree(buf);
 235         return ret_cnt;
 236 }
 237
 238 static const struct file_operations fops_wmi_services = {
 239         .read = ath10k_read_wmi_services,
 240         .open = simple_open,
 241         .owner = THIS_MODULE,
 242         .llseek = default_llseek,
 243 };
 244
 245 void ath10k_debug_read_target_stats(struct ath10k *ar,
 246                                     struct wmi_stats_event *ev)
 247 {
 248         u8 *tmp = ev->data;
 249         struct ath10k_target_stats *stats;
 250         int num_pdev_stats, num_vdev_stats, num_peer_stats;
 251         struct wmi_pdev_stats_10x *ps;
 252         int i;
 253
 254         spin_lock_bh(&ar->data_lock);
 255
 256         stats = &ar->debug.target_stats;
 257
 258         num_pdev_stats = __le32_to_cpu(ev->num_pdev_stats); /* 0 or 1 */
 259         num_vdev_stats = __le32_to_cpu(ev->num_vdev_stats); /* 0 or max vdevs */
 260         num_peer_stats = __le32_to_cpu(ev->num_peer_stats); /* 0 or max peers */
 261
 262         if (num_pdev_stats) {
 263                 ps = (struct wmi_pdev_stats_10x *)tmp;
 264
 265                 stats->ch_noise_floor = __le32_to_cpu(ps->chan_nf);
 266                 stats->tx_frame_count = __le32_to_cpu(ps->tx_frame_count);
 267                 stats->rx_frame_count = __le32_to_cpu(ps->rx_frame_count);
 268                 stats->rx_clear_count = __le32_to_cpu(ps->rx_clear_count);
 269                 stats->cycle_count = __le32_to_cpu(ps->cycle_count);
 270                 stats->phy_err_count = __le32_to_cpu(ps->phy_err_count);
 271                 stats->chan_tx_power = __le32_to_cpu(ps->chan_tx_pwr);
 272
 273                 stats->comp_queued = __le32_to_cpu(ps->wal.tx.comp_queued);
 274                 stats->comp_delivered =
 275                         __le32_to_cpu(ps->wal.tx.comp_delivered);
 276                 stats->msdu_enqued = __le32_to_cpu(ps->wal.tx.msdu_enqued);
 277                 stats->mpdu_enqued = __le32_to_cpu(ps->wal.tx.mpdu_enqued);
 278                 stats->wmm_drop = __le32_to_cpu(ps->wal.tx.wmm_drop);
 279                 stats->local_enqued = __le32_to_cpu(ps->wal.tx.local_enqued);
 280                 stats->local_freed = __le32_to_cpu(ps->wal.tx.local_freed);
 281                 stats->hw_queued = __le32_to_cpu(ps->wal.tx.hw_queued);
 282                 stats->hw_reaped = __le32_to_cpu(ps->wal.tx.hw_reaped);
 283                 stats->underrun = __le32_to_cpu(ps->wal.tx.underrun);
 284                 stats->tx_abort = __le32_to_cpu(ps->wal.tx.tx_abort);
 285                 stats->mpdus_requed = __le32_to_cpu(ps->wal.tx.mpdus_requed);
 286                 stats->tx_ko = __le32_to_cpu(ps->wal.tx.tx_ko);
 287                 stats->data_rc = __le32_to_cpu(ps->wal.tx.data_rc);
 288                 stats->self_triggers = __le32_to_cpu(ps->wal.tx.self_triggers);
 289                 stats->sw_retry_failure =
 290                         __le32_to_cpu(ps->wal.tx.sw_retry_failure);
 291                 stats->illgl_rate_phy_err =
 292                         __le32_to_cpu(ps->wal.tx.illgl_rate_phy_err);
 293                 stats->pdev_cont_xretry =
 294                         __le32_to_cpu(ps->wal.tx.pdev_cont_xretry);
 295                 stats->pdev_tx_timeout =
 296                         __le32_to_cpu(ps->wal.tx.pdev_tx_timeout);
 297                 stats->pdev_resets = __le32_to_cpu(ps->wal.tx.pdev_resets);
 298                 stats->phy_underrun = __le32_to_cpu(ps->wal.tx.phy_underrun);
 299                 stats->txop_ovf = __le32_to_cpu(ps->wal.tx.txop_ovf);
 300
 301                 stats->mid_ppdu_route_change =
 302                         __le32_to_cpu(ps->wal.rx.mid_ppdu_route_change);
 303                 stats->status_rcvd = __le32_to_cpu(ps->wal.rx.status_rcvd);
 304                 stats->r0_frags = __le32_to_cpu(ps->wal.rx.r0_frags);
 305                 stats->r1_frags = __le32_to_cpu(ps->wal.rx.r1_frags);
 306                 stats->r2_frags = __le32_to_cpu(ps->wal.rx.r2_frags);
 307                 stats->r3_frags = __le32_to_cpu(ps->wal.rx.r3_frags);
 308                 stats->htt_msdus = __le32_to_cpu(ps->wal.rx.htt_msdus);
 309                 stats->htt_mpdus = __le32_to_cpu(ps->wal.rx.htt_mpdus);
 310                 stats->loc_msdus = __le32_to_cpu(ps->wal.rx.loc_msdus);
 311                 stats->loc_mpdus = __le32_to_cpu(ps->wal.rx.loc_mpdus);
 312                 stats->oversize_amsdu =
 313                         __le32_to_cpu(ps->wal.rx.oversize_amsdu);
 314                 stats->phy_errs = __le32_to_cpu(ps->wal.rx.phy_errs);
 315                 stats->phy_err_drop = __le32_to_cpu(ps->wal.rx.phy_err_drop);
 316                 stats->mpdu_errs = __le32_to_cpu(ps->wal.rx.mpdu_errs);
 317
 318                 if (test_bit(ATH10K_FW_FEATURE_WMI_10X,
 319                              ar->fw_features)) {
 320                         stats->ack_rx_bad = __le32_to_cpu(ps->ack_rx_bad);
 321                         stats->rts_bad = __le32_to_cpu(ps->rts_bad);
 322                         stats->rts_good = __le32_to_cpu(ps->rts_good);
 323                         stats->fcs_bad = __le32_to_cpu(ps->fcs_bad);
 324                         stats->no_beacons = __le32_to_cpu(ps->no_beacons);
 325                         stats->mib_int_count = __le32_to_cpu(ps->mib_int_count);
 326                         tmp += sizeof(struct wmi_pdev_stats_10x);
 327                 } else {
 328                         tmp += sizeof(struct wmi_pdev_stats_old);
 329                 }
 330         }
 331
 332         /* 0 or max vdevs */
 333         /* Currently firmware does not support VDEV stats */
 334         if (num_vdev_stats) {
 335                 struct wmi_vdev_stats *vdev_stats;
 336
 337                 for (i = 0; i < num_vdev_stats; i++) {
 338                         vdev_stats = (struct wmi_vdev_stats *)tmp;
 339                         tmp += sizeof(struct wmi_vdev_stats);
 340                 }
 341         }
 342
 343         if (num_peer_stats) {
 344                 struct wmi_peer_stats_10x *peer_stats;
 345                 struct ath10k_peer_stat *s;
 346
 347                 stats->peers = num_peer_stats;
 348
 349                 for (i = 0; i < num_peer_stats; i++) {
 350                         peer_stats = (struct wmi_peer_stats_10x *)tmp;
 351                         s = &stats->peer_stat[i];
 352
 353                         memcpy(s->peer_macaddr, &peer_stats->peer_macaddr.addr,
 354                                ETH_ALEN);
 355                         s->peer_rssi = __le32_to_cpu(peer_stats->peer_rssi);
 356                         s->peer_tx_rate =
 357                                 __le32_to_cpu(peer_stats->peer_tx_rate);
 358                         if (test_bit(ATH10K_FW_FEATURE_WMI_10X,
 359                                      ar->fw_features)) {
 360                                 s->peer_rx_rate =
 361                                         __le32_to_cpu(peer_stats->peer_rx_rate);
 362                                 tmp += sizeof(struct wmi_peer_stats_10x);
 363
 364                         } else {
 365                                 tmp += sizeof(struct wmi_peer_stats_old);
 366                         }
 367                 }
 368         }
 369
 370         spin_unlock_bh(&ar->data_lock);
 371         complete(&ar->debug.event_stats_compl);
 372 }
 373
 374 static ssize_t ath10k_read_fw_stats(struct file *file, char __user *user_buf,
 375                                     size_t count, loff_t *ppos)
 376 {
 377         struct ath10k *ar = file->private_data;
 378         struct ath10k_target_stats *fw_stats;
 379         char *buf = NULL;
 380         unsigned int len = 0, buf_len = 8000;
 381         ssize_t ret_cnt = 0;
 382         long left;
 383         int i;
 384         int ret;
 385
 386         fw_stats = &ar->debug.target_stats;
 387
 388         mutex_lock(&ar->conf_mutex);
 389
 390         if (ar->state != ATH10K_STATE_ON)
 391                 goto exit;
 392
 393         buf = kzalloc(buf_len, GFP_KERNEL);
 394         if (!buf)
 395                 goto exit;
 396
 397         ret = ath10k_wmi_request_stats(ar, WMI_REQUEST_PEER_STAT);
 398         if (ret) {
 399                 ath10k_warn(ar, "could not request stats (%d)\n", ret);
 400                 goto exit;
 401         }
 402
 403         left = wait_for_completion_timeout(&ar->debug.event_stats_compl, 1*HZ);
 404         if (left <= 0)
 405                 goto exit;
 406
 407         spin_lock_bh(&ar->data_lock);
 408         len += scnprintf(buf + len, buf_len - len, "\n");
 409         len += scnprintf(buf + len, buf_len - len, "%30s\n",
 410                          "ath10k PDEV stats");
 411         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
 412                                  "=================");
 413
 414         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 415                          "Channel noise floor", fw_stats->ch_noise_floor);
 416         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 417                          "Channel TX power", fw_stats->chan_tx_power);
 418         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 419                          "TX frame count", fw_stats->tx_frame_count);
 420         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 421                          "RX frame count", fw_stats->rx_frame_count);
 422         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 423                          "RX clear count", fw_stats->rx_clear_count);
 424         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 425                          "Cycle count", fw_stats->cycle_count);
 426         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 427                          "PHY error count", fw_stats->phy_err_count);
 428         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 429                          "RTS bad count", fw_stats->rts_bad);
 430         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 431                          "RTS good count", fw_stats->rts_good);
 432         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 433                          "FCS bad count", fw_stats->fcs_bad);
 434         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 435                          "No beacon count", fw_stats->no_beacons);
 436         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
 437                          "MIB int count", fw_stats->mib_int_count);
 438
 439         len += scnprintf(buf + len, buf_len - len, "\n");
 440         len += scnprintf(buf + len, buf_len - len, "%30s\n",
 441                          "ath10k PDEV TX stats");
 442         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
 443                                  "=================");
 444
 445         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 446                          "HTT cookies queued", fw_stats->comp_queued);
 447         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 448                          "HTT cookies disp.", fw_stats->comp_delivered);
 449         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 450                          "MSDU queued", fw_stats->msdu_enqued);
 451         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 452                          "MPDU queued", fw_stats->mpdu_enqued);
 453         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 454                          "MSDUs dropped", fw_stats->wmm_drop);
 455         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 456                          "Local enqued", fw_stats->local_enqued);
 457         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 458                          "Local freed", fw_stats->local_freed);
 459         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 460                          "HW queued", fw_stats->hw_queued);
 461         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 462                          "PPDUs reaped", fw_stats->hw_reaped);
 463         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 464                          "Num underruns", fw_stats->underrun);
 465         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 466                          "PPDUs cleaned", fw_stats->tx_abort);
 467         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 468                          "MPDUs requed", fw_stats->mpdus_requed);
 469         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 470                          "Excessive retries", fw_stats->tx_ko);
 471         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 472                          "HW rate", fw_stats->data_rc);
 473         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 474                          "Sched self tiggers", fw_stats->self_triggers);
 475         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 476                          "Dropped due to SW retries",
 477                          fw_stats->sw_retry_failure);
 478         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 479                          "Illegal rate phy errors",
 480                          fw_stats->illgl_rate_phy_err);
 481         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 482                          "Pdev continous xretry", fw_stats->pdev_cont_xretry);
 483         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 484                          "TX timeout", fw_stats->pdev_tx_timeout);
 485         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 486                          "PDEV resets", fw_stats->pdev_resets);
 487         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 488                          "PHY underrun", fw_stats->phy_underrun);
 489         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 490                          "MPDU is more than txop limit", fw_stats->txop_ovf);
 491
 492         len += scnprintf(buf + len, buf_len - len, "\n");
 493         len += scnprintf(buf + len, buf_len - len, "%30s\n",
 494                          "ath10k PDEV RX stats");
 495         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
 496                                  "=================");
 497
 498         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 499                          "Mid PPDU route change",
 500                          fw_stats->mid_ppdu_route_change);
 501         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 502                          "Tot. number of statuses", fw_stats->status_rcvd);
 503         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 504                          "Extra frags on rings 0", fw_stats->r0_frags);
 505         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 506                          "Extra frags on rings 1", fw_stats->r1_frags);
 507         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 508                          "Extra frags on rings 2", fw_stats->r2_frags);
 509         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 510                          "Extra frags on rings 3", fw_stats->r3_frags);
 511         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 512                          "MSDUs delivered to HTT", fw_stats->htt_msdus);
 513         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 514                          "MPDUs delivered to HTT", fw_stats->htt_mpdus);
 515         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 516                          "MSDUs delivered to stack", fw_stats->loc_msdus);
 517         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 518                          "MPDUs delivered to stack", fw_stats->loc_mpdus);
 519         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 520                          "Oversized AMSUs", fw_stats->oversize_amsdu);
 521         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 522                          "PHY errors", fw_stats->phy_errs);
 523         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 524                          "PHY errors drops", fw_stats->phy_err_drop);
 525         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
 526                          "MPDU errors (FCS, MIC, ENC)", fw_stats->mpdu_errs);
 527
 528         len += scnprintf(buf + len, buf_len - len, "\n");
 529         len += scnprintf(buf + len, buf_len - len, "%30s (%d)\n",
 530                          "ath10k PEER stats", fw_stats->peers);
 531         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
 532                                  "=================");
 533
 534         for (i = 0; i < fw_stats->peers; i++) {
 535                 len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
 536                                  "Peer MAC address",
 537                                  fw_stats->peer_stat[i].peer_macaddr);
 538                 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
 539                                  "Peer RSSI", fw_stats->peer_stat[i].peer_rssi);
 540                 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
 541                                  "Peer TX rate",
 542                                  fw_stats->peer_stat[i].peer_tx_rate);
 543                 len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
 544                                  "Peer RX rate",
 545                                  fw_stats->peer_stat[i].peer_rx_rate);
 546                 len += scnprintf(buf + len, buf_len - len, "\n");
 547         }
 548         spin_unlock_bh(&ar->data_lock);
 549
 550         if (len > buf_len)
 551                 len = buf_len;
 552
 553         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 554
 555 exit:
 556         mutex_unlock(&ar->conf_mutex);
 557         kfree(buf);
 558         return ret_cnt;
 559 }
 560
 561 static const struct file_operations fops_fw_stats = {
 562         .read = ath10k_read_fw_stats,
 563         .open = simple_open,
 564         .owner = THIS_MODULE,
 565         .llseek = default_llseek,
 566 };
 567
 568 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
 569                                              char __user *user_buf,
 570                                              size_t count, loff_t *ppos)
 571 {
 572         const char buf[] = "To simulate firmware crash write one of the"
 573                            " keywords to this file:\n `soft` - this will send"
 574                            " WMI_FORCE_FW_HANG_ASSERT to firmware if FW"
 575                            " supports that command.\n `hard` - this will send"
 576                            " to firmware command with illegal parameters"
 577                            " causing firmware crash.\n";
 578
 579         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
 580 }
 581
 582 /* Simulate firmware crash:
 583  * 'soft': Call wmi command causing firmware hang. This firmware hang is
 584  * recoverable by warm firmware reset.
 585  * 'hard': Force firmware crash by setting any vdev parameter for not allowed
 586  * vdev id. This is hard firmware crash because it is recoverable only by cold
 587  * firmware reset.
 588  */
 589 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
 590                                               const char __user *user_buf,
 591                                               size_t count, loff_t *ppos)
 592 {
 593         struct ath10k *ar = file->private_data;
 594         char buf[32];
 595         int ret;
 596
 597         mutex_lock(&ar->conf_mutex);
 598
 599         simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
 600
 601         /* make sure that buf is null terminated */
 602         buf[sizeof(buf) - 1] = 0;
 603
 604         if (ar->state != ATH10K_STATE_ON &&
 605             ar->state != ATH10K_STATE_RESTARTED) {
 606                 ret = -ENETDOWN;
 607                 goto exit;
 608         }
 609
 610         /* drop the possible '\n' from the end */
 611         if (buf[count - 1] == '\n') {
 612                 buf[count - 1] = 0;
 613                 count--;
 614         }
 615
 616         if (!strcmp(buf, "soft")) {
 617                 ath10k_info(ar, "simulating soft firmware crash\n");
 618                 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
 619         } else if (!strcmp(buf, "hard")) {
 620                 ath10k_info(ar, "simulating hard firmware crash\n");
 621                 /* 0x7fff is vdev id, and it is always out of range for all
 622                  * firmware variants in order to force a firmware crash.
 623                  */
 624                 ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
 625                                         ar->wmi.vdev_param->rts_threshold, 0);
 626         } else {
 627                 ret = -EINVAL;
 628                 goto exit;
 629         }
 630
 631         if (ret) {
 632                 ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
 633                 goto exit;
 634         }
 635
 636         ret = count;
 637
 638 exit:
 639         mutex_unlock(&ar->conf_mutex);
 640         return ret;
 641 }
 642
 643 static const struct file_operations fops_simulate_fw_crash = {
 644         .read = ath10k_read_simulate_fw_crash,
 645         .write = ath10k_write_simulate_fw_crash,
 646         .open = simple_open,
 647         .owner = THIS_MODULE,
 648         .llseek = default_llseek,
 649 };
 650
 651 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
 652                                    size_t count, loff_t *ppos)
 653 {
 654         struct ath10k *ar = file->private_data;
 655         unsigned int len;
 656         char buf[50];
 657
 658         len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->chip_id);
 659
 660         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 661 }
 662
 663 static const struct file_operations fops_chip_id = {
 664         .read = ath10k_read_chip_id,
 665         .open = simple_open,
 666         .owner = THIS_MODULE,
 667         .llseek = default_llseek,
 668 };
 669
 670 struct ath10k_fw_crash_data *
 671 ath10k_debug_get_new_fw_crash_data(struct ath10k *ar)
 672 {
 673         struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
 674
 675         lockdep_assert_held(&ar->data_lock);
 676
 677         crash_data->crashed_since_read = true;
 678         uuid_le_gen(&crash_data->uuid);
 679         getnstimeofday(&crash_data->timestamp);
 680
 681         return crash_data;
 682 }
 683 EXPORT_SYMBOL(ath10k_debug_get_new_fw_crash_data);
 684
 685 static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 686 {
 687         struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
 688         struct ath10k_dump_file_data *dump_data;
 689         struct ath10k_tlv_dump_data *dump_tlv;
 690         int hdr_len = sizeof(*dump_data);
 691         unsigned int len, sofar = 0;
 692         unsigned char *buf;
 693
 694         len = hdr_len;
 695         len += sizeof(*dump_tlv) + sizeof(crash_data->registers);
 696
 697         sofar += hdr_len;
 698
 699         /* This is going to get big when we start dumping FW RAM and such,
 700          * so go ahead and use vmalloc.
 701          */
 702         buf = vzalloc(len);
 703         if (!buf)
 704                 return NULL;
 705
 706         spin_lock_bh(&ar->data_lock);
 707
 708         if (!crash_data->crashed_since_read) {
 709                 spin_unlock_bh(&ar->data_lock);
 710                 vfree(buf);
 711                 return NULL;
 712         }
 713
 714         dump_data = (struct ath10k_dump_file_data *)(buf);
 715         strlcpy(dump_data->df_magic, "ATH10K-FW-DUMP",
 716                 sizeof(dump_data->df_magic));
 717         dump_data->len = cpu_to_le32(len);
 718
 719         dump_data->version = cpu_to_le32(ATH10K_FW_CRASH_DUMP_VERSION);
 720
 721         memcpy(dump_data->uuid, &crash_data->uuid, sizeof(dump_data->uuid));
 722         dump_data->chip_id = cpu_to_le32(ar->chip_id);
 723         dump_data->bus_type = cpu_to_le32(0);
 724         dump_data->target_version = cpu_to_le32(ar->target_version);
 725         dump_data->fw_version_major = cpu_to_le32(ar->fw_version_major);
 726         dump_data->fw_version_minor = cpu_to_le32(ar->fw_version_minor);
 727         dump_data->fw_version_release = cpu_to_le32(ar->fw_version_release);
 728         dump_data->fw_version_build = cpu_to_le32(ar->fw_version_build);
 729         dump_data->phy_capability = cpu_to_le32(ar->phy_capability);
 730         dump_data->hw_min_tx_power = cpu_to_le32(ar->hw_min_tx_power);
 731         dump_data->hw_max_tx_power = cpu_to_le32(ar->hw_max_tx_power);
 732         dump_data->ht_cap_info = cpu_to_le32(ar->ht_cap_info);
 733         dump_data->vht_cap_info = cpu_to_le32(ar->vht_cap_info);
 734         dump_data->num_rf_chains = cpu_to_le32(ar->num_rf_chains);
 735
 736         strlcpy(dump_data->fw_ver, ar->hw->wiphy->fw_version,
 737                 sizeof(dump_data->fw_ver));
 738
 739         dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
 740         strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
 741                 sizeof(dump_data->kernel_ver));
 742
 743         dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
 744         dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
 745
 746         /* Gather crash-dump */
 747         dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
 748         dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGISTERS);
 749         dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->registers));
 750         memcpy(dump_tlv->tlv_data, &crash_data->registers,
 751                sizeof(crash_data->registers));
 752         sofar += sizeof(*dump_tlv) + sizeof(crash_data->registers);
 753
 754         ar->debug.fw_crash_data->crashed_since_read = false;
 755
 756         spin_unlock_bh(&ar->data_lock);
 757
 758         return dump_data;
 759 }
 760
 761 static int ath10k_fw_crash_dump_open(struct inode *inode, struct file *file)
 762 {
 763         struct ath10k *ar = inode->i_private;
 764         struct ath10k_dump_file_data *dump;
 765
 766         dump = ath10k_build_dump_file(ar);
 767         if (!dump)
 768                 return -ENODATA;
 769
 770         file->private_data = dump;
 771
 772         return 0;
 773 }
 774
 775 static ssize_t ath10k_fw_crash_dump_read(struct file *file,
 776                                          char __user *user_buf,
 777                                          size_t count, loff_t *ppos)
 778 {
 779         struct ath10k_dump_file_data *dump_file = file->private_data;
 780
 781         return simple_read_from_buffer(user_buf, count, ppos,
 782                                        dump_file,
 783                                        le32_to_cpu(dump_file->len));
 784 }
 785
 786 static int ath10k_fw_crash_dump_release(struct inode *inode,
 787                                         struct file *file)
 788 {
 789         vfree(file->private_data);
 790
 791         return 0;
 792 }
 793
 794 static const struct file_operations fops_fw_crash_dump = {
 795         .open = ath10k_fw_crash_dump_open,
 796         .read = ath10k_fw_crash_dump_read,
 797         .release = ath10k_fw_crash_dump_release,
 798         .owner = THIS_MODULE,
 799         .llseek = default_llseek,
 800 };
 801
 802 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
 803 {
 804         u64 cookie;
 805         int ret;
 806
 807         lockdep_assert_held(&ar->conf_mutex);
 808
 809         if (ar->debug.htt_stats_mask == 0)
 810                 /* htt stats are disabled */
 811                 return 0;
 812
 813         if (ar->state != ATH10K_STATE_ON)
 814                 return 0;
 815
 816         cookie = get_jiffies_64();
 817
 818         ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
 819                                        cookie);
 820         if (ret) {
 821                 ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
 822                 return ret;
 823         }
 824
 825         queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
 826                            msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
 827
 828         return 0;
 829 }
 830
 831 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
 832 {
 833         struct ath10k *ar = container_of(work, struct ath10k,
 834                                          debug.htt_stats_dwork.work);
 835
 836         mutex_lock(&ar->conf_mutex);
 837
 838         ath10k_debug_htt_stats_req(ar);
 839
 840         mutex_unlock(&ar->conf_mutex);
 841 }
 842
 843 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
 844                                             char __user *user_buf,
 845                                             size_t count, loff_t *ppos)
 846 {
 847         struct ath10k *ar = file->private_data;
 848         char buf[32];
 849         unsigned int len;
 850
 851         len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
 852
 853         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 854 }
 855
 856 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
 857                                              const char __user *user_buf,
 858                                              size_t count, loff_t *ppos)
 859 {
 860         struct ath10k *ar = file->private_data;
 861         unsigned long mask;
 862         int ret;
 863
 864         ret = kstrtoul_from_user(user_buf, count, 0, &mask);
 865         if (ret)
 866                 return ret;
 867
 868         /* max 8 bit masks (for now) */
 869         if (mask > 0xff)
 870                 return -E2BIG;
 871
 872         mutex_lock(&ar->conf_mutex);
 873
 874         ar->debug.htt_stats_mask = mask;
 875
 876         ret = ath10k_debug_htt_stats_req(ar);
 877         if (ret)
 878                 goto out;
 879
 880         ret = count;
 881
 882 out:
 883         mutex_unlock(&ar->conf_mutex);
 884
 885         return ret;
 886 }
 887
 888 static const struct file_operations fops_htt_stats_mask = {
 889         .read = ath10k_read_htt_stats_mask,
 890         .write = ath10k_write_htt_stats_mask,
 891         .open = simple_open,
 892         .owner = THIS_MODULE,
 893         .llseek = default_llseek,
 894 };
 895
 896 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
 897                                                char __user *user_buf,
 898                                                size_t count, loff_t *ppos)
 899 {
 900         struct ath10k *ar = file->private_data;
 901         char buf[64];
 902         u8 amsdu = 3, ampdu = 64;
 903         unsigned int len;
 904
 905         mutex_lock(&ar->conf_mutex);
 906
 907         if (ar->debug.htt_max_amsdu)
 908                 amsdu = ar->debug.htt_max_amsdu;
 909
 910         if (ar->debug.htt_max_ampdu)
 911                 ampdu = ar->debug.htt_max_ampdu;
 912
 913         mutex_unlock(&ar->conf_mutex);
 914
 915         len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
 916
 917         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 918 }
 919
 920 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
 921                                                 const char __user *user_buf,
 922                                                 size_t count, loff_t *ppos)
 923 {
 924         struct ath10k *ar = file->private_data;
 925         int res;
 926         char buf[64];
 927         unsigned int amsdu, ampdu;
 928
 929         simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
 930
 931         /* make sure that buf is null terminated */
 932         buf[sizeof(buf) - 1] = 0;
 933
 934         res = sscanf(buf, "%u %u", &amsdu, &ampdu);
 935
 936         if (res != 2)
 937                 return -EINVAL;
 938
 939         mutex_lock(&ar->conf_mutex);
 940
 941         res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
 942         if (res)
 943                 goto out;
 944
 945         res = count;
 946         ar->debug.htt_max_amsdu = amsdu;
 947         ar->debug.htt_max_ampdu = ampdu;
 948
 949 out:
 950         mutex_unlock(&ar->conf_mutex);
 951         return res;
 952 }
 953
 954 static const struct file_operations fops_htt_max_amsdu_ampdu = {
 955         .read = ath10k_read_htt_max_amsdu_ampdu,
 956         .write = ath10k_write_htt_max_amsdu_ampdu,
 957         .open = simple_open,
 958         .owner = THIS_MODULE,
 959         .llseek = default_llseek,
 960 };
 961
 962 static ssize_t ath10k_read_fw_dbglog(struct file *file,
 963                                             char __user *user_buf,
 964                                             size_t count, loff_t *ppos)
 965 {
 966         struct ath10k *ar = file->private_data;
 967         unsigned int len;
 968         char buf[32];
 969
 970         len = scnprintf(buf, sizeof(buf), "0x%08x\n",
 971                         ar->debug.fw_dbglog_mask);
 972
 973         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 974 }
 975
 976 static ssize_t ath10k_write_fw_dbglog(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         unsigned long mask;
 982         int ret;
 983
 984         ret = kstrtoul_from_user(user_buf, count, 0, &mask);
 985         if (ret)
 986                 return ret;
 987
 988         mutex_lock(&ar->conf_mutex);
 989
 990         ar->debug.fw_dbglog_mask = mask;
 991
 992         if (ar->state == ATH10K_STATE_ON) {
 993                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask);
 994                 if (ret) {
 995                         ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
 996                                     ret);
 997                         goto exit;
 998                 }
 999         }
1000
1001         ret = count;
1002
1003 exit:
1004         mutex_unlock(&ar->conf_mutex);
1005
1006         return ret;
1007 }
1008
1009 static const struct file_operations fops_fw_dbglog = {
1010         .read = ath10k_read_fw_dbglog,
1011         .write = ath10k_write_fw_dbglog,
1012         .open = simple_open,
1013         .owner = THIS_MODULE,
1014         .llseek = default_llseek,
1015 };
1016
1017 int ath10k_debug_start(struct ath10k *ar)
1018 {
1019         int ret;
1020
1021         lockdep_assert_held(&ar->conf_mutex);
1022
1023         ret = ath10k_debug_htt_stats_req(ar);
1024         if (ret)
1025                 /* continue normally anyway, this isn't serious */
1026                 ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1027                             ret);
1028
1029         if (ar->debug.fw_dbglog_mask) {
1030                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask);
1031                 if (ret)
1032                         /* not serious */
1033                         ath10k_warn(ar, "failed to enable dbglog during start: %d",
1034                                     ret);
1035         }
1036
1037         return 0;
1038 }
1039
1040 void ath10k_debug_stop(struct ath10k *ar)
1041 {
1042         lockdep_assert_held(&ar->conf_mutex);
1043
1044         /* Must not use _sync to avoid deadlock, we do that in
1045          * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1046          * warning from del_timer(). */
1047         if (ar->debug.htt_stats_mask != 0)
1048                 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1049
1050         ar->debug.htt_max_amsdu = 0;
1051         ar->debug.htt_max_ampdu = 0;
1052 }
1053
1054 static ssize_t ath10k_write_simulate_radar(struct file *file,
1055                                            const char __user *user_buf,
1056                                            size_t count, loff_t *ppos)
1057 {
1058         struct ath10k *ar = file->private_data;
1059
1060         ieee80211_radar_detected(ar->hw);
1061
1062         return count;
1063 }
1064
1065 static const struct file_operations fops_simulate_radar = {
1066         .write = ath10k_write_simulate_radar,
1067         .open = simple_open,
1068         .owner = THIS_MODULE,
1069         .llseek = default_llseek,
1070 };
1071
1072 #define ATH10K_DFS_STAT(s, p) (\
1073         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1074                          ar->debug.dfs_stats.p))
1075
1076 #define ATH10K_DFS_POOL_STAT(s, p) (\
1077         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1078                          ar->debug.dfs_pool_stats.p))
1079
1080 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1081                                      size_t count, loff_t *ppos)
1082 {
1083         int retval = 0, len = 0;
1084         const int size = 8000;
1085         struct ath10k *ar = file->private_data;
1086         char *buf;
1087
1088         buf = kzalloc(size, GFP_KERNEL);
1089         if (buf == NULL)
1090                 return -ENOMEM;
1091
1092         if (!ar->dfs_detector) {
1093                 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1094                 goto exit;
1095         }
1096
1097         ar->debug.dfs_pool_stats =
1098                         ar->dfs_detector->get_stats(ar->dfs_detector);
1099
1100         len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1101
1102         ATH10K_DFS_STAT("reported phy errors", phy_errors);
1103         ATH10K_DFS_STAT("pulse events reported", pulses_total);
1104         ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1105         ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1106         ATH10K_DFS_STAT("Radars detected", radar_detected);
1107
1108         len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1109         ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1110         ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1111         ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1112         ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1113         ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1114         ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1115         ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1116
1117 exit:
1118         if (len > size)
1119                 len = size;
1120
1121         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1122         kfree(buf);
1123
1124         return retval;
1125 }
1126
1127 static const struct file_operations fops_dfs_stats = {
1128         .read = ath10k_read_dfs_stats,
1129         .open = simple_open,
1130         .owner = THIS_MODULE,
1131         .llseek = default_llseek,
1132 };
1133
1134 int ath10k_debug_create(struct ath10k *ar)
1135 {
1136         ar->debug.fw_crash_data = vzalloc(sizeof(*ar->debug.fw_crash_data));
1137         if (!ar->debug.fw_crash_data)
1138                 return -ENOMEM;
1139
1140         return 0;
1141 }
1142
1143 void ath10k_debug_destroy(struct ath10k *ar)
1144 {
1145         vfree(ar->debug.fw_crash_data);
1146         ar->debug.fw_crash_data = NULL;
1147 }
1148
1149 int ath10k_debug_register(struct ath10k *ar)
1150 {
1151         ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
1152                                                    ar->hw->wiphy->debugfsdir);
1153         if (!ar->debug.debugfs_phy)
1154                 return -ENOMEM;
1155
1156         INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
1157                           ath10k_debug_htt_stats_dwork);
1158
1159         init_completion(&ar->debug.event_stats_compl);
1160
1161         debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
1162                             &fops_fw_stats);
1163
1164         debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
1165                             &fops_wmi_services);
1166
1167         debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy,
1168                             ar, &fops_simulate_fw_crash);
1169
1170         debugfs_create_file("fw_crash_dump", S_IRUSR, ar->debug.debugfs_phy,
1171                             ar, &fops_fw_crash_dump);
1172
1173         debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
1174                             ar, &fops_chip_id);
1175
1176         debugfs_create_file("htt_stats_mask", S_IRUSR, ar->debug.debugfs_phy,
1177                             ar, &fops_htt_stats_mask);
1178
1179         debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
1180                             ar->debug.debugfs_phy, ar,
1181                             &fops_htt_max_amsdu_ampdu);
1182
1183         debugfs_create_file("fw_dbglog", S_IRUSR, ar->debug.debugfs_phy,
1184                             ar, &fops_fw_dbglog);
1185
1186         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
1187                 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
1188                                     ar->debug.debugfs_phy, ar,
1189                                     &fops_simulate_radar);
1190
1191                 debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
1192                                     ar->debug.debugfs_phy,
1193                                     &ar->dfs_block_radar_events);
1194
1195                 debugfs_create_file("dfs_stats", S_IRUSR,
1196                                     ar->debug.debugfs_phy, ar,
1197                                     &fops_dfs_stats);
1198         }
1199
1200         return 0;
1201 }
1202
1203 void ath10k_debug_unregister(struct ath10k *ar)
1204 {
1205         cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
1206 }
1207
1208 #endif /* CONFIG_ATH10K_DEBUGFS */
1209
1210 #ifdef CONFIG_ATH10K_DEBUG
1211 void ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
1212                 const char *fmt, ...)
1213 {
1214         struct va_format vaf;
1215         va_list args;
1216
1217         va_start(args, fmt);
1218
1219         vaf.fmt = fmt;
1220         vaf.va = &args;
1221
1222         if (ath10k_debug_mask & mask)
1223                 dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
1224
1225         trace_ath10k_log_dbg(ar, mask, &vaf);
1226
1227         va_end(args);
1228 }
1229 EXPORT_SYMBOL(ath10k_dbg);
1230
1231 void ath10k_dbg_dump(struct ath10k *ar,
1232                      enum ath10k_debug_mask mask,
1233                      const char *msg, const char *prefix,
1234                      const void *buf, size_t len)
1235 {
1236         if (ath10k_debug_mask & mask) {
1237                 if (msg)
1238                         ath10k_dbg(ar, mask, "%s\n", msg);
1239
1240                 print_hex_dump_bytes(prefix, DUMP_PREFIX_OFFSET, buf, len);
1241         }
1242
1243         /* tracing code doesn't like null strings :/ */
1244         trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
1245                                   buf, len);
1246 }
1247 EXPORT_SYMBOL(ath10k_dbg_dump);
1248
1249 #endif /* CONFIG_ATH10K_DEBUG */