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 /* This is a clean assert crash in firmware. */
 569 static int ath10k_debug_fw_assert(struct ath10k *ar)
 570 {
 571         struct wmi_vdev_install_key_cmd *cmd;
 572         struct sk_buff *skb;
 573
 574         skb = ath10k_wmi_alloc_skb(ar, sizeof(*cmd) + 16);
 575         if (!skb)
 576                 return -ENOMEM;
 577
 578         cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
 579         memset(cmd, 0, sizeof(*cmd));
 580
 581         /* big enough number so that firmware asserts */
 582         cmd->vdev_id = __cpu_to_le32(0x7ffe);
 583
 584         return ath10k_wmi_cmd_send(ar, skb,
 585                                    ar->wmi.cmd->vdev_install_key_cmdid);
 586 }
 587
 588 static ssize_t ath10k_read_simulate_fw_crash(struct file *file,
 589                                              char __user *user_buf,
 590                                              size_t count, loff_t *ppos)
 591 {
 592         const char buf[] =
 593                 "To simulate firmware crash write one of the keywords to this file:\n"
 594                 "`soft` - this will send WMI_FORCE_FW_HANG_ASSERT to firmware if FW supports that command.\n"
 595                 "`hard` - this will send to firmware command with illegal parameters causing firmware crash.\n"
 596                 "`assert` - this will send special illegal parameter to firmware to cause assert failure and crash.\n";
 597
 598         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
 599 }
 600
 601 /* Simulate firmware crash:
 602  * 'soft': Call wmi command causing firmware hang. This firmware hang is
 603  * recoverable by warm firmware reset.
 604  * 'hard': Force firmware crash by setting any vdev parameter for not allowed
 605  * vdev id. This is hard firmware crash because it is recoverable only by cold
 606  * firmware reset.
 607  */
 608 static ssize_t ath10k_write_simulate_fw_crash(struct file *file,
 609                                               const char __user *user_buf,
 610                                               size_t count, loff_t *ppos)
 611 {
 612         struct ath10k *ar = file->private_data;
 613         char buf[32];
 614         int ret;
 615
 616         mutex_lock(&ar->conf_mutex);
 617
 618         simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
 619
 620         /* make sure that buf is null terminated */
 621         buf[sizeof(buf) - 1] = 0;
 622
 623         if (ar->state != ATH10K_STATE_ON &&
 624             ar->state != ATH10K_STATE_RESTARTED) {
 625                 ret = -ENETDOWN;
 626                 goto exit;
 627         }
 628
 629         /* drop the possible '\n' from the end */
 630         if (buf[count - 1] == '\n') {
 631                 buf[count - 1] = 0;
 632                 count--;
 633         }
 634
 635         if (!strcmp(buf, "soft")) {
 636                 ath10k_info(ar, "simulating soft firmware crash\n");
 637                 ret = ath10k_wmi_force_fw_hang(ar, WMI_FORCE_FW_HANG_ASSERT, 0);
 638         } else if (!strcmp(buf, "hard")) {
 639                 ath10k_info(ar, "simulating hard firmware crash\n");
 640                 /* 0x7fff is vdev id, and it is always out of range for all
 641                  * firmware variants in order to force a firmware crash.
 642                  */
 643                 ret = ath10k_wmi_vdev_set_param(ar, 0x7fff,
 644                                                 ar->wmi.vdev_param->rts_threshold,
 645                                                 0);
 646         } else if (!strcmp(buf, "assert")) {
 647                 ath10k_info(ar, "simulating firmware assert crash\n");
 648                 ret = ath10k_debug_fw_assert(ar);
 649         } else {
 650                 ret = -EINVAL;
 651                 goto exit;
 652         }
 653
 654         if (ret) {
 655                 ath10k_warn(ar, "failed to simulate firmware crash: %d\n", ret);
 656                 goto exit;
 657         }
 658
 659         ret = count;
 660
 661 exit:
 662         mutex_unlock(&ar->conf_mutex);
 663         return ret;
 664 }
 665
 666 static const struct file_operations fops_simulate_fw_crash = {
 667         .read = ath10k_read_simulate_fw_crash,
 668         .write = ath10k_write_simulate_fw_crash,
 669         .open = simple_open,
 670         .owner = THIS_MODULE,
 671         .llseek = default_llseek,
 672 };
 673
 674 static ssize_t ath10k_read_chip_id(struct file *file, char __user *user_buf,
 675                                    size_t count, loff_t *ppos)
 676 {
 677         struct ath10k *ar = file->private_data;
 678         unsigned int len;
 679         char buf[50];
 680
 681         len = scnprintf(buf, sizeof(buf), "0x%08x\n", ar->chip_id);
 682
 683         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 684 }
 685
 686 static const struct file_operations fops_chip_id = {
 687         .read = ath10k_read_chip_id,
 688         .open = simple_open,
 689         .owner = THIS_MODULE,
 690         .llseek = default_llseek,
 691 };
 692
 693 struct ath10k_fw_crash_data *
 694 ath10k_debug_get_new_fw_crash_data(struct ath10k *ar)
 695 {
 696         struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
 697
 698         lockdep_assert_held(&ar->data_lock);
 699
 700         crash_data->crashed_since_read = true;
 701         uuid_le_gen(&crash_data->uuid);
 702         getnstimeofday(&crash_data->timestamp);
 703
 704         return crash_data;
 705 }
 706 EXPORT_SYMBOL(ath10k_debug_get_new_fw_crash_data);
 707
 708 static struct ath10k_dump_file_data *ath10k_build_dump_file(struct ath10k *ar)
 709 {
 710         struct ath10k_fw_crash_data *crash_data = ar->debug.fw_crash_data;
 711         struct ath10k_dump_file_data *dump_data;
 712         struct ath10k_tlv_dump_data *dump_tlv;
 713         int hdr_len = sizeof(*dump_data);
 714         unsigned int len, sofar = 0;
 715         unsigned char *buf;
 716
 717         len = hdr_len;
 718         len += sizeof(*dump_tlv) + sizeof(crash_data->registers);
 719
 720         sofar += hdr_len;
 721
 722         /* This is going to get big when we start dumping FW RAM and such,
 723          * so go ahead and use vmalloc.
 724          */
 725         buf = vzalloc(len);
 726         if (!buf)
 727                 return NULL;
 728
 729         spin_lock_bh(&ar->data_lock);
 730
 731         if (!crash_data->crashed_since_read) {
 732                 spin_unlock_bh(&ar->data_lock);
 733                 vfree(buf);
 734                 return NULL;
 735         }
 736
 737         dump_data = (struct ath10k_dump_file_data *)(buf);
 738         strlcpy(dump_data->df_magic, "ATH10K-FW-DUMP",
 739                 sizeof(dump_data->df_magic));
 740         dump_data->len = cpu_to_le32(len);
 741
 742         dump_data->version = cpu_to_le32(ATH10K_FW_CRASH_DUMP_VERSION);
 743
 744         memcpy(dump_data->uuid, &crash_data->uuid, sizeof(dump_data->uuid));
 745         dump_data->chip_id = cpu_to_le32(ar->chip_id);
 746         dump_data->bus_type = cpu_to_le32(0);
 747         dump_data->target_version = cpu_to_le32(ar->target_version);
 748         dump_data->fw_version_major = cpu_to_le32(ar->fw_version_major);
 749         dump_data->fw_version_minor = cpu_to_le32(ar->fw_version_minor);
 750         dump_data->fw_version_release = cpu_to_le32(ar->fw_version_release);
 751         dump_data->fw_version_build = cpu_to_le32(ar->fw_version_build);
 752         dump_data->phy_capability = cpu_to_le32(ar->phy_capability);
 753         dump_data->hw_min_tx_power = cpu_to_le32(ar->hw_min_tx_power);
 754         dump_data->hw_max_tx_power = cpu_to_le32(ar->hw_max_tx_power);
 755         dump_data->ht_cap_info = cpu_to_le32(ar->ht_cap_info);
 756         dump_data->vht_cap_info = cpu_to_le32(ar->vht_cap_info);
 757         dump_data->num_rf_chains = cpu_to_le32(ar->num_rf_chains);
 758
 759         strlcpy(dump_data->fw_ver, ar->hw->wiphy->fw_version,
 760                 sizeof(dump_data->fw_ver));
 761
 762         dump_data->kernel_ver_code = cpu_to_le32(LINUX_VERSION_CODE);
 763         strlcpy(dump_data->kernel_ver, VERMAGIC_STRING,
 764                 sizeof(dump_data->kernel_ver));
 765
 766         dump_data->tv_sec = cpu_to_le64(crash_data->timestamp.tv_sec);
 767         dump_data->tv_nsec = cpu_to_le64(crash_data->timestamp.tv_nsec);
 768
 769         /* Gather crash-dump */
 770         dump_tlv = (struct ath10k_tlv_dump_data *)(buf + sofar);
 771         dump_tlv->type = cpu_to_le32(ATH10K_FW_CRASH_DUMP_REGISTERS);
 772         dump_tlv->tlv_len = cpu_to_le32(sizeof(crash_data->registers));
 773         memcpy(dump_tlv->tlv_data, &crash_data->registers,
 774                sizeof(crash_data->registers));
 775         sofar += sizeof(*dump_tlv) + sizeof(crash_data->registers);
 776
 777         ar->debug.fw_crash_data->crashed_since_read = false;
 778
 779         spin_unlock_bh(&ar->data_lock);
 780
 781         return dump_data;
 782 }
 783
 784 static int ath10k_fw_crash_dump_open(struct inode *inode, struct file *file)
 785 {
 786         struct ath10k *ar = inode->i_private;
 787         struct ath10k_dump_file_data *dump;
 788
 789         dump = ath10k_build_dump_file(ar);
 790         if (!dump)
 791                 return -ENODATA;
 792
 793         file->private_data = dump;
 794
 795         return 0;
 796 }
 797
 798 static ssize_t ath10k_fw_crash_dump_read(struct file *file,
 799                                          char __user *user_buf,
 800                                          size_t count, loff_t *ppos)
 801 {
 802         struct ath10k_dump_file_data *dump_file = file->private_data;
 803
 804         return simple_read_from_buffer(user_buf, count, ppos,
 805                                        dump_file,
 806                                        le32_to_cpu(dump_file->len));
 807 }
 808
 809 static int ath10k_fw_crash_dump_release(struct inode *inode,
 810                                         struct file *file)
 811 {
 812         vfree(file->private_data);
 813
 814         return 0;
 815 }
 816
 817 static const struct file_operations fops_fw_crash_dump = {
 818         .open = ath10k_fw_crash_dump_open,
 819         .read = ath10k_fw_crash_dump_read,
 820         .release = ath10k_fw_crash_dump_release,
 821         .owner = THIS_MODULE,
 822         .llseek = default_llseek,
 823 };
 824
 825 static int ath10k_debug_htt_stats_req(struct ath10k *ar)
 826 {
 827         u64 cookie;
 828         int ret;
 829
 830         lockdep_assert_held(&ar->conf_mutex);
 831
 832         if (ar->debug.htt_stats_mask == 0)
 833                 /* htt stats are disabled */
 834                 return 0;
 835
 836         if (ar->state != ATH10K_STATE_ON)
 837                 return 0;
 838
 839         cookie = get_jiffies_64();
 840
 841         ret = ath10k_htt_h2t_stats_req(&ar->htt, ar->debug.htt_stats_mask,
 842                                        cookie);
 843         if (ret) {
 844                 ath10k_warn(ar, "failed to send htt stats request: %d\n", ret);
 845                 return ret;
 846         }
 847
 848         queue_delayed_work(ar->workqueue, &ar->debug.htt_stats_dwork,
 849                            msecs_to_jiffies(ATH10K_DEBUG_HTT_STATS_INTERVAL));
 850
 851         return 0;
 852 }
 853
 854 static void ath10k_debug_htt_stats_dwork(struct work_struct *work)
 855 {
 856         struct ath10k *ar = container_of(work, struct ath10k,
 857                                          debug.htt_stats_dwork.work);
 858
 859         mutex_lock(&ar->conf_mutex);
 860
 861         ath10k_debug_htt_stats_req(ar);
 862
 863         mutex_unlock(&ar->conf_mutex);
 864 }
 865
 866 static ssize_t ath10k_read_htt_stats_mask(struct file *file,
 867                                           char __user *user_buf,
 868                                           size_t count, loff_t *ppos)
 869 {
 870         struct ath10k *ar = file->private_data;
 871         char buf[32];
 872         unsigned int len;
 873
 874         len = scnprintf(buf, sizeof(buf), "%lu\n", ar->debug.htt_stats_mask);
 875
 876         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 877 }
 878
 879 static ssize_t ath10k_write_htt_stats_mask(struct file *file,
 880                                            const char __user *user_buf,
 881                                            size_t count, loff_t *ppos)
 882 {
 883         struct ath10k *ar = file->private_data;
 884         unsigned long mask;
 885         int ret;
 886
 887         ret = kstrtoul_from_user(user_buf, count, 0, &mask);
 888         if (ret)
 889                 return ret;
 890
 891         /* max 8 bit masks (for now) */
 892         if (mask > 0xff)
 893                 return -E2BIG;
 894
 895         mutex_lock(&ar->conf_mutex);
 896
 897         ar->debug.htt_stats_mask = mask;
 898
 899         ret = ath10k_debug_htt_stats_req(ar);
 900         if (ret)
 901                 goto out;
 902
 903         ret = count;
 904
 905 out:
 906         mutex_unlock(&ar->conf_mutex);
 907
 908         return ret;
 909 }
 910
 911 static const struct file_operations fops_htt_stats_mask = {
 912         .read = ath10k_read_htt_stats_mask,
 913         .write = ath10k_write_htt_stats_mask,
 914         .open = simple_open,
 915         .owner = THIS_MODULE,
 916         .llseek = default_llseek,
 917 };
 918
 919 static ssize_t ath10k_read_htt_max_amsdu_ampdu(struct file *file,
 920                                                char __user *user_buf,
 921                                                size_t count, loff_t *ppos)
 922 {
 923         struct ath10k *ar = file->private_data;
 924         char buf[64];
 925         u8 amsdu = 3, ampdu = 64;
 926         unsigned int len;
 927
 928         mutex_lock(&ar->conf_mutex);
 929
 930         if (ar->debug.htt_max_amsdu)
 931                 amsdu = ar->debug.htt_max_amsdu;
 932
 933         if (ar->debug.htt_max_ampdu)
 934                 ampdu = ar->debug.htt_max_ampdu;
 935
 936         mutex_unlock(&ar->conf_mutex);
 937
 938         len = scnprintf(buf, sizeof(buf), "%u %u\n", amsdu, ampdu);
 939
 940         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 941 }
 942
 943 static ssize_t ath10k_write_htt_max_amsdu_ampdu(struct file *file,
 944                                                 const char __user *user_buf,
 945                                                 size_t count, loff_t *ppos)
 946 {
 947         struct ath10k *ar = file->private_data;
 948         int res;
 949         char buf[64];
 950         unsigned int amsdu, ampdu;
 951
 952         simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
 953
 954         /* make sure that buf is null terminated */
 955         buf[sizeof(buf) - 1] = 0;
 956
 957         res = sscanf(buf, "%u %u", &amsdu, &ampdu);
 958
 959         if (res != 2)
 960                 return -EINVAL;
 961
 962         mutex_lock(&ar->conf_mutex);
 963
 964         res = ath10k_htt_h2t_aggr_cfg_msg(&ar->htt, ampdu, amsdu);
 965         if (res)
 966                 goto out;
 967
 968         res = count;
 969         ar->debug.htt_max_amsdu = amsdu;
 970         ar->debug.htt_max_ampdu = ampdu;
 971
 972 out:
 973         mutex_unlock(&ar->conf_mutex);
 974         return res;
 975 }
 976
 977 static const struct file_operations fops_htt_max_amsdu_ampdu = {
 978         .read = ath10k_read_htt_max_amsdu_ampdu,
 979         .write = ath10k_write_htt_max_amsdu_ampdu,
 980         .open = simple_open,
 981         .owner = THIS_MODULE,
 982         .llseek = default_llseek,
 983 };
 984
 985 static ssize_t ath10k_read_fw_dbglog(struct file *file,
 986                                      char __user *user_buf,
 987                                      size_t count, loff_t *ppos)
 988 {
 989         struct ath10k *ar = file->private_data;
 990         unsigned int len;
 991         char buf[32];
 992
 993         len = scnprintf(buf, sizeof(buf), "0x%08x\n",
 994                         ar->debug.fw_dbglog_mask);
 995
 996         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 997 }
 998
 999 static ssize_t ath10k_write_fw_dbglog(struct file *file,
1000                                       const char __user *user_buf,
1001                                       size_t count, loff_t *ppos)
1002 {
1003         struct ath10k *ar = file->private_data;
1004         unsigned long mask;
1005         int ret;
1006
1007         ret = kstrtoul_from_user(user_buf, count, 0, &mask);
1008         if (ret)
1009                 return ret;
1010
1011         mutex_lock(&ar->conf_mutex);
1012
1013         ar->debug.fw_dbglog_mask = mask;
1014
1015         if (ar->state == ATH10K_STATE_ON) {
1016                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask);
1017                 if (ret) {
1018                         ath10k_warn(ar, "dbglog cfg failed from debugfs: %d\n",
1019                                     ret);
1020                         goto exit;
1021                 }
1022         }
1023
1024         ret = count;
1025
1026 exit:
1027         mutex_unlock(&ar->conf_mutex);
1028
1029         return ret;
1030 }
1031
1032 static const struct file_operations fops_fw_dbglog = {
1033         .read = ath10k_read_fw_dbglog,
1034         .write = ath10k_write_fw_dbglog,
1035         .open = simple_open,
1036         .owner = THIS_MODULE,
1037         .llseek = default_llseek,
1038 };
1039
1040 int ath10k_debug_start(struct ath10k *ar)
1041 {
1042         int ret;
1043
1044         lockdep_assert_held(&ar->conf_mutex);
1045
1046         ret = ath10k_debug_htt_stats_req(ar);
1047         if (ret)
1048                 /* continue normally anyway, this isn't serious */
1049                 ath10k_warn(ar, "failed to start htt stats workqueue: %d\n",
1050                             ret);
1051
1052         if (ar->debug.fw_dbglog_mask) {
1053                 ret = ath10k_wmi_dbglog_cfg(ar, ar->debug.fw_dbglog_mask);
1054                 if (ret)
1055                         /* not serious */
1056                         ath10k_warn(ar, "failed to enable dbglog during start: %d",
1057                                     ret);
1058         }
1059
1060         return 0;
1061 }
1062
1063 void ath10k_debug_stop(struct ath10k *ar)
1064 {
1065         lockdep_assert_held(&ar->conf_mutex);
1066
1067         /* Must not use _sync to avoid deadlock, we do that in
1068          * ath10k_debug_destroy(). The check for htt_stats_mask is to avoid
1069          * warning from del_timer(). */
1070         if (ar->debug.htt_stats_mask != 0)
1071                 cancel_delayed_work(&ar->debug.htt_stats_dwork);
1072
1073         ar->debug.htt_max_amsdu = 0;
1074         ar->debug.htt_max_ampdu = 0;
1075 }
1076
1077 static ssize_t ath10k_write_simulate_radar(struct file *file,
1078                                            const char __user *user_buf,
1079                                            size_t count, loff_t *ppos)
1080 {
1081         struct ath10k *ar = file->private_data;
1082
1083         ieee80211_radar_detected(ar->hw);
1084
1085         return count;
1086 }
1087
1088 static const struct file_operations fops_simulate_radar = {
1089         .write = ath10k_write_simulate_radar,
1090         .open = simple_open,
1091         .owner = THIS_MODULE,
1092         .llseek = default_llseek,
1093 };
1094
1095 #define ATH10K_DFS_STAT(s, p) (\
1096         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1097                          ar->debug.dfs_stats.p))
1098
1099 #define ATH10K_DFS_POOL_STAT(s, p) (\
1100         len += scnprintf(buf + len, size - len, "%-28s : %10u\n", s, \
1101                          ar->debug.dfs_pool_stats.p))
1102
1103 static ssize_t ath10k_read_dfs_stats(struct file *file, char __user *user_buf,
1104                                      size_t count, loff_t *ppos)
1105 {
1106         int retval = 0, len = 0;
1107         const int size = 8000;
1108         struct ath10k *ar = file->private_data;
1109         char *buf;
1110
1111         buf = kzalloc(size, GFP_KERNEL);
1112         if (buf == NULL)
1113                 return -ENOMEM;
1114
1115         if (!ar->dfs_detector) {
1116                 len += scnprintf(buf + len, size - len, "DFS not enabled\n");
1117                 goto exit;
1118         }
1119
1120         ar->debug.dfs_pool_stats =
1121                         ar->dfs_detector->get_stats(ar->dfs_detector);
1122
1123         len += scnprintf(buf + len, size - len, "Pulse detector statistics:\n");
1124
1125         ATH10K_DFS_STAT("reported phy errors", phy_errors);
1126         ATH10K_DFS_STAT("pulse events reported", pulses_total);
1127         ATH10K_DFS_STAT("DFS pulses detected", pulses_detected);
1128         ATH10K_DFS_STAT("DFS pulses discarded", pulses_discarded);
1129         ATH10K_DFS_STAT("Radars detected", radar_detected);
1130
1131         len += scnprintf(buf + len, size - len, "Global Pool statistics:\n");
1132         ATH10K_DFS_POOL_STAT("Pool references", pool_reference);
1133         ATH10K_DFS_POOL_STAT("Pulses allocated", pulse_allocated);
1134         ATH10K_DFS_POOL_STAT("Pulses alloc error", pulse_alloc_error);
1135         ATH10K_DFS_POOL_STAT("Pulses in use", pulse_used);
1136         ATH10K_DFS_POOL_STAT("Seqs. allocated", pseq_allocated);
1137         ATH10K_DFS_POOL_STAT("Seqs. alloc error", pseq_alloc_error);
1138         ATH10K_DFS_POOL_STAT("Seqs. in use", pseq_used);
1139
1140 exit:
1141         if (len > size)
1142                 len = size;
1143
1144         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1145         kfree(buf);
1146
1147         return retval;
1148 }
1149
1150 static const struct file_operations fops_dfs_stats = {
1151         .read = ath10k_read_dfs_stats,
1152         .open = simple_open,
1153         .owner = THIS_MODULE,
1154         .llseek = default_llseek,
1155 };
1156
1157 int ath10k_debug_create(struct ath10k *ar)
1158 {
1159         ar->debug.fw_crash_data = vzalloc(sizeof(*ar->debug.fw_crash_data));
1160         if (!ar->debug.fw_crash_data)
1161                 return -ENOMEM;
1162
1163         return 0;
1164 }
1165
1166 void ath10k_debug_destroy(struct ath10k *ar)
1167 {
1168         vfree(ar->debug.fw_crash_data);
1169         ar->debug.fw_crash_data = NULL;
1170 }
1171
1172 int ath10k_debug_register(struct ath10k *ar)
1173 {
1174         ar->debug.debugfs_phy = debugfs_create_dir("ath10k",
1175                                                    ar->hw->wiphy->debugfsdir);
1176         if (IS_ERR_OR_NULL(ar->debug.debugfs_phy)) {
1177                 if (IS_ERR(ar->debug.debugfs_phy))
1178                         return PTR_ERR(ar->debug.debugfs_phy);
1179
1180                 return -ENOMEM;
1181         }
1182
1183         INIT_DELAYED_WORK(&ar->debug.htt_stats_dwork,
1184                           ath10k_debug_htt_stats_dwork);
1185
1186         init_completion(&ar->debug.event_stats_compl);
1187
1188         debugfs_create_file("fw_stats", S_IRUSR, ar->debug.debugfs_phy, ar,
1189                             &fops_fw_stats);
1190
1191         debugfs_create_file("wmi_services", S_IRUSR, ar->debug.debugfs_phy, ar,
1192                             &fops_wmi_services);
1193
1194         debugfs_create_file("simulate_fw_crash", S_IRUSR, ar->debug.debugfs_phy,
1195                             ar, &fops_simulate_fw_crash);
1196
1197         debugfs_create_file("fw_crash_dump", S_IRUSR, ar->debug.debugfs_phy,
1198                             ar, &fops_fw_crash_dump);
1199
1200         debugfs_create_file("chip_id", S_IRUSR, ar->debug.debugfs_phy,
1201                             ar, &fops_chip_id);
1202
1203         debugfs_create_file("htt_stats_mask", S_IRUSR, ar->debug.debugfs_phy,
1204                             ar, &fops_htt_stats_mask);
1205
1206         debugfs_create_file("htt_max_amsdu_ampdu", S_IRUSR | S_IWUSR,
1207                             ar->debug.debugfs_phy, ar,
1208                             &fops_htt_max_amsdu_ampdu);
1209
1210         debugfs_create_file("fw_dbglog", S_IRUSR, ar->debug.debugfs_phy,
1211                             ar, &fops_fw_dbglog);
1212
1213         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
1214                 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
1215                                     ar->debug.debugfs_phy, ar,
1216                                     &fops_simulate_radar);
1217
1218                 debugfs_create_bool("dfs_block_radar_events", S_IWUSR,
1219                                     ar->debug.debugfs_phy,
1220                                     &ar->dfs_block_radar_events);
1221
1222                 debugfs_create_file("dfs_stats", S_IRUSR,
1223                                     ar->debug.debugfs_phy, ar,
1224                                     &fops_dfs_stats);
1225         }
1226
1227         return 0;
1228 }
1229
1230 void ath10k_debug_unregister(struct ath10k *ar)
1231 {
1232         cancel_delayed_work_sync(&ar->debug.htt_stats_dwork);
1233 }
1234
1235 #endif /* CONFIG_ATH10K_DEBUGFS */
1236
1237 #ifdef CONFIG_ATH10K_DEBUG
1238 void ath10k_dbg(struct ath10k *ar, enum ath10k_debug_mask mask,
1239                 const char *fmt, ...)
1240 {
1241         struct va_format vaf;
1242         va_list args;
1243
1244         va_start(args, fmt);
1245
1246         vaf.fmt = fmt;
1247         vaf.va = &args;
1248
1249         if (ath10k_debug_mask & mask)
1250                 dev_printk(KERN_DEBUG, ar->dev, "%pV", &vaf);
1251
1252         trace_ath10k_log_dbg(ar, mask, &vaf);
1253
1254         va_end(args);
1255 }
1256 EXPORT_SYMBOL(ath10k_dbg);
1257
1258 void ath10k_dbg_dump(struct ath10k *ar,
1259                      enum ath10k_debug_mask mask,
1260                      const char *msg, const char *prefix,
1261                      const void *buf, size_t len)
1262 {
1263         if (ath10k_debug_mask & mask) {
1264                 if (msg)
1265                         ath10k_dbg(ar, mask, "%s\n", msg);
1266
1267                 print_hex_dump_bytes(prefix, DUMP_PREFIX_OFFSET, buf, len);
1268         }
1269
1270         /* tracing code doesn't like null strings :/ */
1271         trace_ath10k_log_dbg_dump(ar, msg ? msg : "", prefix ? prefix : "",
1272                                   buf, len);
1273 }
1274 EXPORT_SYMBOL(ath10k_dbg_dump);
1275
1276 #endif /* CONFIG_ATH10K_DEBUG */