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