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