1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright (C) 2015 Intel Mobile Communications GmbH 4 * Copyright (C) 2016-2017 Intel Deutschland GmbH 5 * Copyright (C) 2019-2021, 2023-2025 Intel Corporation 6 */ 7 #include <linux/kernel.h> 8 #include <linux/bsearch.h> 9 #include <linux/list.h> 10 11 #include "fw/api/tx.h" 12 #include "iwl-trans.h" 13 #include "iwl-drv.h" 14 #include "iwl-fh.h" 15 #include <linux/dmapool.h> 16 #include "fw/api/commands.h" 17 #include "pcie/gen1_2/internal.h" 18 #include "pcie/iwl-context-info-v2.h" 19 20 struct iwl_trans_dev_restart_data { 21 struct list_head list; 22 unsigned int restart_count; 23 time64_t last_error; 24 bool backoff; 25 char name[]; 26 }; 27 28 static LIST_HEAD(restart_data_list); 29 static DEFINE_SPINLOCK(restart_data_lock); 30 31 static struct iwl_trans_dev_restart_data * 32 iwl_trans_get_restart_data(struct device *dev) 33 { 34 struct iwl_trans_dev_restart_data *tmp, *data = NULL; 35 const char *name = dev_name(dev); 36 37 spin_lock(&restart_data_lock); 38 list_for_each_entry(tmp, &restart_data_list, list) { 39 if (strcmp(tmp->name, name)) 40 continue; 41 data = tmp; 42 break; 43 } 44 spin_unlock(&restart_data_lock); 45 46 if (data) 47 return data; 48 49 data = kzalloc(struct_size(data, name, strlen(name) + 1), GFP_ATOMIC); 50 if (!data) 51 return NULL; 52 53 strcpy(data->name, name); 54 spin_lock(&restart_data_lock); 55 list_add_tail(&data->list, &restart_data_list); 56 spin_unlock(&restart_data_lock); 57 58 return data; 59 } 60 61 static void iwl_trans_inc_restart_count(struct device *dev) 62 { 63 struct iwl_trans_dev_restart_data *data; 64 65 data = iwl_trans_get_restart_data(dev); 66 if (data) { 67 data->last_error = ktime_get_boottime_seconds(); 68 data->restart_count++; 69 } 70 } 71 72 void iwl_trans_free_restart_list(void) 73 { 74 struct iwl_trans_dev_restart_data *tmp; 75 76 while ((tmp = list_first_entry_or_null(&restart_data_list, 77 typeof(*tmp), list))) { 78 list_del(&tmp->list); 79 kfree(tmp); 80 } 81 } 82 83 struct iwl_trans_reprobe { 84 struct device *dev; 85 struct delayed_work work; 86 }; 87 88 static void iwl_trans_reprobe_wk(struct work_struct *wk) 89 { 90 struct iwl_trans_reprobe *reprobe; 91 92 reprobe = container_of(wk, typeof(*reprobe), work.work); 93 94 if (device_reprobe(reprobe->dev)) 95 dev_err(reprobe->dev, "reprobe failed!\n"); 96 put_device(reprobe->dev); 97 kfree(reprobe); 98 module_put(THIS_MODULE); 99 } 100 101 static void iwl_trans_schedule_reprobe(struct iwl_trans *trans, 102 unsigned int delay_ms) 103 { 104 struct iwl_trans_reprobe *reprobe; 105 106 /* 107 * get a module reference to avoid doing this while unloading 108 * anyway and to avoid scheduling a work with code that's 109 * being removed. 110 */ 111 if (!try_module_get(THIS_MODULE)) { 112 IWL_ERR(trans, "Module is being unloaded - abort\n"); 113 return; 114 } 115 116 reprobe = kzalloc(sizeof(*reprobe), GFP_KERNEL); 117 if (!reprobe) { 118 module_put(THIS_MODULE); 119 return; 120 } 121 reprobe->dev = get_device(trans->dev); 122 INIT_DELAYED_WORK(&reprobe->work, iwl_trans_reprobe_wk); 123 schedule_delayed_work(&reprobe->work, msecs_to_jiffies(delay_ms)); 124 } 125 126 #define IWL_TRANS_RESET_OK_TIME 7 /* seconds */ 127 128 static enum iwl_reset_mode 129 iwl_trans_determine_restart_mode(struct iwl_trans *trans) 130 { 131 struct iwl_trans_dev_restart_data *data; 132 enum iwl_reset_mode at_least = 0; 133 unsigned int index; 134 static const enum iwl_reset_mode escalation_list_old[] = { 135 IWL_RESET_MODE_SW_RESET, 136 IWL_RESET_MODE_REPROBE, 137 IWL_RESET_MODE_REPROBE, 138 IWL_RESET_MODE_FUNC_RESET, 139 IWL_RESET_MODE_PROD_RESET, 140 }; 141 static const enum iwl_reset_mode escalation_list_sc[] = { 142 IWL_RESET_MODE_SW_RESET, 143 IWL_RESET_MODE_REPROBE, 144 IWL_RESET_MODE_REPROBE, 145 IWL_RESET_MODE_FUNC_RESET, 146 IWL_RESET_MODE_TOP_RESET, 147 IWL_RESET_MODE_PROD_RESET, 148 IWL_RESET_MODE_TOP_RESET, 149 IWL_RESET_MODE_PROD_RESET, 150 IWL_RESET_MODE_TOP_RESET, 151 IWL_RESET_MODE_PROD_RESET, 152 }; 153 const enum iwl_reset_mode *escalation_list; 154 size_t escalation_list_size; 155 156 /* used by TOP fatal error/TOP reset */ 157 if (trans->restart.mode.type == IWL_ERR_TYPE_TOP_RESET_FAILED) 158 return IWL_RESET_MODE_PROD_RESET; 159 160 if (trans->request_top_reset) { 161 trans->request_top_reset = 0; 162 if (trans->mac_cfg->device_family >= IWL_DEVICE_FAMILY_SC) 163 return IWL_RESET_MODE_TOP_RESET; 164 return IWL_RESET_MODE_PROD_RESET; 165 } 166 167 if (trans->mac_cfg->device_family >= IWL_DEVICE_FAMILY_SC) { 168 escalation_list = escalation_list_sc; 169 escalation_list_size = ARRAY_SIZE(escalation_list_sc); 170 } else { 171 escalation_list = escalation_list_old; 172 escalation_list_size = ARRAY_SIZE(escalation_list_old); 173 } 174 175 if (trans->restart.during_reset) 176 at_least = IWL_RESET_MODE_REPROBE; 177 178 data = iwl_trans_get_restart_data(trans->dev); 179 if (!data) 180 return at_least; 181 182 if (!data->backoff && 183 ktime_get_boottime_seconds() - data->last_error >= 184 IWL_TRANS_RESET_OK_TIME) 185 data->restart_count = 0; 186 187 index = data->restart_count; 188 if (index >= escalation_list_size) { 189 index = escalation_list_size - 1; 190 if (!data->backoff) { 191 data->backoff = true; 192 return IWL_RESET_MODE_BACKOFF; 193 } 194 data->backoff = false; 195 } 196 197 return max(at_least, escalation_list[index]); 198 } 199 200 #define IWL_TRANS_TOP_FOLLOWER_WAIT 180 /* ms */ 201 202 #define IWL_TRANS_RESET_DELAY (HZ * 60) 203 204 static void iwl_trans_restart_wk(struct work_struct *wk) 205 { 206 struct iwl_trans *trans = container_of(wk, typeof(*trans), 207 restart.wk.work); 208 enum iwl_reset_mode mode; 209 210 if (trans->restart.mode.type == IWL_ERR_TYPE_TOP_RESET_BY_BT) { 211 iwl_trans_schedule_reprobe(trans, IWL_TRANS_TOP_FOLLOWER_WAIT); 212 return; 213 } 214 215 if (!trans->op_mode) 216 return; 217 218 /* might have been scheduled before marked as dead, re-check */ 219 if (test_bit(STATUS_TRANS_DEAD, &trans->status)) 220 return; 221 222 iwl_op_mode_dump_error(trans->op_mode, &trans->restart.mode); 223 224 /* 225 * If the opmode stopped the device while we were trying to dump and 226 * reset, then we'll have done the dump already (synchronized by the 227 * opmode lock that it will acquire in iwl_op_mode_dump_error()) and 228 * managed that via trans->restart.mode. 229 * Additionally, make sure that in such a case we won't attempt to do 230 * any resets now, since it's no longer requested. 231 */ 232 if (!test_and_clear_bit(STATUS_RESET_PENDING, &trans->status)) 233 return; 234 235 if (!iwlwifi_mod_params.fw_restart) 236 return; 237 238 mode = iwl_trans_determine_restart_mode(trans); 239 if (mode == IWL_RESET_MODE_BACKOFF) { 240 IWL_ERR(trans, "Too many device errors - delay next reset\n"); 241 queue_delayed_work(system_unbound_wq, &trans->restart.wk, 242 IWL_TRANS_RESET_DELAY); 243 return; 244 } 245 246 iwl_trans_inc_restart_count(trans->dev); 247 248 switch (mode) { 249 case IWL_RESET_MODE_TOP_RESET: 250 trans->do_top_reset = 1; 251 IWL_ERR(trans, "Device error - TOP reset\n"); 252 fallthrough; 253 case IWL_RESET_MODE_SW_RESET: 254 if (mode == IWL_RESET_MODE_SW_RESET) 255 IWL_ERR(trans, "Device error - SW reset\n"); 256 iwl_trans_opmode_sw_reset(trans, trans->restart.mode.type); 257 break; 258 case IWL_RESET_MODE_REPROBE: 259 IWL_ERR(trans, "Device error - reprobe!\n"); 260 261 iwl_trans_schedule_reprobe(trans, 0); 262 break; 263 default: 264 iwl_trans_pcie_reset(trans, mode); 265 break; 266 } 267 } 268 269 struct iwl_trans *iwl_trans_alloc(unsigned int priv_size, 270 struct device *dev, 271 const struct iwl_mac_cfg *mac_cfg) 272 { 273 struct iwl_trans *trans; 274 #ifdef CONFIG_LOCKDEP 275 static struct lock_class_key __sync_cmd_key; 276 #endif 277 278 trans = devm_kzalloc(dev, sizeof(*trans) + priv_size, GFP_KERNEL); 279 if (!trans) 280 return NULL; 281 282 trans->mac_cfg = mac_cfg; 283 284 #ifdef CONFIG_LOCKDEP 285 lockdep_init_map(&trans->sync_cmd_lockdep_map, "sync_cmd_lockdep_map", 286 &__sync_cmd_key, 0); 287 #endif 288 289 trans->dev = dev; 290 291 INIT_DELAYED_WORK(&trans->restart.wk, iwl_trans_restart_wk); 292 293 return trans; 294 } 295 296 int iwl_trans_init(struct iwl_trans *trans) 297 { 298 int txcmd_size, txcmd_align; 299 300 /* check if name/num_rx_queues were set as a proxy for info being set */ 301 if (WARN_ON(!trans->info.name || !trans->info.num_rxqs)) 302 return -EINVAL; 303 304 if (!trans->mac_cfg->gen2) { 305 txcmd_size = sizeof(struct iwl_tx_cmd_v6); 306 txcmd_align = sizeof(void *); 307 } else if (trans->mac_cfg->device_family < IWL_DEVICE_FAMILY_AX210) { 308 txcmd_size = sizeof(struct iwl_tx_cmd_v9); 309 txcmd_align = 64; 310 } else { 311 txcmd_size = sizeof(struct iwl_tx_cmd); 312 txcmd_align = 128; 313 } 314 315 txcmd_size += sizeof(struct iwl_cmd_header); 316 txcmd_size += 36; /* biggest possible 802.11 header */ 317 318 /* Ensure device TX cmd cannot reach/cross a page boundary in gen2 */ 319 if (WARN_ON(trans->mac_cfg->gen2 && txcmd_size >= txcmd_align)) 320 return -EINVAL; 321 322 snprintf(trans->dev_cmd_pool_name, sizeof(trans->dev_cmd_pool_name), 323 "iwl_cmd_pool:%s", dev_name(trans->dev)); 324 trans->dev_cmd_pool = 325 kmem_cache_create(trans->dev_cmd_pool_name, 326 txcmd_size, txcmd_align, 327 SLAB_HWCACHE_ALIGN, NULL); 328 if (!trans->dev_cmd_pool) 329 return -ENOMEM; 330 331 return 0; 332 } 333 334 void iwl_trans_free(struct iwl_trans *trans) 335 { 336 cancel_delayed_work_sync(&trans->restart.wk); 337 kmem_cache_destroy(trans->dev_cmd_pool); 338 } 339 340 int iwl_trans_send_cmd(struct iwl_trans *trans, struct iwl_host_cmd *cmd) 341 { 342 int ret; 343 344 if (unlikely(!(cmd->flags & CMD_SEND_IN_RFKILL) && 345 test_bit(STATUS_RFKILL_OPMODE, &trans->status))) 346 return -ERFKILL; 347 348 if (unlikely(test_bit(STATUS_SUSPENDED, &trans->status))) 349 return -EHOSTDOWN; 350 351 if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status))) 352 return -EIO; 353 354 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 355 "bad state = %d\n", trans->state)) 356 return -EIO; 357 358 if (!(cmd->flags & CMD_ASYNC)) 359 lock_map_acquire_read(&trans->sync_cmd_lockdep_map); 360 361 if (trans->conf.wide_cmd_header && !iwl_cmd_groupid(cmd->id)) { 362 if (cmd->id != REPLY_ERROR) 363 cmd->id = DEF_ID(cmd->id); 364 } 365 366 ret = iwl_trans_pcie_send_hcmd(trans, cmd); 367 368 if (!(cmd->flags & CMD_ASYNC)) 369 lock_map_release(&trans->sync_cmd_lockdep_map); 370 371 if (WARN_ON((cmd->flags & CMD_WANT_SKB) && !ret && !cmd->resp_pkt)) 372 return -EIO; 373 374 return ret; 375 } 376 IWL_EXPORT_SYMBOL(iwl_trans_send_cmd); 377 378 /* Comparator for struct iwl_hcmd_names. 379 * Used in the binary search over a list of host commands. 380 * 381 * @key: command_id that we're looking for. 382 * @elt: struct iwl_hcmd_names candidate for match. 383 * 384 * @return 0 iff equal. 385 */ 386 static int iwl_hcmd_names_cmp(const void *key, const void *elt) 387 { 388 const struct iwl_hcmd_names *name = elt; 389 const u8 *cmd1 = key; 390 u8 cmd2 = name->cmd_id; 391 392 return (*cmd1 - cmd2); 393 } 394 395 const char *iwl_get_cmd_string(struct iwl_trans *trans, u32 id) 396 { 397 u8 grp, cmd; 398 struct iwl_hcmd_names *ret; 399 const struct iwl_hcmd_arr *arr; 400 size_t size = sizeof(struct iwl_hcmd_names); 401 402 grp = iwl_cmd_groupid(id); 403 cmd = iwl_cmd_opcode(id); 404 405 if (!trans->conf.command_groups || 406 grp >= trans->conf.command_groups_size || 407 !trans->conf.command_groups[grp].arr) 408 return "UNKNOWN"; 409 410 arr = &trans->conf.command_groups[grp]; 411 ret = bsearch(&cmd, arr->arr, arr->size, size, iwl_hcmd_names_cmp); 412 if (!ret) 413 return "UNKNOWN"; 414 return ret->cmd_name; 415 } 416 IWL_EXPORT_SYMBOL(iwl_get_cmd_string); 417 418 void iwl_trans_op_mode_enter(struct iwl_trans *trans, 419 struct iwl_op_mode *op_mode) 420 { 421 trans->op_mode = op_mode; 422 423 if (WARN_ON(trans->conf.n_no_reclaim_cmds > MAX_NO_RECLAIM_CMDS)) 424 trans->conf.n_no_reclaim_cmds = 425 ARRAY_SIZE(trans->conf.no_reclaim_cmds); 426 427 WARN_ON_ONCE(!trans->conf.rx_mpdu_cmd); 428 429 iwl_trans_pcie_op_mode_enter(trans); 430 } 431 IWL_EXPORT_SYMBOL(iwl_trans_op_mode_enter); 432 433 int iwl_trans_start_hw(struct iwl_trans *trans) 434 { 435 might_sleep(); 436 437 clear_bit(STATUS_TRANS_RESET_IN_PROGRESS, &trans->status); 438 /* opmode may not resume if it detects errors */ 439 clear_bit(STATUS_SUSPENDED, &trans->status); 440 441 return iwl_trans_pcie_start_hw(trans); 442 } 443 IWL_EXPORT_SYMBOL(iwl_trans_start_hw); 444 445 void iwl_trans_op_mode_leave(struct iwl_trans *trans) 446 { 447 might_sleep(); 448 449 iwl_trans_pcie_op_mode_leave(trans); 450 451 cancel_delayed_work_sync(&trans->restart.wk); 452 453 trans->op_mode = NULL; 454 memset(&trans->conf, 0, sizeof(trans->conf)); 455 456 trans->state = IWL_TRANS_NO_FW; 457 } 458 IWL_EXPORT_SYMBOL(iwl_trans_op_mode_leave); 459 460 void iwl_trans_write8(struct iwl_trans *trans, u32 ofs, u8 val) 461 { 462 iwl_trans_pcie_write8(trans, ofs, val); 463 } 464 IWL_EXPORT_SYMBOL(iwl_trans_write8); 465 466 void iwl_trans_write32(struct iwl_trans *trans, u32 ofs, u32 val) 467 { 468 iwl_trans_pcie_write32(trans, ofs, val); 469 } 470 IWL_EXPORT_SYMBOL(iwl_trans_write32); 471 472 u32 iwl_trans_read32(struct iwl_trans *trans, u32 ofs) 473 { 474 return iwl_trans_pcie_read32(trans, ofs); 475 } 476 IWL_EXPORT_SYMBOL(iwl_trans_read32); 477 478 u32 iwl_trans_read_prph(struct iwl_trans *trans, u32 ofs) 479 { 480 return iwl_trans_pcie_read_prph(trans, ofs); 481 } 482 IWL_EXPORT_SYMBOL(iwl_trans_read_prph); 483 484 void iwl_trans_write_prph(struct iwl_trans *trans, u32 ofs, u32 val) 485 { 486 return iwl_trans_pcie_write_prph(trans, ofs, val); 487 } 488 IWL_EXPORT_SYMBOL(iwl_trans_write_prph); 489 490 int iwl_trans_read_mem(struct iwl_trans *trans, u32 addr, 491 void *buf, int dwords) 492 { 493 return iwl_trans_pcie_read_mem(trans, addr, buf, dwords); 494 } 495 IWL_EXPORT_SYMBOL(iwl_trans_read_mem); 496 497 int iwl_trans_write_mem(struct iwl_trans *trans, u32 addr, 498 const void *buf, int dwords) 499 { 500 int offs, ret = 0; 501 const u32 *vals = buf; 502 503 if (iwl_trans_grab_nic_access(trans)) { 504 iwl_write32(trans, HBUS_TARG_MEM_WADDR, addr); 505 for (offs = 0; offs < dwords; offs++) 506 iwl_write32(trans, HBUS_TARG_MEM_WDAT, 507 vals ? vals[offs] : 0); 508 iwl_trans_release_nic_access(trans); 509 } else { 510 ret = -EBUSY; 511 } 512 return ret; 513 } 514 IWL_EXPORT_SYMBOL(iwl_trans_write_mem); 515 516 void iwl_trans_set_pmi(struct iwl_trans *trans, bool state) 517 { 518 if (state) 519 set_bit(STATUS_TPOWER_PMI, &trans->status); 520 else 521 clear_bit(STATUS_TPOWER_PMI, &trans->status); 522 } 523 IWL_EXPORT_SYMBOL(iwl_trans_set_pmi); 524 525 int iwl_trans_sw_reset(struct iwl_trans *trans, bool retake_ownership) 526 { 527 return iwl_trans_pcie_sw_reset(trans, retake_ownership); 528 } 529 IWL_EXPORT_SYMBOL(iwl_trans_sw_reset); 530 531 struct iwl_trans_dump_data * 532 iwl_trans_dump_data(struct iwl_trans *trans, u32 dump_mask, 533 const struct iwl_dump_sanitize_ops *sanitize_ops, 534 void *sanitize_ctx) 535 { 536 return iwl_trans_pcie_dump_data(trans, dump_mask, 537 sanitize_ops, sanitize_ctx); 538 } 539 IWL_EXPORT_SYMBOL(iwl_trans_dump_data); 540 541 int iwl_trans_d3_suspend(struct iwl_trans *trans, bool test, bool reset) 542 { 543 int err; 544 545 might_sleep(); 546 547 err = iwl_trans_pcie_d3_suspend(trans, test, reset); 548 549 if (!err) 550 set_bit(STATUS_SUSPENDED, &trans->status); 551 552 return err; 553 } 554 IWL_EXPORT_SYMBOL(iwl_trans_d3_suspend); 555 556 int iwl_trans_d3_resume(struct iwl_trans *trans, enum iwl_d3_status *status, 557 bool test, bool reset) 558 { 559 int err; 560 561 might_sleep(); 562 563 err = iwl_trans_pcie_d3_resume(trans, status, test, reset); 564 565 clear_bit(STATUS_SUSPENDED, &trans->status); 566 567 return err; 568 } 569 IWL_EXPORT_SYMBOL(iwl_trans_d3_resume); 570 571 void iwl_trans_interrupts(struct iwl_trans *trans, bool enable) 572 { 573 iwl_trans_pci_interrupts(trans, enable); 574 } 575 IWL_EXPORT_SYMBOL(iwl_trans_interrupts); 576 577 void iwl_trans_sync_nmi(struct iwl_trans *trans) 578 { 579 iwl_trans_pcie_sync_nmi(trans); 580 } 581 IWL_EXPORT_SYMBOL(iwl_trans_sync_nmi); 582 583 int iwl_trans_write_imr_mem(struct iwl_trans *trans, u32 dst_addr, 584 u64 src_addr, u32 byte_cnt) 585 { 586 return iwl_trans_pcie_copy_imr(trans, dst_addr, src_addr, byte_cnt); 587 } 588 IWL_EXPORT_SYMBOL(iwl_trans_write_imr_mem); 589 590 void iwl_trans_set_bits_mask(struct iwl_trans *trans, u32 reg, 591 u32 mask, u32 value) 592 { 593 iwl_trans_pcie_set_bits_mask(trans, reg, mask, value); 594 } 595 IWL_EXPORT_SYMBOL(iwl_trans_set_bits_mask); 596 597 int iwl_trans_read_config32(struct iwl_trans *trans, u32 ofs, 598 u32 *val) 599 { 600 return iwl_trans_pcie_read_config32(trans, ofs, val); 601 } 602 IWL_EXPORT_SYMBOL(iwl_trans_read_config32); 603 604 bool _iwl_trans_grab_nic_access(struct iwl_trans *trans) 605 { 606 return iwl_trans_pcie_grab_nic_access(trans); 607 } 608 IWL_EXPORT_SYMBOL(_iwl_trans_grab_nic_access); 609 610 void __releases(nic_access) 611 iwl_trans_release_nic_access(struct iwl_trans *trans) 612 { 613 iwl_trans_pcie_release_nic_access(trans); 614 } 615 IWL_EXPORT_SYMBOL(iwl_trans_release_nic_access); 616 617 void iwl_trans_fw_alive(struct iwl_trans *trans) 618 { 619 might_sleep(); 620 621 trans->state = IWL_TRANS_FW_ALIVE; 622 623 if (trans->mac_cfg->gen2) 624 iwl_trans_pcie_gen2_fw_alive(trans); 625 else 626 iwl_trans_pcie_fw_alive(trans); 627 } 628 IWL_EXPORT_SYMBOL(iwl_trans_fw_alive); 629 630 int iwl_trans_start_fw(struct iwl_trans *trans, const struct iwl_fw *fw, 631 enum iwl_ucode_type ucode_type, bool run_in_rfkill) 632 { 633 const struct fw_img *img; 634 int ret; 635 636 might_sleep(); 637 638 img = iwl_get_ucode_image(fw, ucode_type); 639 if (!img) 640 return -EINVAL; 641 642 clear_bit(STATUS_FW_ERROR, &trans->status); 643 644 if (trans->mac_cfg->gen2) 645 ret = iwl_trans_pcie_gen2_start_fw(trans, fw, img, 646 run_in_rfkill); 647 else 648 ret = iwl_trans_pcie_start_fw(trans, fw, img, 649 run_in_rfkill); 650 651 if (ret == 0) 652 trans->state = IWL_TRANS_FW_STARTED; 653 654 return ret; 655 } 656 IWL_EXPORT_SYMBOL(iwl_trans_start_fw); 657 658 void iwl_trans_stop_device(struct iwl_trans *trans) 659 { 660 might_sleep(); 661 662 /* 663 * See also the comment in iwl_trans_restart_wk(). 664 * 665 * When the opmode stops the device while a reset is pending, the 666 * worker (iwl_trans_restart_wk) might not have run yet or, more 667 * likely, will be blocked on the opmode lock. Due to the locking, 668 * we can't just flush the worker. 669 * 670 * If this is the case, then the test_and_clear_bit() ensures that 671 * the worker won't attempt to do anything after the stop. 672 * 673 * The trans->restart.mode is a handshake with the opmode, we set 674 * the context there to ABORT so that when the worker can finally 675 * acquire the lock in the opmode, the code there won't attempt to 676 * do any dumps. Since we'd really like to have the dump though, 677 * also do it inline here (with the opmode locks already held), 678 * but use a separate mode struct to avoid races. 679 */ 680 if (test_and_clear_bit(STATUS_RESET_PENDING, &trans->status)) { 681 struct iwl_fw_error_dump_mode mode; 682 683 mode = trans->restart.mode; 684 mode.context = IWL_ERR_CONTEXT_FROM_OPMODE; 685 trans->restart.mode.context = IWL_ERR_CONTEXT_ABORT; 686 687 iwl_op_mode_dump_error(trans->op_mode, &mode); 688 } 689 690 if (trans->mac_cfg->gen2) 691 iwl_trans_pcie_gen2_stop_device(trans); 692 else 693 iwl_trans_pcie_stop_device(trans); 694 695 trans->state = IWL_TRANS_NO_FW; 696 } 697 IWL_EXPORT_SYMBOL(iwl_trans_stop_device); 698 699 int iwl_trans_tx(struct iwl_trans *trans, struct sk_buff *skb, 700 struct iwl_device_tx_cmd *dev_cmd, int queue) 701 { 702 if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status))) 703 return -EIO; 704 705 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 706 "bad state = %d\n", trans->state)) 707 return -EIO; 708 709 if (trans->mac_cfg->gen2) 710 return iwl_txq_gen2_tx(trans, skb, dev_cmd, queue); 711 712 return iwl_trans_pcie_tx(trans, skb, dev_cmd, queue); 713 } 714 IWL_EXPORT_SYMBOL(iwl_trans_tx); 715 716 void iwl_trans_reclaim(struct iwl_trans *trans, int queue, int ssn, 717 struct sk_buff_head *skbs, bool is_flush) 718 { 719 if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status))) 720 return; 721 722 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 723 "bad state = %d\n", trans->state)) 724 return; 725 726 iwl_pcie_reclaim(trans, queue, ssn, skbs, is_flush); 727 } 728 IWL_EXPORT_SYMBOL(iwl_trans_reclaim); 729 730 void iwl_trans_txq_disable(struct iwl_trans *trans, int queue, 731 bool configure_scd) 732 { 733 iwl_trans_pcie_txq_disable(trans, queue, configure_scd); 734 } 735 IWL_EXPORT_SYMBOL(iwl_trans_txq_disable); 736 737 bool iwl_trans_txq_enable_cfg(struct iwl_trans *trans, int queue, u16 ssn, 738 const struct iwl_trans_txq_scd_cfg *cfg, 739 unsigned int queue_wdg_timeout) 740 { 741 might_sleep(); 742 743 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 744 "bad state = %d\n", trans->state)) 745 return false; 746 747 return iwl_trans_pcie_txq_enable(trans, queue, ssn, 748 cfg, queue_wdg_timeout); 749 } 750 IWL_EXPORT_SYMBOL(iwl_trans_txq_enable_cfg); 751 752 int iwl_trans_wait_txq_empty(struct iwl_trans *trans, int queue) 753 { 754 if (unlikely(test_bit(STATUS_FW_ERROR, &trans->status))) 755 return -EIO; 756 757 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 758 "bad state = %d\n", trans->state)) 759 return -EIO; 760 761 return iwl_trans_pcie_wait_txq_empty(trans, queue); 762 } 763 IWL_EXPORT_SYMBOL(iwl_trans_wait_txq_empty); 764 765 int iwl_trans_wait_tx_queues_empty(struct iwl_trans *trans, u32 txqs) 766 { 767 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 768 "bad state = %d\n", trans->state)) 769 return -EIO; 770 771 return iwl_trans_pcie_wait_txqs_empty(trans, txqs); 772 } 773 IWL_EXPORT_SYMBOL(iwl_trans_wait_tx_queues_empty); 774 775 void iwl_trans_freeze_txq_timer(struct iwl_trans *trans, 776 unsigned long txqs, bool freeze) 777 { 778 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 779 "bad state = %d\n", trans->state)) 780 return; 781 782 iwl_pcie_freeze_txq_timer(trans, txqs, freeze); 783 } 784 IWL_EXPORT_SYMBOL(iwl_trans_freeze_txq_timer); 785 786 void iwl_trans_txq_set_shared_mode(struct iwl_trans *trans, 787 int txq_id, bool shared_mode) 788 { 789 iwl_trans_pcie_txq_set_shared_mode(trans, txq_id, shared_mode); 790 } 791 IWL_EXPORT_SYMBOL(iwl_trans_txq_set_shared_mode); 792 793 #ifdef CONFIG_IWLWIFI_DEBUGFS 794 void iwl_trans_debugfs_cleanup(struct iwl_trans *trans) 795 { 796 iwl_trans_pcie_debugfs_cleanup(trans); 797 } 798 IWL_EXPORT_SYMBOL(iwl_trans_debugfs_cleanup); 799 #endif 800 801 void iwl_trans_set_q_ptrs(struct iwl_trans *trans, int queue, int ptr) 802 { 803 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 804 "bad state = %d\n", trans->state)) 805 return; 806 807 iwl_pcie_set_q_ptrs(trans, queue, ptr); 808 } 809 IWL_EXPORT_SYMBOL(iwl_trans_set_q_ptrs); 810 811 int iwl_trans_txq_alloc(struct iwl_trans *trans, u32 flags, u32 sta_mask, 812 u8 tid, int size, unsigned int wdg_timeout) 813 { 814 might_sleep(); 815 816 if (WARN_ONCE(trans->state != IWL_TRANS_FW_ALIVE, 817 "bad state = %d\n", trans->state)) 818 return -EIO; 819 820 return iwl_txq_dyn_alloc(trans, flags, sta_mask, tid, 821 size, wdg_timeout); 822 } 823 IWL_EXPORT_SYMBOL(iwl_trans_txq_alloc); 824 825 void iwl_trans_txq_free(struct iwl_trans *trans, int queue) 826 { 827 iwl_txq_dyn_free(trans, queue); 828 } 829 IWL_EXPORT_SYMBOL(iwl_trans_txq_free); 830 831 int iwl_trans_get_rxq_dma_data(struct iwl_trans *trans, int queue, 832 struct iwl_trans_rxq_dma_data *data) 833 { 834 return iwl_trans_pcie_rxq_dma_data(trans, queue, data); 835 } 836 IWL_EXPORT_SYMBOL(iwl_trans_get_rxq_dma_data); 837 838 int iwl_trans_load_pnvm(struct iwl_trans *trans, 839 const struct iwl_pnvm_image *pnvm_data, 840 const struct iwl_ucode_capabilities *capa) 841 { 842 return iwl_trans_pcie_ctx_info_v2_load_pnvm(trans, pnvm_data, capa); 843 } 844 IWL_EXPORT_SYMBOL(iwl_trans_load_pnvm); 845 846 void iwl_trans_set_pnvm(struct iwl_trans *trans, 847 const struct iwl_ucode_capabilities *capa) 848 { 849 iwl_trans_pcie_ctx_info_v2_set_pnvm(trans, capa); 850 } 851 IWL_EXPORT_SYMBOL(iwl_trans_set_pnvm); 852 853 int iwl_trans_load_reduce_power(struct iwl_trans *trans, 854 const struct iwl_pnvm_image *payloads, 855 const struct iwl_ucode_capabilities *capa) 856 { 857 return iwl_trans_pcie_ctx_info_v2_load_reduce_power(trans, payloads, 858 capa); 859 } 860 IWL_EXPORT_SYMBOL(iwl_trans_load_reduce_power); 861 862 void iwl_trans_set_reduce_power(struct iwl_trans *trans, 863 const struct iwl_ucode_capabilities *capa) 864 { 865 iwl_trans_pcie_ctx_info_v2_set_reduce_power(trans, capa); 866 } 867 IWL_EXPORT_SYMBOL(iwl_trans_set_reduce_power); 868