1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2020-2021 The Linux Foundation. All rights reserved. 4 * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. 5 */ 6 7 #include <linux/msi.h> 8 #include <linux/pci.h> 9 10 #include "core.h" 11 #include "debug.h" 12 #include "mhi.h" 13 #include "pci.h" 14 15 #define MHI_TIMEOUT_DEFAULT_MS 90000 16 17 static const struct mhi_channel_config ath12k_mhi_channels_qcn9274[] = { 18 { 19 .num = 0, 20 .name = "LOOPBACK", 21 .num_elements = 32, 22 .event_ring = 1, 23 .dir = DMA_TO_DEVICE, 24 .ee_mask = 0x4, 25 .pollcfg = 0, 26 .doorbell = MHI_DB_BRST_DISABLE, 27 .lpm_notify = false, 28 .offload_channel = false, 29 .doorbell_mode_switch = false, 30 .auto_queue = false, 31 }, 32 { 33 .num = 1, 34 .name = "LOOPBACK", 35 .num_elements = 32, 36 .event_ring = 1, 37 .dir = DMA_FROM_DEVICE, 38 .ee_mask = 0x4, 39 .pollcfg = 0, 40 .doorbell = MHI_DB_BRST_DISABLE, 41 .lpm_notify = false, 42 .offload_channel = false, 43 .doorbell_mode_switch = false, 44 .auto_queue = false, 45 }, 46 { 47 .num = 20, 48 .name = "IPCR", 49 .num_elements = 32, 50 .event_ring = 1, 51 .dir = DMA_TO_DEVICE, 52 .ee_mask = 0x4, 53 .pollcfg = 0, 54 .doorbell = MHI_DB_BRST_DISABLE, 55 .lpm_notify = false, 56 .offload_channel = false, 57 .doorbell_mode_switch = false, 58 .auto_queue = false, 59 }, 60 { 61 .num = 21, 62 .name = "IPCR", 63 .num_elements = 32, 64 .event_ring = 1, 65 .dir = DMA_FROM_DEVICE, 66 .ee_mask = 0x4, 67 .pollcfg = 0, 68 .doorbell = MHI_DB_BRST_DISABLE, 69 .lpm_notify = false, 70 .offload_channel = false, 71 .doorbell_mode_switch = false, 72 .auto_queue = true, 73 }, 74 }; 75 76 static struct mhi_event_config ath12k_mhi_events_qcn9274[] = { 77 { 78 .num_elements = 32, 79 .irq_moderation_ms = 0, 80 .irq = 1, 81 .data_type = MHI_ER_CTRL, 82 .mode = MHI_DB_BRST_DISABLE, 83 .hardware_event = false, 84 .client_managed = false, 85 .offload_channel = false, 86 }, 87 { 88 .num_elements = 256, 89 .irq_moderation_ms = 1, 90 .irq = 2, 91 .mode = MHI_DB_BRST_DISABLE, 92 .priority = 1, 93 .hardware_event = false, 94 .client_managed = false, 95 .offload_channel = false, 96 }, 97 }; 98 99 const struct mhi_controller_config ath12k_mhi_config_qcn9274 = { 100 .max_channels = 30, 101 .timeout_ms = 10000, 102 .use_bounce_buf = false, 103 .buf_len = 0, 104 .num_channels = ARRAY_SIZE(ath12k_mhi_channels_qcn9274), 105 .ch_cfg = ath12k_mhi_channels_qcn9274, 106 .num_events = ARRAY_SIZE(ath12k_mhi_events_qcn9274), 107 .event_cfg = ath12k_mhi_events_qcn9274, 108 }; 109 110 static const struct mhi_channel_config ath12k_mhi_channels_wcn7850[] = { 111 { 112 .num = 0, 113 .name = "LOOPBACK", 114 .num_elements = 32, 115 .event_ring = 0, 116 .dir = DMA_TO_DEVICE, 117 .ee_mask = 0x4, 118 .pollcfg = 0, 119 .doorbell = MHI_DB_BRST_DISABLE, 120 .lpm_notify = false, 121 .offload_channel = false, 122 .doorbell_mode_switch = false, 123 .auto_queue = false, 124 }, 125 { 126 .num = 1, 127 .name = "LOOPBACK", 128 .num_elements = 32, 129 .event_ring = 0, 130 .dir = DMA_FROM_DEVICE, 131 .ee_mask = 0x4, 132 .pollcfg = 0, 133 .doorbell = MHI_DB_BRST_DISABLE, 134 .lpm_notify = false, 135 .offload_channel = false, 136 .doorbell_mode_switch = false, 137 .auto_queue = false, 138 }, 139 { 140 .num = 20, 141 .name = "IPCR", 142 .num_elements = 64, 143 .event_ring = 1, 144 .dir = DMA_TO_DEVICE, 145 .ee_mask = 0x4, 146 .pollcfg = 0, 147 .doorbell = MHI_DB_BRST_DISABLE, 148 .lpm_notify = false, 149 .offload_channel = false, 150 .doorbell_mode_switch = false, 151 .auto_queue = false, 152 }, 153 { 154 .num = 21, 155 .name = "IPCR", 156 .num_elements = 64, 157 .event_ring = 1, 158 .dir = DMA_FROM_DEVICE, 159 .ee_mask = 0x4, 160 .pollcfg = 0, 161 .doorbell = MHI_DB_BRST_DISABLE, 162 .lpm_notify = false, 163 .offload_channel = false, 164 .doorbell_mode_switch = false, 165 .auto_queue = true, 166 }, 167 }; 168 169 static struct mhi_event_config ath12k_mhi_events_wcn7850[] = { 170 { 171 .num_elements = 32, 172 .irq_moderation_ms = 0, 173 .irq = 1, 174 .mode = MHI_DB_BRST_DISABLE, 175 .data_type = MHI_ER_CTRL, 176 .hardware_event = false, 177 .client_managed = false, 178 .offload_channel = false, 179 }, 180 { 181 .num_elements = 256, 182 .irq_moderation_ms = 1, 183 .irq = 2, 184 .mode = MHI_DB_BRST_DISABLE, 185 .priority = 1, 186 .hardware_event = false, 187 .client_managed = false, 188 .offload_channel = false, 189 }, 190 }; 191 192 const struct mhi_controller_config ath12k_mhi_config_wcn7850 = { 193 .max_channels = 128, 194 .timeout_ms = 2000, 195 .use_bounce_buf = false, 196 .buf_len = 0, 197 .num_channels = ARRAY_SIZE(ath12k_mhi_channels_wcn7850), 198 .ch_cfg = ath12k_mhi_channels_wcn7850, 199 .num_events = ARRAY_SIZE(ath12k_mhi_events_wcn7850), 200 .event_cfg = ath12k_mhi_events_wcn7850, 201 }; 202 203 void ath12k_mhi_set_mhictrl_reset(struct ath12k_base *ab) 204 { 205 u32 val; 206 207 val = ath12k_pci_read32(ab, MHISTATUS); 208 209 ath12k_dbg(ab, ATH12K_DBG_PCI, "MHISTATUS 0x%x\n", val); 210 211 /* Observed on some targets that after SOC_GLOBAL_RESET, MHISTATUS 212 * has SYSERR bit set and thus need to set MHICTRL_RESET 213 * to clear SYSERR. 214 */ 215 ath12k_pci_write32(ab, MHICTRL, MHICTRL_RESET_MASK); 216 217 mdelay(10); 218 } 219 220 static void ath12k_mhi_reset_txvecdb(struct ath12k_base *ab) 221 { 222 ath12k_pci_write32(ab, PCIE_TXVECDB, 0); 223 } 224 225 static void ath12k_mhi_reset_txvecstatus(struct ath12k_base *ab) 226 { 227 ath12k_pci_write32(ab, PCIE_TXVECSTATUS, 0); 228 } 229 230 static void ath12k_mhi_reset_rxvecdb(struct ath12k_base *ab) 231 { 232 ath12k_pci_write32(ab, PCIE_RXVECDB, 0); 233 } 234 235 static void ath12k_mhi_reset_rxvecstatus(struct ath12k_base *ab) 236 { 237 ath12k_pci_write32(ab, PCIE_RXVECSTATUS, 0); 238 } 239 240 void ath12k_mhi_clear_vector(struct ath12k_base *ab) 241 { 242 ath12k_mhi_reset_txvecdb(ab); 243 ath12k_mhi_reset_txvecstatus(ab); 244 ath12k_mhi_reset_rxvecdb(ab); 245 ath12k_mhi_reset_rxvecstatus(ab); 246 } 247 248 static int ath12k_mhi_get_msi(struct ath12k_pci *ab_pci) 249 { 250 struct ath12k_base *ab = ab_pci->ab; 251 u32 user_base_data, base_vector; 252 int ret, num_vectors, i; 253 int *irq; 254 255 ret = ath12k_pci_get_user_msi_assignment(ab, 256 "MHI", &num_vectors, 257 &user_base_data, &base_vector); 258 if (ret) 259 return ret; 260 261 ath12k_dbg(ab, ATH12K_DBG_PCI, "Number of assigned MSI for MHI is %d, base vector is %d\n", 262 num_vectors, base_vector); 263 264 irq = kcalloc(num_vectors, sizeof(*irq), GFP_KERNEL); 265 if (!irq) 266 return -ENOMEM; 267 268 for (i = 0; i < num_vectors; i++) 269 irq[i] = ath12k_pci_get_msi_irq(ab->dev, 270 base_vector + i); 271 272 ab_pci->mhi_ctrl->irq = irq; 273 ab_pci->mhi_ctrl->nr_irqs = num_vectors; 274 275 return 0; 276 } 277 278 static int ath12k_mhi_op_runtime_get(struct mhi_controller *mhi_cntrl) 279 { 280 return 0; 281 } 282 283 static void ath12k_mhi_op_runtime_put(struct mhi_controller *mhi_cntrl) 284 { 285 } 286 287 static char *ath12k_mhi_op_callback_to_str(enum mhi_callback reason) 288 { 289 switch (reason) { 290 case MHI_CB_IDLE: 291 return "MHI_CB_IDLE"; 292 case MHI_CB_PENDING_DATA: 293 return "MHI_CB_PENDING_DATA"; 294 case MHI_CB_LPM_ENTER: 295 return "MHI_CB_LPM_ENTER"; 296 case MHI_CB_LPM_EXIT: 297 return "MHI_CB_LPM_EXIT"; 298 case MHI_CB_EE_RDDM: 299 return "MHI_CB_EE_RDDM"; 300 case MHI_CB_EE_MISSION_MODE: 301 return "MHI_CB_EE_MISSION_MODE"; 302 case MHI_CB_SYS_ERROR: 303 return "MHI_CB_SYS_ERROR"; 304 case MHI_CB_FATAL_ERROR: 305 return "MHI_CB_FATAL_ERROR"; 306 case MHI_CB_BW_REQ: 307 return "MHI_CB_BW_REQ"; 308 default: 309 return "UNKNOWN"; 310 } 311 } 312 313 static void ath12k_mhi_op_status_cb(struct mhi_controller *mhi_cntrl, 314 enum mhi_callback cb) 315 { 316 struct ath12k_base *ab = dev_get_drvdata(mhi_cntrl->cntrl_dev); 317 318 ath12k_dbg(ab, ATH12K_DBG_BOOT, "mhi notify status reason %s\n", 319 ath12k_mhi_op_callback_to_str(cb)); 320 321 switch (cb) { 322 case MHI_CB_SYS_ERROR: 323 ath12k_warn(ab, "firmware crashed: MHI_CB_SYS_ERROR\n"); 324 break; 325 case MHI_CB_EE_RDDM: 326 if (!(test_bit(ATH12K_FLAG_UNREGISTERING, &ab->dev_flags))) 327 queue_work(ab->workqueue_aux, &ab->reset_work); 328 break; 329 default: 330 break; 331 } 332 } 333 334 static int ath12k_mhi_op_read_reg(struct mhi_controller *mhi_cntrl, 335 void __iomem *addr, 336 u32 *out) 337 { 338 *out = readl(addr); 339 340 return 0; 341 } 342 343 static void ath12k_mhi_op_write_reg(struct mhi_controller *mhi_cntrl, 344 void __iomem *addr, 345 u32 val) 346 { 347 writel(val, addr); 348 } 349 350 int ath12k_mhi_register(struct ath12k_pci *ab_pci) 351 { 352 struct ath12k_base *ab = ab_pci->ab; 353 struct mhi_controller *mhi_ctrl; 354 int ret; 355 356 mhi_ctrl = mhi_alloc_controller(); 357 if (!mhi_ctrl) 358 return -ENOMEM; 359 360 ath12k_core_create_firmware_path(ab, ATH12K_AMSS_FILE, 361 ab_pci->amss_path, 362 sizeof(ab_pci->amss_path)); 363 364 ab_pci->mhi_ctrl = mhi_ctrl; 365 mhi_ctrl->cntrl_dev = ab->dev; 366 mhi_ctrl->fw_image = ab_pci->amss_path; 367 mhi_ctrl->regs = ab->mem; 368 mhi_ctrl->reg_len = ab->mem_len; 369 mhi_ctrl->rddm_size = ab->hw_params->rddm_size; 370 371 ret = ath12k_mhi_get_msi(ab_pci); 372 if (ret) { 373 ath12k_err(ab, "failed to get msi for mhi\n"); 374 goto free_controller; 375 } 376 377 mhi_ctrl->iova_start = 0; 378 mhi_ctrl->iova_stop = 0xffffffff; 379 mhi_ctrl->sbl_size = SZ_512K; 380 mhi_ctrl->seg_len = SZ_512K; 381 mhi_ctrl->fbc_download = true; 382 mhi_ctrl->runtime_get = ath12k_mhi_op_runtime_get; 383 mhi_ctrl->runtime_put = ath12k_mhi_op_runtime_put; 384 mhi_ctrl->status_cb = ath12k_mhi_op_status_cb; 385 mhi_ctrl->read_reg = ath12k_mhi_op_read_reg; 386 mhi_ctrl->write_reg = ath12k_mhi_op_write_reg; 387 388 ret = mhi_register_controller(mhi_ctrl, ab->hw_params->mhi_config); 389 if (ret) { 390 ath12k_err(ab, "failed to register to mhi bus, err = %d\n", ret); 391 goto free_controller; 392 } 393 394 return 0; 395 396 free_controller: 397 mhi_free_controller(mhi_ctrl); 398 ab_pci->mhi_ctrl = NULL; 399 return ret; 400 } 401 402 void ath12k_mhi_unregister(struct ath12k_pci *ab_pci) 403 { 404 struct mhi_controller *mhi_ctrl = ab_pci->mhi_ctrl; 405 406 mhi_unregister_controller(mhi_ctrl); 407 kfree(mhi_ctrl->irq); 408 mhi_free_controller(mhi_ctrl); 409 ab_pci->mhi_ctrl = NULL; 410 } 411 412 static char *ath12k_mhi_state_to_str(enum ath12k_mhi_state mhi_state) 413 { 414 switch (mhi_state) { 415 case ATH12K_MHI_INIT: 416 return "INIT"; 417 case ATH12K_MHI_DEINIT: 418 return "DEINIT"; 419 case ATH12K_MHI_POWER_ON: 420 return "POWER_ON"; 421 case ATH12K_MHI_POWER_OFF: 422 return "POWER_OFF"; 423 case ATH12K_MHI_FORCE_POWER_OFF: 424 return "FORCE_POWER_OFF"; 425 case ATH12K_MHI_SUSPEND: 426 return "SUSPEND"; 427 case ATH12K_MHI_RESUME: 428 return "RESUME"; 429 case ATH12K_MHI_TRIGGER_RDDM: 430 return "TRIGGER_RDDM"; 431 case ATH12K_MHI_RDDM_DONE: 432 return "RDDM_DONE"; 433 default: 434 return "UNKNOWN"; 435 } 436 }; 437 438 static void ath12k_mhi_set_state_bit(struct ath12k_pci *ab_pci, 439 enum ath12k_mhi_state mhi_state) 440 { 441 struct ath12k_base *ab = ab_pci->ab; 442 443 switch (mhi_state) { 444 case ATH12K_MHI_INIT: 445 set_bit(ATH12K_MHI_INIT, &ab_pci->mhi_state); 446 break; 447 case ATH12K_MHI_DEINIT: 448 clear_bit(ATH12K_MHI_INIT, &ab_pci->mhi_state); 449 break; 450 case ATH12K_MHI_POWER_ON: 451 set_bit(ATH12K_MHI_POWER_ON, &ab_pci->mhi_state); 452 break; 453 case ATH12K_MHI_POWER_OFF: 454 case ATH12K_MHI_FORCE_POWER_OFF: 455 clear_bit(ATH12K_MHI_POWER_ON, &ab_pci->mhi_state); 456 clear_bit(ATH12K_MHI_TRIGGER_RDDM, &ab_pci->mhi_state); 457 clear_bit(ATH12K_MHI_RDDM_DONE, &ab_pci->mhi_state); 458 break; 459 case ATH12K_MHI_SUSPEND: 460 set_bit(ATH12K_MHI_SUSPEND, &ab_pci->mhi_state); 461 break; 462 case ATH12K_MHI_RESUME: 463 clear_bit(ATH12K_MHI_SUSPEND, &ab_pci->mhi_state); 464 break; 465 case ATH12K_MHI_TRIGGER_RDDM: 466 set_bit(ATH12K_MHI_TRIGGER_RDDM, &ab_pci->mhi_state); 467 break; 468 case ATH12K_MHI_RDDM_DONE: 469 set_bit(ATH12K_MHI_RDDM_DONE, &ab_pci->mhi_state); 470 break; 471 default: 472 ath12k_err(ab, "unhandled mhi state (%d)\n", mhi_state); 473 } 474 } 475 476 static int ath12k_mhi_check_state_bit(struct ath12k_pci *ab_pci, 477 enum ath12k_mhi_state mhi_state) 478 { 479 struct ath12k_base *ab = ab_pci->ab; 480 481 switch (mhi_state) { 482 case ATH12K_MHI_INIT: 483 if (!test_bit(ATH12K_MHI_INIT, &ab_pci->mhi_state)) 484 return 0; 485 break; 486 case ATH12K_MHI_DEINIT: 487 case ATH12K_MHI_POWER_ON: 488 if (test_bit(ATH12K_MHI_INIT, &ab_pci->mhi_state) && 489 !test_bit(ATH12K_MHI_POWER_ON, &ab_pci->mhi_state)) 490 return 0; 491 break; 492 case ATH12K_MHI_FORCE_POWER_OFF: 493 if (test_bit(ATH12K_MHI_POWER_ON, &ab_pci->mhi_state)) 494 return 0; 495 break; 496 case ATH12K_MHI_POWER_OFF: 497 case ATH12K_MHI_SUSPEND: 498 if (test_bit(ATH12K_MHI_POWER_ON, &ab_pci->mhi_state) && 499 !test_bit(ATH12K_MHI_SUSPEND, &ab_pci->mhi_state)) 500 return 0; 501 break; 502 case ATH12K_MHI_RESUME: 503 if (test_bit(ATH12K_MHI_SUSPEND, &ab_pci->mhi_state)) 504 return 0; 505 break; 506 case ATH12K_MHI_TRIGGER_RDDM: 507 if (test_bit(ATH12K_MHI_POWER_ON, &ab_pci->mhi_state) && 508 !test_bit(ATH12K_MHI_TRIGGER_RDDM, &ab_pci->mhi_state)) 509 return 0; 510 break; 511 case ATH12K_MHI_RDDM_DONE: 512 return 0; 513 default: 514 ath12k_err(ab, "unhandled mhi state: %s(%d)\n", 515 ath12k_mhi_state_to_str(mhi_state), mhi_state); 516 } 517 518 ath12k_err(ab, "failed to set mhi state %s(%d) in current mhi state (0x%lx)\n", 519 ath12k_mhi_state_to_str(mhi_state), mhi_state, 520 ab_pci->mhi_state); 521 522 return -EINVAL; 523 } 524 525 static int ath12k_mhi_set_state(struct ath12k_pci *ab_pci, 526 enum ath12k_mhi_state mhi_state) 527 { 528 struct ath12k_base *ab = ab_pci->ab; 529 int ret; 530 531 ret = ath12k_mhi_check_state_bit(ab_pci, mhi_state); 532 if (ret) 533 goto out; 534 535 ath12k_dbg(ab, ATH12K_DBG_PCI, "setting mhi state: %s(%d)\n", 536 ath12k_mhi_state_to_str(mhi_state), mhi_state); 537 538 switch (mhi_state) { 539 case ATH12K_MHI_INIT: 540 ret = mhi_prepare_for_power_up(ab_pci->mhi_ctrl); 541 break; 542 case ATH12K_MHI_DEINIT: 543 mhi_unprepare_after_power_down(ab_pci->mhi_ctrl); 544 ret = 0; 545 break; 546 case ATH12K_MHI_POWER_ON: 547 ret = mhi_async_power_up(ab_pci->mhi_ctrl); 548 break; 549 case ATH12K_MHI_POWER_OFF: 550 mhi_power_down(ab_pci->mhi_ctrl, true); 551 ret = 0; 552 break; 553 case ATH12K_MHI_FORCE_POWER_OFF: 554 mhi_power_down(ab_pci->mhi_ctrl, false); 555 ret = 0; 556 break; 557 case ATH12K_MHI_SUSPEND: 558 ret = mhi_pm_suspend(ab_pci->mhi_ctrl); 559 break; 560 case ATH12K_MHI_RESUME: 561 ret = mhi_pm_resume(ab_pci->mhi_ctrl); 562 break; 563 case ATH12K_MHI_TRIGGER_RDDM: 564 ret = mhi_force_rddm_mode(ab_pci->mhi_ctrl); 565 break; 566 case ATH12K_MHI_RDDM_DONE: 567 break; 568 default: 569 ath12k_err(ab, "unhandled MHI state (%d)\n", mhi_state); 570 ret = -EINVAL; 571 } 572 573 if (ret) 574 goto out; 575 576 ath12k_mhi_set_state_bit(ab_pci, mhi_state); 577 578 return 0; 579 580 out: 581 ath12k_err(ab, "failed to set mhi state: %s(%d)\n", 582 ath12k_mhi_state_to_str(mhi_state), mhi_state); 583 return ret; 584 } 585 586 int ath12k_mhi_start(struct ath12k_pci *ab_pci) 587 { 588 int ret; 589 590 ab_pci->mhi_ctrl->timeout_ms = MHI_TIMEOUT_DEFAULT_MS; 591 592 ret = ath12k_mhi_set_state(ab_pci, ATH12K_MHI_INIT); 593 if (ret) 594 goto out; 595 596 ret = ath12k_mhi_set_state(ab_pci, ATH12K_MHI_POWER_ON); 597 if (ret) 598 goto out; 599 600 return 0; 601 602 out: 603 return ret; 604 } 605 606 void ath12k_mhi_stop(struct ath12k_pci *ab_pci) 607 { 608 ath12k_mhi_set_state(ab_pci, ATH12K_MHI_POWER_OFF); 609 ath12k_mhi_set_state(ab_pci, ATH12K_MHI_DEINIT); 610 } 611 612 void ath12k_mhi_suspend(struct ath12k_pci *ab_pci) 613 { 614 ath12k_mhi_set_state(ab_pci, ATH12K_MHI_SUSPEND); 615 } 616 617 void ath12k_mhi_resume(struct ath12k_pci *ab_pci) 618 { 619 ath12k_mhi_set_state(ab_pci, ATH12K_MHI_RESUME); 620 } 621