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