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