1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Qualcomm Technology Inc. ADSP Peripheral Image Loader for SDM845. 4 * Copyright (c) 2018, The Linux Foundation. All rights reserved. 5 */ 6 7 #include <linux/clk.h> 8 #include <linux/delay.h> 9 #include <linux/firmware.h> 10 #include <linux/interrupt.h> 11 #include <linux/io.h> 12 #include <linux/iommu.h> 13 #include <linux/iopoll.h> 14 #include <linux/kernel.h> 15 #include <linux/mfd/syscon.h> 16 #include <linux/module.h> 17 #include <linux/of.h> 18 #include <linux/of_reserved_mem.h> 19 #include <linux/platform_device.h> 20 #include <linux/pm_domain.h> 21 #include <linux/pm_runtime.h> 22 #include <linux/regmap.h> 23 #include <linux/remoteproc.h> 24 #include <linux/reset.h> 25 #include <linux/soc/qcom/mdt_loader.h> 26 #include <linux/soc/qcom/smem.h> 27 #include <linux/soc/qcom/smem_state.h> 28 29 #include "qcom_common.h" 30 #include "qcom_pil_info.h" 31 #include "qcom_q6v5.h" 32 #include "remoteproc_internal.h" 33 34 /* time out value */ 35 #define ACK_TIMEOUT 1000 36 #define ACK_TIMEOUT_US 1000000 37 #define BOOT_FSM_TIMEOUT 10000 38 /* mask values */ 39 #define EVB_MASK GENMASK(27, 4) 40 /*QDSP6SS register offsets*/ 41 #define RST_EVB_REG 0x10 42 #define CORE_START_REG 0x400 43 #define BOOT_CMD_REG 0x404 44 #define BOOT_STATUS_REG 0x408 45 #define RET_CFG_REG 0x1C 46 /*TCSR register offsets*/ 47 #define LPASS_MASTER_IDLE_REG 0x8 48 #define LPASS_HALTACK_REG 0x4 49 #define LPASS_PWR_ON_REG 0x10 50 #define LPASS_HALTREQ_REG 0x0 51 52 #define SID_MASK_DEFAULT 0xF 53 54 #define QDSP6SS_XO_CBCR 0x38 55 #define QDSP6SS_CORE_CBCR 0x20 56 #define QDSP6SS_SLEEP_CBCR 0x3c 57 58 #define LPASS_BOOT_CORE_START BIT(0) 59 #define LPASS_BOOT_CMD_START BIT(0) 60 #define LPASS_EFUSE_Q6SS_EVB_SEL 0x0 61 62 struct adsp_pil_data { 63 int crash_reason_smem; 64 const char *firmware_name; 65 66 const char *ssr_name; 67 const char *sysmon_name; 68 int ssctl_id; 69 bool is_wpss; 70 bool has_iommu; 71 bool auto_boot; 72 73 const char **clk_ids; 74 int num_clks; 75 const char **pd_names; 76 unsigned int num_pds; 77 const char *load_state; 78 }; 79 80 struct qcom_adsp { 81 struct device *dev; 82 struct rproc *rproc; 83 84 struct qcom_q6v5 q6v5; 85 86 struct clk *xo; 87 88 int num_clks; 89 struct clk_bulk_data *clks; 90 91 void __iomem *qdsp6ss_base; 92 void __iomem *lpass_efuse; 93 94 struct reset_control *pdc_sync_reset; 95 struct reset_control *restart; 96 97 struct regmap *halt_map; 98 unsigned int halt_lpass; 99 100 int crash_reason_smem; 101 const char *info_name; 102 103 struct completion start_done; 104 struct completion stop_done; 105 106 phys_addr_t mem_phys; 107 phys_addr_t mem_reloc; 108 void *mem_region; 109 size_t mem_size; 110 bool has_iommu; 111 112 struct dev_pm_domain_list *pd_list; 113 114 struct qcom_rproc_glink glink_subdev; 115 struct qcom_rproc_pdm pdm_subdev; 116 struct qcom_rproc_ssr ssr_subdev; 117 struct qcom_sysmon *sysmon; 118 119 int (*shutdown)(struct qcom_adsp *adsp); 120 }; 121 122 static int qcom_rproc_pds_attach(struct qcom_adsp *adsp, const char **pd_names, 123 unsigned int num_pds) 124 { 125 struct device *dev = adsp->dev; 126 struct dev_pm_domain_attach_data pd_data = { 127 .pd_names = pd_names, 128 .num_pd_names = num_pds, 129 }; 130 int ret; 131 132 /* Handle single power domain */ 133 if (dev->pm_domain) 134 goto out; 135 136 if (!pd_names) 137 return 0; 138 139 ret = dev_pm_domain_attach_list(dev, &pd_data, &adsp->pd_list); 140 if (ret < 0) 141 return ret; 142 143 out: 144 pm_runtime_enable(dev); 145 return 0; 146 } 147 148 static void qcom_rproc_pds_detach(struct qcom_adsp *adsp) 149 { 150 struct device *dev = adsp->dev; 151 struct dev_pm_domain_list *pds = adsp->pd_list; 152 153 dev_pm_domain_detach_list(pds); 154 155 if (dev->pm_domain || pds) 156 pm_runtime_disable(adsp->dev); 157 } 158 159 static int qcom_rproc_pds_enable(struct qcom_adsp *adsp) 160 { 161 struct device *dev = adsp->dev; 162 struct dev_pm_domain_list *pds = adsp->pd_list; 163 int ret, i = 0; 164 165 if (!dev->pm_domain && !pds) 166 return 0; 167 168 if (dev->pm_domain) 169 dev_pm_genpd_set_performance_state(dev, INT_MAX); 170 171 while (pds && i < pds->num_pds) { 172 dev_pm_genpd_set_performance_state(pds->pd_devs[i], INT_MAX); 173 i++; 174 } 175 176 ret = pm_runtime_resume_and_get(dev); 177 if (ret < 0) { 178 while (pds && i > 0) { 179 i--; 180 dev_pm_genpd_set_performance_state(pds->pd_devs[i], 0); 181 } 182 183 if (dev->pm_domain) 184 dev_pm_genpd_set_performance_state(dev, 0); 185 } 186 187 return ret; 188 } 189 190 static void qcom_rproc_pds_disable(struct qcom_adsp *adsp) 191 { 192 struct device *dev = adsp->dev; 193 struct dev_pm_domain_list *pds = adsp->pd_list; 194 int i = 0; 195 196 if (!dev->pm_domain && !pds) 197 return; 198 199 if (dev->pm_domain) 200 dev_pm_genpd_set_performance_state(dev, 0); 201 202 while (pds && i < pds->num_pds) { 203 dev_pm_genpd_set_performance_state(pds->pd_devs[i], 0); 204 i++; 205 } 206 207 pm_runtime_put(dev); 208 } 209 210 static int qcom_wpss_shutdown(struct qcom_adsp *adsp) 211 { 212 unsigned int val; 213 214 regmap_write(adsp->halt_map, adsp->halt_lpass + LPASS_HALTREQ_REG, 1); 215 216 /* Wait for halt ACK from QDSP6 */ 217 regmap_read_poll_timeout(adsp->halt_map, 218 adsp->halt_lpass + LPASS_HALTACK_REG, val, 219 val, 1000, ACK_TIMEOUT_US); 220 221 /* Assert the WPSS PDC Reset */ 222 reset_control_assert(adsp->pdc_sync_reset); 223 224 /* Place the WPSS processor into reset */ 225 reset_control_assert(adsp->restart); 226 227 /* wait after asserting subsystem restart from AOSS */ 228 usleep_range(200, 205); 229 230 /* Remove the WPSS reset */ 231 reset_control_deassert(adsp->restart); 232 233 /* De-assert the WPSS PDC Reset */ 234 reset_control_deassert(adsp->pdc_sync_reset); 235 236 usleep_range(100, 105); 237 238 clk_bulk_disable_unprepare(adsp->num_clks, adsp->clks); 239 240 regmap_write(adsp->halt_map, adsp->halt_lpass + LPASS_HALTREQ_REG, 0); 241 242 /* Wait for halt ACK from QDSP6 */ 243 regmap_read_poll_timeout(adsp->halt_map, 244 adsp->halt_lpass + LPASS_HALTACK_REG, val, 245 !val, 1000, ACK_TIMEOUT_US); 246 247 return 0; 248 } 249 250 static int qcom_adsp_shutdown(struct qcom_adsp *adsp) 251 { 252 unsigned long timeout; 253 unsigned int val; 254 int ret; 255 256 /* Reset the retention logic */ 257 val = readl(adsp->qdsp6ss_base + RET_CFG_REG); 258 val |= 0x1; 259 writel(val, adsp->qdsp6ss_base + RET_CFG_REG); 260 261 clk_bulk_disable_unprepare(adsp->num_clks, adsp->clks); 262 263 /* QDSP6 master port needs to be explicitly halted */ 264 ret = regmap_read(adsp->halt_map, 265 adsp->halt_lpass + LPASS_PWR_ON_REG, &val); 266 if (ret || !val) 267 goto reset; 268 269 ret = regmap_read(adsp->halt_map, 270 adsp->halt_lpass + LPASS_MASTER_IDLE_REG, 271 &val); 272 if (ret || val) 273 goto reset; 274 275 regmap_write(adsp->halt_map, 276 adsp->halt_lpass + LPASS_HALTREQ_REG, 1); 277 278 /* Wait for halt ACK from QDSP6 */ 279 timeout = jiffies + msecs_to_jiffies(ACK_TIMEOUT); 280 for (;;) { 281 ret = regmap_read(adsp->halt_map, 282 adsp->halt_lpass + LPASS_HALTACK_REG, &val); 283 if (ret || val || time_after(jiffies, timeout)) 284 break; 285 286 usleep_range(1000, 1100); 287 } 288 289 ret = regmap_read(adsp->halt_map, 290 adsp->halt_lpass + LPASS_MASTER_IDLE_REG, &val); 291 if (ret || !val) 292 dev_err(adsp->dev, "port failed halt\n"); 293 294 reset: 295 /* Assert the LPASS PDC Reset */ 296 reset_control_assert(adsp->pdc_sync_reset); 297 /* Place the LPASS processor into reset */ 298 reset_control_assert(adsp->restart); 299 /* wait after asserting subsystem restart from AOSS */ 300 usleep_range(200, 300); 301 302 /* Clear the halt request for the AXIM and AHBM for Q6 */ 303 regmap_write(adsp->halt_map, adsp->halt_lpass + LPASS_HALTREQ_REG, 0); 304 305 /* De-assert the LPASS PDC Reset */ 306 reset_control_deassert(adsp->pdc_sync_reset); 307 /* Remove the LPASS reset */ 308 reset_control_deassert(adsp->restart); 309 /* wait after de-asserting subsystem restart from AOSS */ 310 usleep_range(200, 300); 311 312 return 0; 313 } 314 315 static int adsp_load(struct rproc *rproc, const struct firmware *fw) 316 { 317 struct qcom_adsp *adsp = rproc->priv; 318 int ret; 319 320 ret = qcom_mdt_load_no_init(adsp->dev, fw, rproc->firmware, 0, 321 adsp->mem_region, adsp->mem_phys, 322 adsp->mem_size, &adsp->mem_reloc); 323 if (ret) 324 return ret; 325 326 qcom_pil_info_store(adsp->info_name, adsp->mem_phys, adsp->mem_size); 327 328 return 0; 329 } 330 331 static void adsp_unmap_carveout(struct rproc *rproc) 332 { 333 struct qcom_adsp *adsp = rproc->priv; 334 335 if (adsp->has_iommu) 336 iommu_unmap(rproc->domain, adsp->mem_phys, adsp->mem_size); 337 } 338 339 static int adsp_map_carveout(struct rproc *rproc) 340 { 341 struct qcom_adsp *adsp = rproc->priv; 342 struct of_phandle_args args; 343 long long sid; 344 unsigned long iova; 345 int ret; 346 347 if (!adsp->has_iommu) 348 return 0; 349 350 if (!rproc->domain) 351 return -EINVAL; 352 353 ret = of_parse_phandle_with_args(adsp->dev->of_node, "iommus", "#iommu-cells", 0, &args); 354 if (ret < 0) 355 return ret; 356 357 sid = args.args[0] & SID_MASK_DEFAULT; 358 359 /* Add SID configuration for ADSP Firmware to SMMU */ 360 iova = adsp->mem_phys | (sid << 32); 361 362 ret = iommu_map(rproc->domain, iova, adsp->mem_phys, 363 adsp->mem_size, IOMMU_READ | IOMMU_WRITE, 364 GFP_KERNEL); 365 if (ret) { 366 dev_err(adsp->dev, "Unable to map ADSP Physical Memory\n"); 367 return ret; 368 } 369 370 return 0; 371 } 372 373 static int adsp_start(struct rproc *rproc) 374 { 375 struct qcom_adsp *adsp = rproc->priv; 376 int ret; 377 unsigned int val; 378 379 ret = qcom_q6v5_prepare(&adsp->q6v5); 380 if (ret) 381 return ret; 382 383 ret = adsp_map_carveout(rproc); 384 if (ret) { 385 dev_err(adsp->dev, "ADSP smmu mapping failed\n"); 386 goto disable_irqs; 387 } 388 389 ret = clk_prepare_enable(adsp->xo); 390 if (ret) 391 goto adsp_smmu_unmap; 392 393 ret = qcom_rproc_pds_enable(adsp); 394 if (ret < 0) 395 goto disable_xo_clk; 396 397 ret = clk_bulk_prepare_enable(adsp->num_clks, adsp->clks); 398 if (ret) { 399 dev_err(adsp->dev, "adsp clk_enable failed\n"); 400 goto disable_power_domain; 401 } 402 403 /* Enable the XO clock */ 404 writel(1, adsp->qdsp6ss_base + QDSP6SS_XO_CBCR); 405 406 /* Enable the QDSP6SS sleep clock */ 407 writel(1, adsp->qdsp6ss_base + QDSP6SS_SLEEP_CBCR); 408 409 /* Enable the QDSP6 core clock */ 410 writel(1, adsp->qdsp6ss_base + QDSP6SS_CORE_CBCR); 411 412 /* Program boot address */ 413 writel(adsp->mem_phys >> 4, adsp->qdsp6ss_base + RST_EVB_REG); 414 415 if (adsp->lpass_efuse) 416 writel(LPASS_EFUSE_Q6SS_EVB_SEL, adsp->lpass_efuse); 417 418 /* De-assert QDSP6 stop core. QDSP6 will execute after out of reset */ 419 writel(LPASS_BOOT_CORE_START, adsp->qdsp6ss_base + CORE_START_REG); 420 421 /* Trigger boot FSM to start QDSP6 */ 422 writel(LPASS_BOOT_CMD_START, adsp->qdsp6ss_base + BOOT_CMD_REG); 423 424 /* Wait for core to come out of reset */ 425 ret = readl_poll_timeout(adsp->qdsp6ss_base + BOOT_STATUS_REG, 426 val, (val & BIT(0)) != 0, 10, BOOT_FSM_TIMEOUT); 427 if (ret) { 428 dev_err(adsp->dev, "failed to bootup adsp\n"); 429 goto disable_adsp_clks; 430 } 431 432 ret = qcom_q6v5_wait_for_start(&adsp->q6v5, msecs_to_jiffies(5 * HZ)); 433 if (ret == -ETIMEDOUT) { 434 dev_err(adsp->dev, "start timed out\n"); 435 goto disable_adsp_clks; 436 } 437 438 return 0; 439 440 disable_adsp_clks: 441 clk_bulk_disable_unprepare(adsp->num_clks, adsp->clks); 442 disable_power_domain: 443 qcom_rproc_pds_disable(adsp); 444 disable_xo_clk: 445 clk_disable_unprepare(adsp->xo); 446 adsp_smmu_unmap: 447 adsp_unmap_carveout(rproc); 448 disable_irqs: 449 qcom_q6v5_unprepare(&adsp->q6v5); 450 451 return ret; 452 } 453 454 static void qcom_adsp_pil_handover(struct qcom_q6v5 *q6v5) 455 { 456 struct qcom_adsp *adsp = container_of(q6v5, struct qcom_adsp, q6v5); 457 458 clk_disable_unprepare(adsp->xo); 459 qcom_rproc_pds_disable(adsp); 460 } 461 462 static int adsp_stop(struct rproc *rproc) 463 { 464 struct qcom_adsp *adsp = rproc->priv; 465 int handover; 466 int ret; 467 468 ret = qcom_q6v5_request_stop(&adsp->q6v5, adsp->sysmon); 469 if (ret == -ETIMEDOUT) 470 dev_err(adsp->dev, "timed out on wait\n"); 471 472 ret = adsp->shutdown(adsp); 473 if (ret) 474 dev_err(adsp->dev, "failed to shutdown: %d\n", ret); 475 476 adsp_unmap_carveout(rproc); 477 478 handover = qcom_q6v5_unprepare(&adsp->q6v5); 479 if (handover) 480 qcom_adsp_pil_handover(&adsp->q6v5); 481 482 return ret; 483 } 484 485 static void *adsp_da_to_va(struct rproc *rproc, u64 da, size_t len, bool *is_iomem) 486 { 487 struct qcom_adsp *adsp = rproc->priv; 488 int offset; 489 490 offset = da - adsp->mem_reloc; 491 if (offset < 0 || offset + len > adsp->mem_size) 492 return NULL; 493 494 return adsp->mem_region + offset; 495 } 496 497 static int adsp_parse_firmware(struct rproc *rproc, const struct firmware *fw) 498 { 499 struct qcom_adsp *adsp = rproc->priv; 500 int ret; 501 502 ret = qcom_register_dump_segments(rproc, fw); 503 if (ret) { 504 dev_err(&rproc->dev, "Error in registering dump segments\n"); 505 return ret; 506 } 507 508 if (adsp->has_iommu) { 509 ret = rproc_elf_load_rsc_table(rproc, fw); 510 if (ret) { 511 dev_err(&rproc->dev, "Error in loading resource table\n"); 512 return ret; 513 } 514 } 515 return 0; 516 } 517 518 static unsigned long adsp_panic(struct rproc *rproc) 519 { 520 struct qcom_adsp *adsp = rproc->priv; 521 522 return qcom_q6v5_panic(&adsp->q6v5); 523 } 524 525 static const struct rproc_ops adsp_ops = { 526 .start = adsp_start, 527 .stop = adsp_stop, 528 .da_to_va = adsp_da_to_va, 529 .parse_fw = adsp_parse_firmware, 530 .load = adsp_load, 531 .panic = adsp_panic, 532 }; 533 534 static int adsp_init_clock(struct qcom_adsp *adsp, const char **clk_ids) 535 { 536 int num_clks = 0; 537 int i; 538 539 adsp->xo = devm_clk_get(adsp->dev, "xo"); 540 if (IS_ERR(adsp->xo)) 541 return dev_err_probe(adsp->dev, PTR_ERR(adsp->xo), "failed to get xo clock"); 542 543 for (i = 0; clk_ids[i]; i++) 544 num_clks++; 545 546 adsp->num_clks = num_clks; 547 adsp->clks = devm_kcalloc(adsp->dev, adsp->num_clks, 548 sizeof(*adsp->clks), GFP_KERNEL); 549 if (!adsp->clks) 550 return -ENOMEM; 551 552 for (i = 0; i < adsp->num_clks; i++) 553 adsp->clks[i].id = clk_ids[i]; 554 555 return devm_clk_bulk_get(adsp->dev, adsp->num_clks, adsp->clks); 556 } 557 558 static int adsp_init_reset(struct qcom_adsp *adsp) 559 { 560 adsp->pdc_sync_reset = devm_reset_control_get_optional_exclusive(adsp->dev, 561 "pdc_sync"); 562 if (IS_ERR(adsp->pdc_sync_reset)) { 563 dev_err(adsp->dev, "failed to acquire pdc_sync reset\n"); 564 return PTR_ERR(adsp->pdc_sync_reset); 565 } 566 567 adsp->restart = devm_reset_control_get_optional_exclusive(adsp->dev, "restart"); 568 569 /* Fall back to the old "cc_lpass" if "restart" is absent */ 570 if (!adsp->restart) 571 adsp->restart = devm_reset_control_get_exclusive(adsp->dev, "cc_lpass"); 572 573 if (IS_ERR(adsp->restart)) { 574 dev_err(adsp->dev, "failed to acquire restart\n"); 575 return PTR_ERR(adsp->restart); 576 } 577 578 return 0; 579 } 580 581 static int adsp_init_mmio(struct qcom_adsp *adsp, 582 struct platform_device *pdev) 583 { 584 struct resource *efuse_region; 585 struct device_node *syscon; 586 int ret; 587 588 adsp->qdsp6ss_base = devm_platform_ioremap_resource(pdev, 0); 589 if (IS_ERR(adsp->qdsp6ss_base)) { 590 dev_err(adsp->dev, "failed to map QDSP6SS registers\n"); 591 return PTR_ERR(adsp->qdsp6ss_base); 592 } 593 594 efuse_region = platform_get_resource(pdev, IORESOURCE_MEM, 1); 595 if (!efuse_region) { 596 adsp->lpass_efuse = NULL; 597 dev_dbg(adsp->dev, "failed to get efuse memory region\n"); 598 } else { 599 adsp->lpass_efuse = devm_ioremap_resource(&pdev->dev, efuse_region); 600 if (IS_ERR(adsp->lpass_efuse)) { 601 dev_err(adsp->dev, "failed to map efuse registers\n"); 602 return PTR_ERR(adsp->lpass_efuse); 603 } 604 } 605 syscon = of_parse_phandle(pdev->dev.of_node, "qcom,halt-regs", 0); 606 if (!syscon) { 607 dev_err(&pdev->dev, "failed to parse qcom,halt-regs\n"); 608 return -EINVAL; 609 } 610 611 adsp->halt_map = syscon_node_to_regmap(syscon); 612 of_node_put(syscon); 613 if (IS_ERR(adsp->halt_map)) 614 return PTR_ERR(adsp->halt_map); 615 616 ret = of_property_read_u32_index(pdev->dev.of_node, "qcom,halt-regs", 617 1, &adsp->halt_lpass); 618 if (ret < 0) { 619 dev_err(&pdev->dev, "no offset in syscon\n"); 620 return ret; 621 } 622 623 return 0; 624 } 625 626 static int adsp_alloc_memory_region(struct qcom_adsp *adsp) 627 { 628 struct reserved_mem *rmem = NULL; 629 struct device_node *node; 630 631 node = of_parse_phandle(adsp->dev->of_node, "memory-region", 0); 632 if (node) 633 rmem = of_reserved_mem_lookup(node); 634 of_node_put(node); 635 636 if (!rmem) { 637 dev_err(adsp->dev, "unable to resolve memory-region\n"); 638 return -EINVAL; 639 } 640 641 adsp->mem_phys = adsp->mem_reloc = rmem->base; 642 adsp->mem_size = rmem->size; 643 adsp->mem_region = devm_ioremap_wc(adsp->dev, 644 adsp->mem_phys, adsp->mem_size); 645 if (!adsp->mem_region) { 646 dev_err(adsp->dev, "unable to map memory region: %pa+%zx\n", 647 &rmem->base, adsp->mem_size); 648 return -EBUSY; 649 } 650 651 return 0; 652 } 653 654 static int adsp_probe(struct platform_device *pdev) 655 { 656 const struct adsp_pil_data *desc; 657 const char *firmware_name; 658 struct qcom_adsp *adsp; 659 struct rproc *rproc; 660 int ret; 661 662 desc = of_device_get_match_data(&pdev->dev); 663 if (!desc) 664 return -EINVAL; 665 666 firmware_name = desc->firmware_name; 667 ret = of_property_read_string(pdev->dev.of_node, "firmware-name", 668 &firmware_name); 669 if (ret < 0 && ret != -EINVAL) { 670 dev_err(&pdev->dev, "unable to read firmware-name\n"); 671 return ret; 672 } 673 674 rproc = devm_rproc_alloc(&pdev->dev, pdev->name, &adsp_ops, 675 firmware_name, sizeof(*adsp)); 676 if (!rproc) { 677 dev_err(&pdev->dev, "unable to allocate remoteproc\n"); 678 return -ENOMEM; 679 } 680 681 rproc->auto_boot = desc->auto_boot; 682 rproc->has_iommu = desc->has_iommu; 683 rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_NONE); 684 685 adsp = rproc->priv; 686 adsp->dev = &pdev->dev; 687 adsp->rproc = rproc; 688 adsp->info_name = desc->sysmon_name; 689 adsp->has_iommu = desc->has_iommu; 690 691 platform_set_drvdata(pdev, adsp); 692 693 if (desc->is_wpss) 694 adsp->shutdown = qcom_wpss_shutdown; 695 else 696 adsp->shutdown = qcom_adsp_shutdown; 697 698 ret = adsp_alloc_memory_region(adsp); 699 if (ret) 700 return ret; 701 702 ret = adsp_init_clock(adsp, desc->clk_ids); 703 if (ret) 704 return ret; 705 706 ret = qcom_rproc_pds_attach(adsp, desc->pd_names, desc->num_pds); 707 if (ret < 0) 708 return dev_err_probe(&pdev->dev, ret, 709 "Failed to attach proxy power domains\n"); 710 711 ret = adsp_init_reset(adsp); 712 if (ret) 713 goto disable_pm; 714 715 ret = adsp_init_mmio(adsp, pdev); 716 if (ret) 717 goto disable_pm; 718 719 ret = qcom_q6v5_init(&adsp->q6v5, pdev, rproc, desc->crash_reason_smem, 720 desc->load_state, qcom_adsp_pil_handover); 721 if (ret) 722 goto disable_pm; 723 724 qcom_add_glink_subdev(rproc, &adsp->glink_subdev, desc->ssr_name); 725 qcom_add_pdm_subdev(rproc, &adsp->pdm_subdev); 726 qcom_add_ssr_subdev(rproc, &adsp->ssr_subdev, desc->ssr_name); 727 adsp->sysmon = qcom_add_sysmon_subdev(rproc, 728 desc->sysmon_name, 729 desc->ssctl_id); 730 if (IS_ERR(adsp->sysmon)) { 731 ret = PTR_ERR(adsp->sysmon); 732 goto deinit_remove_glink_pdm_ssr; 733 } 734 735 ret = rproc_add(rproc); 736 if (ret) 737 goto remove_sysmon; 738 739 return 0; 740 741 remove_sysmon: 742 qcom_remove_sysmon_subdev(adsp->sysmon); 743 deinit_remove_glink_pdm_ssr: 744 qcom_q6v5_deinit(&adsp->q6v5); 745 qcom_remove_glink_subdev(rproc, &adsp->glink_subdev); 746 qcom_remove_pdm_subdev(rproc, &adsp->pdm_subdev); 747 qcom_remove_ssr_subdev(rproc, &adsp->ssr_subdev); 748 disable_pm: 749 qcom_rproc_pds_detach(adsp); 750 751 return ret; 752 } 753 754 static void adsp_remove(struct platform_device *pdev) 755 { 756 struct qcom_adsp *adsp = platform_get_drvdata(pdev); 757 758 rproc_del(adsp->rproc); 759 760 qcom_q6v5_deinit(&adsp->q6v5); 761 qcom_remove_glink_subdev(adsp->rproc, &adsp->glink_subdev); 762 qcom_remove_pdm_subdev(adsp->rproc, &adsp->pdm_subdev); 763 qcom_remove_sysmon_subdev(adsp->sysmon); 764 qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev); 765 qcom_rproc_pds_detach(adsp); 766 } 767 768 static const struct adsp_pil_data adsp_resource_init = { 769 .crash_reason_smem = 423, 770 .firmware_name = "adsp.mdt", 771 .ssr_name = "lpass", 772 .sysmon_name = "adsp", 773 .ssctl_id = 0x14, 774 .is_wpss = false, 775 .auto_boot = true, 776 .clk_ids = (const char*[]) { 777 "sway_cbcr", "lpass_ahbs_aon_cbcr", "lpass_ahbm_aon_cbcr", 778 "qdsp6ss_xo", "qdsp6ss_sleep", "qdsp6ss_core", NULL 779 }, 780 .num_clks = 7, 781 .pd_names = (const char*[]) { "cx" }, 782 .num_pds = 1, 783 }; 784 785 static const struct adsp_pil_data adsp_sc7280_resource_init = { 786 .crash_reason_smem = 423, 787 .firmware_name = "adsp.pbn", 788 .load_state = "adsp", 789 .ssr_name = "lpass", 790 .sysmon_name = "adsp", 791 .ssctl_id = 0x14, 792 .has_iommu = true, 793 .auto_boot = true, 794 .clk_ids = (const char*[]) { 795 "gcc_cfg_noc_lpass", NULL 796 }, 797 .num_clks = 1, 798 }; 799 800 static const struct adsp_pil_data cdsp_resource_init = { 801 .crash_reason_smem = 601, 802 .firmware_name = "cdsp.mdt", 803 .ssr_name = "cdsp", 804 .sysmon_name = "cdsp", 805 .ssctl_id = 0x17, 806 .is_wpss = false, 807 .auto_boot = true, 808 .clk_ids = (const char*[]) { 809 "sway", "tbu", "bimc", "ahb_aon", "q6ss_slave", "q6ss_master", 810 "q6_axim", NULL 811 }, 812 .num_clks = 7, 813 .pd_names = (const char*[]) { "cx" }, 814 .num_pds = 1, 815 }; 816 817 static const struct adsp_pil_data wpss_resource_init = { 818 .crash_reason_smem = 626, 819 .firmware_name = "wpss.mdt", 820 .ssr_name = "wpss", 821 .sysmon_name = "wpss", 822 .ssctl_id = 0x19, 823 .is_wpss = true, 824 .auto_boot = false, 825 .load_state = "wpss", 826 .clk_ids = (const char*[]) { 827 "ahb_bdg", "ahb", "rscp", NULL 828 }, 829 .num_clks = 3, 830 .pd_names = (const char*[]) { "cx", "mx" }, 831 .num_pds = 2, 832 }; 833 834 static const struct of_device_id adsp_of_match[] = { 835 { .compatible = "qcom,qcs404-cdsp-pil", .data = &cdsp_resource_init }, 836 { .compatible = "qcom,sc7280-adsp-pil", .data = &adsp_sc7280_resource_init }, 837 { .compatible = "qcom,sc7280-wpss-pil", .data = &wpss_resource_init }, 838 { .compatible = "qcom,sdm845-adsp-pil", .data = &adsp_resource_init }, 839 { }, 840 }; 841 MODULE_DEVICE_TABLE(of, adsp_of_match); 842 843 static struct platform_driver adsp_pil_driver = { 844 .probe = adsp_probe, 845 .remove = adsp_remove, 846 .driver = { 847 .name = "qcom_q6v5_adsp", 848 .of_match_table = adsp_of_match, 849 }, 850 }; 851 852 module_platform_driver(adsp_pil_driver); 853 MODULE_DESCRIPTION("QTI SDM845 ADSP Peripheral Image Loader"); 854 MODULE_LICENSE("GPL v2"); 855