tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'rproc-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux

Pull remoteproc updates from Bjorn Andersson:
"Make Qualcomm TrustZone Peripherial Authentication Service-remoteproc
identifier/name human friendly. Add audio DSP support for the Qualcomm
SAR2130P. Ensure IMEM access in the Qualcomm modem remoteproc driver
is performed prior to the firmware enabling the XPU and locking us
out.

Improve error handling, error logging, compile testing support, and a
few other stylistic things across a variety of the drivers"

* tag 'rproc-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux: (30 commits)
remoteproc: qcom: wcss: Remove double assignment in q6v5_wcss_probe()
remoteproc: qcom_q6v5_mss: Re-order writes to the IMEM region
remoteproc: qcom_wcnss_iris: Simplify with dev_err_probe()
remoteproc: qcom_q6v5_wcss: Simplify with dev_err_probe()
remoteproc: qcom_q6v5_pas: Simplify with dev_err_probe()
remoteproc: qcom_q6v5_mss: Drop redundant error printks in probe
remoteproc: qcom_q6v5_mss: Simplify with dev_err_probe()
remoteproc: qcom_q6v5_adsp: Simplify with dev_err_probe()
remoteproc: qcom_q6v5_pas: disable auto boot for wpss
remoteproc: qcom: pas: Make remoteproc name human friendly
remoteproc: qcom: pas: enable SAR2130P audio DSP support
remoteproc: qcom: pas: add minidump_id to SM8350 resources
dt-bindings: remoteproc: qcom,sm8350-pas: add SAR2130P aDSP compatible
dt-bindings: remoteproc: qcom,sm8550-pas: Add SM8750 ADSP
remoteproc: qcom: wcss: Remove subdevs on the error path of q6v5_wcss_probe()
remoteproc: qcom: adsp: Remove subdevs on the error path of adsp_probe()
remoteproc: qcom: pas: Remove subdevs on the error path of adsp_probe()
remoteproc: Switch back to struct platform_driver::remove()
remoteproc: k3-dsp: Force cast from iomem address space
remoteproc: k3-r5: Force cast from iomem address space
...

Linus Torvalds 08906abc 727968ff

+212 -261
+3
Documentation/devicetree/bindings/remoteproc/qcom,sm8350-pas.yaml
··· 16 16 properties: 17 17 compatible: 18 18 enum: 19 + - qcom,sar2130p-adsp-pas 19 20 - qcom,sm8350-adsp-pas 20 21 - qcom,sm8350-cdsp-pas 21 22 - qcom,sm8350-slpi-pas ··· 62 61 properties: 63 62 compatible: 64 63 enum: 64 + - qcom,sar2130p-adsp-pas 65 65 - qcom,sm8350-adsp-pas 66 66 - qcom,sm8350-cdsp-pas 67 67 - qcom,sm8350-slpi-pas ··· 103 101 properties: 104 102 compatible: 105 103 enum: 104 + - qcom,sar2130p-adsp-pas 106 105 - qcom,sm8350-adsp-pas 107 106 - qcom,sm8350-slpi-pas 108 107 - qcom,sm8450-adsp-pas
+34 -14
Documentation/devicetree/bindings/remoteproc/qcom,sm8550-pas.yaml
··· 15 15 16 16 properties: 17 17 compatible: 18 - enum: 19 - - qcom,sdx75-mpss-pas 20 - - qcom,sm8550-adsp-pas 21 - - qcom,sm8550-cdsp-pas 22 - - qcom,sm8550-mpss-pas 23 - - qcom,sm8650-adsp-pas 24 - - qcom,sm8650-cdsp-pas 25 - - qcom,sm8650-mpss-pas 26 - - qcom,x1e80100-adsp-pas 27 - - qcom,x1e80100-cdsp-pas 18 + oneOf: 19 + - enum: 20 + - qcom,sdx75-mpss-pas 21 + - qcom,sm8550-adsp-pas 22 + - qcom,sm8550-cdsp-pas 23 + - qcom,sm8550-mpss-pas 24 + - qcom,sm8650-adsp-pas 25 + - qcom,sm8650-cdsp-pas 26 + - qcom,sm8650-mpss-pas 27 + - qcom,x1e80100-adsp-pas 28 + - qcom,x1e80100-cdsp-pas 29 + - items: 30 + - const: qcom,sm8750-adsp-pas 31 + - const: qcom,sm8550-adsp-pas 28 32 29 33 reg: 30 34 maxItems: 1 ··· 89 85 - if: 90 86 properties: 91 87 compatible: 88 + contains: 89 + enum: 90 + - qcom,sm8750-adsp-pas 91 + then: 92 + properties: 93 + interrupts: 94 + maxItems: 6 95 + interrupt-names: 96 + maxItems: 6 97 + memory-region: 98 + maxItems: 2 99 + - if: 100 + properties: 101 + compatible: 92 102 enum: 93 103 - qcom,sm8650-cdsp-pas 94 104 then: ··· 147 129 - if: 148 130 properties: 149 131 compatible: 150 - enum: 151 - - qcom,sm8550-adsp-pas 152 - - qcom,sm8650-adsp-pas 153 - - qcom,x1e80100-adsp-pas 132 + contains: 133 + enum: 134 + - qcom,sm8550-adsp-pas 135 + - qcom,sm8650-adsp-pas 136 + - qcom,sm8750-adsp-pas 137 + - qcom,x1e80100-adsp-pas 154 138 then: 155 139 properties: 156 140 power-domains:
+7 -5
drivers/remoteproc/Kconfig
··· 329 329 330 330 config TI_K3_DSP_REMOTEPROC 331 331 tristate "TI K3 DSP remoteproc support" 332 - depends on ARCH_K3 332 + depends on ARCH_K3 || COMPILE_TEST 333 + depends on TI_SCI_PROTOCOL || (COMPILE_TEST && TI_SCI_PROTOCOL=n) 333 334 depends on OMAP2PLUS_MBOX 334 335 help 335 336 Say m here to support TI's C66x and C71x DSP remote processor ··· 342 341 343 342 config TI_K3_M4_REMOTEPROC 344 343 tristate "TI K3 M4 remoteproc support" 345 - depends on ARCH_OMAP2PLUS || ARCH_K3 346 - select MAILBOX 347 - select OMAP2PLUS_MBOX 344 + depends on ARCH_K3 || COMPILE_TEST 345 + depends on TI_SCI_PROTOCOL || (COMPILE_TEST && TI_SCI_PROTOCOL=n) 346 + depends on OMAP2PLUS_MBOX 348 347 help 349 348 Say m here to support TI's M4 remote processor subsystems 350 349 on various TI K3 family of SoCs through the remote processor ··· 355 354 356 355 config TI_K3_R5_REMOTEPROC 357 356 tristate "TI K3 R5 remoteproc support" 358 - depends on ARCH_K3 357 + depends on ARCH_K3 || COMPILE_TEST 358 + depends on TI_SCI_PROTOCOL || (COMPILE_TEST && TI_SCI_PROTOCOL=n) 359 359 depends on OMAP2PLUS_MBOX 360 360 help 361 361 Say m here to support TI's R5F remote processor subsystems
+9 -22
drivers/remoteproc/da8xx_remoteproc.c
··· 251 251 return irq; 252 252 253 253 irq_data = irq_get_irq_data(irq); 254 - if (!irq_data) { 255 - dev_err(dev, "irq_get_irq_data(%d): NULL\n", irq); 256 - return -EINVAL; 257 - } 254 + if (!irq_data) 255 + return dev_err_probe(dev, -EINVAL, "irq_get_irq_data(%d): NULL\n", irq); 258 256 259 257 bootreg = devm_platform_ioremap_resource_byname(pdev, "host1cfg"); 260 258 if (IS_ERR(bootreg)) ··· 263 265 return PTR_ERR(chipsig); 264 266 265 267 dsp_clk = devm_clk_get(dev, NULL); 266 - if (IS_ERR(dsp_clk)) { 267 - dev_err(dev, "clk_get error: %ld\n", PTR_ERR(dsp_clk)); 268 - 269 - return PTR_ERR(dsp_clk); 270 - } 268 + if (IS_ERR(dsp_clk)) 269 + return dev_err_probe(dev, PTR_ERR(dsp_clk), "clk_get error\n"); 271 270 272 271 dsp_reset = devm_reset_control_get_exclusive(dev, NULL); 273 - if (IS_ERR(dsp_reset)) { 274 - if (PTR_ERR(dsp_reset) != -EPROBE_DEFER) 275 - dev_err(dev, "unable to get reset control: %ld\n", 276 - PTR_ERR(dsp_reset)); 277 - 278 - return PTR_ERR(dsp_reset); 279 - } 272 + if (IS_ERR(dsp_reset)) 273 + return dev_err_probe(dev, PTR_ERR(dsp_reset), "unable to get reset control\n"); 280 274 281 275 if (dev->of_node) { 282 276 ret = of_reserved_mem_device_init(dev); 283 - if (ret) { 284 - dev_err(dev, "device does not have specific CMA pool: %d\n", 285 - ret); 286 - return ret; 287 - } 277 + if (ret) 278 + return dev_err_probe(dev, ret, "device does not have specific CMA pool\n"); 288 279 } 289 280 290 281 rproc = rproc_alloc(dev, "dsp", &da8xx_rproc_ops, da8xx_fw_name, ··· 365 378 366 379 static struct platform_driver da8xx_rproc_driver = { 367 380 .probe = da8xx_rproc_probe, 368 - .remove_new = da8xx_rproc_remove, 381 + .remove = da8xx_rproc_remove, 369 382 .driver = { 370 383 .name = "davinci-rproc", 371 384 .of_match_table = of_match_ptr(davinci_rproc_of_match),
+1 -1
drivers/remoteproc/imx_dsp_rproc.c
··· 1258 1258 1259 1259 static struct platform_driver imx_dsp_rproc_driver = { 1260 1260 .probe = imx_dsp_rproc_probe, 1261 - .remove_new = imx_dsp_rproc_remove, 1261 + .remove = imx_dsp_rproc_remove, 1262 1262 .driver = { 1263 1263 .name = "imx-dsp-rproc", 1264 1264 .of_match_table = imx_dsp_rproc_of_match,
+1 -1
drivers/remoteproc/imx_rproc.c
··· 1198 1198 1199 1199 static struct platform_driver imx_rproc_driver = { 1200 1200 .probe = imx_rproc_probe, 1201 - .remove_new = imx_rproc_remove, 1201 + .remove = imx_rproc_remove, 1202 1202 .driver = { 1203 1203 .name = "imx-rproc", 1204 1204 .of_match_table = imx_rproc_of_match,
+1 -1
drivers/remoteproc/keystone_remoteproc.c
··· 490 490 491 491 static struct platform_driver keystone_rproc_driver = { 492 492 .probe = keystone_rproc_probe, 493 - .remove_new = keystone_rproc_remove, 493 + .remove = keystone_rproc_remove, 494 494 .driver = { 495 495 .name = "keystone-rproc", 496 496 .of_match_table = keystone_rproc_of_match,
+1 -1
drivers/remoteproc/meson_mx_ao_arc.c
··· 246 246 247 247 static struct platform_driver meson_mx_ao_arc_rproc_driver = { 248 248 .probe = meson_mx_ao_arc_rproc_probe, 249 - .remove_new = meson_mx_ao_arc_rproc_remove, 249 + .remove = meson_mx_ao_arc_rproc_remove, 250 250 .driver = { 251 251 .name = "meson-mx-ao-arc-rproc", 252 252 .of_match_table = meson_mx_ao_arc_rproc_match,
+1 -1
drivers/remoteproc/mtk_scp.c
··· 1521 1521 1522 1522 static struct platform_driver mtk_scp_driver = { 1523 1523 .probe = scp_probe, 1524 - .remove_new = scp_remove, 1524 + .remove = scp_remove, 1525 1525 .driver = { 1526 1526 .name = "mtk-scp", 1527 1527 .of_match_table = mtk_scp_of_match,
+1 -1
drivers/remoteproc/pru_rproc.c
··· 1132 1132 .suppress_bind_attrs = true, 1133 1133 }, 1134 1134 .probe = pru_rproc_probe, 1135 - .remove_new = pru_rproc_remove, 1135 + .remove = pru_rproc_remove, 1136 1136 }; 1137 1137 module_platform_driver(pru_rproc_driver); 1138 1138
+16 -14
drivers/remoteproc/qcom_q6v5_adsp.c
··· 534 534 static int adsp_init_clock(struct qcom_adsp *adsp, const char **clk_ids) 535 535 { 536 536 int num_clks = 0; 537 - int i, ret; 537 + int i; 538 538 539 539 adsp->xo = devm_clk_get(adsp->dev, "xo"); 540 - if (IS_ERR(adsp->xo)) { 541 - ret = PTR_ERR(adsp->xo); 542 - if (ret != -EPROBE_DEFER) 543 - dev_err(adsp->dev, "failed to get xo clock"); 544 - return ret; 545 - } 540 + if (IS_ERR(adsp->xo)) 541 + return dev_err_probe(adsp->dev, PTR_ERR(adsp->xo), "failed to get xo clock"); 546 542 547 543 for (i = 0; clk_ids[i]; i++) 548 544 num_clks++; ··· 704 708 return ret; 705 709 706 710 ret = qcom_rproc_pds_attach(adsp, desc->pd_names, desc->num_pds); 707 - if (ret < 0) { 708 - dev_err(&pdev->dev, "Failed to attach proxy power domains\n"); 709 - return ret; 710 - } 711 + if (ret < 0) 712 + return dev_err_probe(&pdev->dev, ret, 713 + "Failed to attach proxy power domains\n"); 711 714 712 715 ret = adsp_init_reset(adsp); 713 716 if (ret) ··· 729 734 desc->ssctl_id); 730 735 if (IS_ERR(adsp->sysmon)) { 731 736 ret = PTR_ERR(adsp->sysmon); 732 - goto disable_pm; 737 + goto deinit_remove_glink_pdm_ssr; 733 738 } 734 739 735 740 ret = rproc_add(rproc); 736 741 if (ret) 737 - goto disable_pm; 742 + goto remove_sysmon; 738 743 739 744 return 0; 740 745 746 + remove_sysmon: 747 + qcom_remove_sysmon_subdev(adsp->sysmon); 748 + deinit_remove_glink_pdm_ssr: 749 + qcom_q6v5_deinit(&adsp->q6v5); 750 + qcom_remove_glink_subdev(rproc, &adsp->glink_subdev); 751 + qcom_remove_pdm_subdev(rproc, &adsp->pdm_subdev); 752 + qcom_remove_ssr_subdev(rproc, &adsp->ssr_subdev); 741 753 disable_pm: 742 754 qcom_rproc_pds_detach(adsp); 743 755 ··· 842 840 843 841 static struct platform_driver adsp_pil_driver = { 844 842 .probe = adsp_probe, 845 - .remove_new = adsp_remove, 843 + .remove = adsp_remove, 846 844 .driver = { 847 845 .name = "qcom_q6v5_adsp", 848 846 .of_match_table = adsp_of_match,
+18 -38
drivers/remoteproc/qcom_q6v5_mss.c
··· 261 261 static int q6v5_regulator_init(struct device *dev, struct reg_info *regs, 262 262 const struct qcom_mss_reg_res *reg_res) 263 263 { 264 - int rc; 265 264 int i; 266 265 267 266 if (!reg_res) ··· 268 269 269 270 for (i = 0; reg_res[i].supply; i++) { 270 271 regs[i].reg = devm_regulator_get(dev, reg_res[i].supply); 271 - if (IS_ERR(regs[i].reg)) { 272 - rc = PTR_ERR(regs[i].reg); 273 - if (rc != -EPROBE_DEFER) 274 - dev_err(dev, "Failed to get %s\n regulator", 275 - reg_res[i].supply); 276 - return rc; 277 - } 272 + if (IS_ERR(regs[i].reg)) 273 + return dev_err_probe(dev, PTR_ERR(regs[i].reg), 274 + "Failed to get %s\n regulator", 275 + reg_res[i].supply); 278 276 279 277 regs[i].uV = reg_res[i].uV; 280 278 regs[i].uA = reg_res[i].uA; ··· 1158 1162 goto disable_active_clks; 1159 1163 } 1160 1164 1165 + if (qproc->has_mba_logs) 1166 + qcom_pil_info_store("mba", qproc->mba_phys, MBA_LOG_SIZE); 1167 + 1161 1168 writel(qproc->mba_phys, qproc->rmb_base + RMB_MBA_IMAGE_REG); 1162 1169 if (qproc->dp_size) { 1163 1170 writel(qproc->mba_phys + SZ_1M, qproc->rmb_base + RMB_PMI_CODE_START_REG); ··· 1170 1171 ret = q6v5proc_reset(qproc); 1171 1172 if (ret) 1172 1173 goto reclaim_mba; 1173 - 1174 - if (qproc->has_mba_logs) 1175 - qcom_pil_info_store("mba", qproc->mba_phys, MBA_LOG_SIZE); 1176 1174 1177 1175 ret = q6v5_rmb_mba_wait(qproc, 0, 5000); 1178 1176 if (ret == -ETIMEDOUT) { ··· 1809 1813 1810 1814 for (i = 0; clk_names[i]; i++) { 1811 1815 clks[i] = devm_clk_get(dev, clk_names[i]); 1812 - if (IS_ERR(clks[i])) { 1813 - int rc = PTR_ERR(clks[i]); 1814 - 1815 - if (rc != -EPROBE_DEFER) 1816 - dev_err(dev, "Failed to get %s clock\n", 1817 - clk_names[i]); 1818 - return rc; 1819 - } 1816 + if (IS_ERR(clks[i])) 1817 + return dev_err_probe(dev, PTR_ERR(clks[i]), 1818 + "Failed to get %s clock\n", 1819 + clk_names[i]); 1820 1820 } 1821 1821 1822 1822 return i; ··· 2020 2028 2021 2029 ret = q6v5_init_clocks(&pdev->dev, qproc->proxy_clks, 2022 2030 desc->proxy_clk_names); 2023 - if (ret < 0) { 2024 - dev_err(&pdev->dev, "Failed to get proxy clocks.\n"); 2031 + if (ret < 0) 2025 2032 return ret; 2026 - } 2027 2033 qproc->proxy_clk_count = ret; 2028 2034 2029 2035 ret = q6v5_init_clocks(&pdev->dev, qproc->reset_clks, 2030 2036 desc->reset_clk_names); 2031 - if (ret < 0) { 2032 - dev_err(&pdev->dev, "Failed to get reset clocks.\n"); 2037 + if (ret < 0) 2033 2038 return ret; 2034 - } 2035 2039 qproc->reset_clk_count = ret; 2036 2040 2037 2041 ret = q6v5_init_clocks(&pdev->dev, qproc->active_clks, 2038 2042 desc->active_clk_names); 2039 - if (ret < 0) { 2040 - dev_err(&pdev->dev, "Failed to get active clocks.\n"); 2043 + if (ret < 0) 2041 2044 return ret; 2042 - } 2043 2045 qproc->active_clk_count = ret; 2044 2046 2045 2047 ret = q6v5_regulator_init(&pdev->dev, qproc->proxy_regs, 2046 2048 desc->proxy_supply); 2047 - if (ret < 0) { 2048 - dev_err(&pdev->dev, "Failed to get proxy regulators.\n"); 2049 + if (ret < 0) 2049 2050 return ret; 2050 - } 2051 2051 qproc->proxy_reg_count = ret; 2052 2052 2053 2053 ret = q6v5_regulator_init(&pdev->dev, qproc->active_regs, 2054 2054 desc->active_supply); 2055 - if (ret < 0) { 2056 - dev_err(&pdev->dev, "Failed to get active regulators.\n"); 2055 + if (ret < 0) 2057 2056 return ret; 2058 - } 2059 2057 qproc->active_reg_count = ret; 2060 2058 2061 2059 ret = q6v5_pds_attach(&pdev->dev, qproc->proxy_pds, ··· 2055 2073 ret = q6v5_regulator_init(&pdev->dev, 2056 2074 qproc->fallback_proxy_regs, 2057 2075 desc->fallback_proxy_supply); 2058 - if (ret < 0) { 2059 - dev_err(&pdev->dev, "Failed to get fallback proxy regulators.\n"); 2076 + if (ret < 0) 2060 2077 return ret; 2061 - } 2062 2078 qproc->fallback_proxy_reg_count = ret; 2063 2079 } else if (ret < 0) { 2064 2080 dev_err(&pdev->dev, "Failed to init power domains\n"); ··· 2513 2533 2514 2534 static struct platform_driver q6v5_driver = { 2515 2535 .probe = q6v5_probe, 2516 - .remove_new = q6v5_remove, 2536 + .remove = q6v5_remove, 2517 2537 .driver = { 2518 2538 .name = "qcom-q6v5-mss", 2519 2539 .of_match_table = q6v5_of_match,
+28 -23
drivers/remoteproc/qcom_q6v5_pas.c
··· 453 453 454 454 static int adsp_init_clock(struct qcom_adsp *adsp) 455 455 { 456 - int ret; 457 - 458 456 adsp->xo = devm_clk_get(adsp->dev, "xo"); 459 - if (IS_ERR(adsp->xo)) { 460 - ret = PTR_ERR(adsp->xo); 461 - if (ret != -EPROBE_DEFER) 462 - dev_err(adsp->dev, "failed to get xo clock"); 463 - return ret; 464 - } 457 + if (IS_ERR(adsp->xo)) 458 + return dev_err_probe(adsp->dev, PTR_ERR(adsp->xo), 459 + "failed to get xo clock"); 460 + 465 461 466 462 adsp->aggre2_clk = devm_clk_get_optional(adsp->dev, "aggre2"); 467 - if (IS_ERR(adsp->aggre2_clk)) { 468 - ret = PTR_ERR(adsp->aggre2_clk); 469 - if (ret != -EPROBE_DEFER) 470 - dev_err(adsp->dev, 471 - "failed to get aggre2 clock"); 472 - return ret; 473 - } 463 + if (IS_ERR(adsp->aggre2_clk)) 464 + return dev_err_probe(adsp->dev, PTR_ERR(adsp->aggre2_clk), 465 + "failed to get aggre2 clock"); 474 466 475 467 return 0; 476 468 } ··· 708 716 if (desc->minidump_id) 709 717 ops = &adsp_minidump_ops; 710 718 711 - rproc = devm_rproc_alloc(&pdev->dev, pdev->name, ops, fw_name, sizeof(*adsp)); 719 + rproc = devm_rproc_alloc(&pdev->dev, desc->sysmon_name, ops, fw_name, sizeof(*adsp)); 712 720 713 721 if (!rproc) { 714 722 dev_err(&pdev->dev, "unable to allocate remoteproc\n"); ··· 751 759 752 760 ret = adsp_init_clock(adsp); 753 761 if (ret) 754 - goto free_rproc; 762 + goto unassign_mem; 755 763 756 764 ret = adsp_init_regulator(adsp); 757 765 if (ret) 758 - goto free_rproc; 766 + goto unassign_mem; 759 767 760 768 ret = adsp_pds_attach(&pdev->dev, adsp->proxy_pds, 761 769 desc->proxy_pd_names); 762 770 if (ret < 0) 763 - goto free_rproc; 771 + goto unassign_mem; 764 772 adsp->proxy_pd_count = ret; 765 773 766 774 ret = qcom_q6v5_init(&adsp->q6v5, pdev, rproc, desc->crash_reason_smem, desc->load_state, ··· 776 784 desc->ssctl_id); 777 785 if (IS_ERR(adsp->sysmon)) { 778 786 ret = PTR_ERR(adsp->sysmon); 779 - goto detach_proxy_pds; 787 + goto deinit_remove_pdm_smd_glink; 780 788 } 781 789 782 790 qcom_add_ssr_subdev(rproc, &adsp->ssr_subdev, desc->ssr_name); 783 791 ret = rproc_add(rproc); 784 792 if (ret) 785 - goto detach_proxy_pds; 793 + goto remove_ssr_sysmon; 786 794 787 795 return 0; 788 796 797 + remove_ssr_sysmon: 798 + qcom_remove_ssr_subdev(rproc, &adsp->ssr_subdev); 799 + qcom_remove_sysmon_subdev(adsp->sysmon); 800 + deinit_remove_pdm_smd_glink: 801 + qcom_remove_pdm_subdev(rproc, &adsp->pdm_subdev); 802 + qcom_remove_smd_subdev(rproc, &adsp->smd_subdev); 803 + qcom_remove_glink_subdev(rproc, &adsp->glink_subdev); 804 + qcom_q6v5_deinit(&adsp->q6v5); 789 805 detach_proxy_pds: 790 806 adsp_pds_detach(adsp, adsp->proxy_pds, adsp->proxy_pd_count); 807 + unassign_mem: 808 + adsp_unassign_memory_region(adsp); 791 809 free_rproc: 792 810 device_init_wakeup(adsp->dev, false); 793 811 ··· 909 907 .crash_reason_smem = 423, 910 908 .firmware_name = "adsp.mdt", 911 909 .pas_id = 1, 910 + .minidump_id = 5, 912 911 .auto_boot = true, 913 912 .proxy_pd_names = (char*[]){ 914 913 "lcx", ··· 1127 1124 .crash_reason_smem = 601, 1128 1125 .firmware_name = "cdsp.mdt", 1129 1126 .pas_id = 18, 1127 + .minidump_id = 7, 1130 1128 .auto_boot = true, 1131 1129 .proxy_pd_names = (char*[]){ 1132 1130 "cx", ··· 1348 1344 .crash_reason_smem = 626, 1349 1345 .firmware_name = "wpss.mdt", 1350 1346 .pas_id = 6, 1351 - .auto_boot = true, 1347 + .auto_boot = false, 1352 1348 .proxy_pd_names = (char*[]){ 1353 1349 "cx", 1354 1350 "mx", ··· 1425 1421 { .compatible = "qcom,sa8775p-cdsp1-pas", .data = &sa8775p_cdsp1_resource}, 1426 1422 { .compatible = "qcom,sa8775p-gpdsp0-pas", .data = &sa8775p_gpdsp0_resource}, 1427 1423 { .compatible = "qcom,sa8775p-gpdsp1-pas", .data = &sa8775p_gpdsp1_resource}, 1424 + { .compatible = "qcom,sar2130p-adsp-pas", .data = &sm8350_adsp_resource}, 1428 1425 { .compatible = "qcom,sc7180-adsp-pas", .data = &sm8250_adsp_resource}, 1429 1426 { .compatible = "qcom,sc7180-mpss-pas", .data = &mpss_resource_init}, 1430 1427 { .compatible = "qcom,sc7280-adsp-pas", .data = &sm8350_adsp_resource}, ··· 1482 1477 1483 1478 static struct platform_driver adsp_driver = { 1484 1479 .probe = adsp_probe, 1485 - .remove_new = adsp_remove, 1480 + .remove = adsp_remove, 1486 1481 .driver = { 1487 1482 .name = "qcom_q6v5_pas", 1488 1483 .of_match_table = adsp_of_match,
+48 -66
drivers/remoteproc/qcom_q6v5_wcss.c
··· 902 902 903 903 static int q6v5_wcss_init_clock(struct q6v5_wcss *wcss) 904 904 { 905 - int ret; 906 - 907 905 wcss->xo = devm_clk_get(wcss->dev, "xo"); 908 - if (IS_ERR(wcss->xo)) { 909 - ret = PTR_ERR(wcss->xo); 910 - if (ret != -EPROBE_DEFER) 911 - dev_err(wcss->dev, "failed to get xo clock"); 912 - return ret; 913 - } 906 + if (IS_ERR(wcss->xo)) 907 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->xo), 908 + "failed to get xo clock"); 914 909 915 910 wcss->gcc_abhs_cbcr = devm_clk_get(wcss->dev, "gcc_abhs_cbcr"); 916 - if (IS_ERR(wcss->gcc_abhs_cbcr)) { 917 - ret = PTR_ERR(wcss->gcc_abhs_cbcr); 918 - if (ret != -EPROBE_DEFER) 919 - dev_err(wcss->dev, "failed to get gcc abhs clock"); 920 - return ret; 921 - } 911 + if (IS_ERR(wcss->gcc_abhs_cbcr)) 912 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->gcc_abhs_cbcr), 913 + "failed to get gcc abhs clock"); 922 914 923 915 wcss->gcc_axim_cbcr = devm_clk_get(wcss->dev, "gcc_axim_cbcr"); 924 - if (IS_ERR(wcss->gcc_axim_cbcr)) { 925 - ret = PTR_ERR(wcss->gcc_axim_cbcr); 926 - if (ret != -EPROBE_DEFER) 927 - dev_err(wcss->dev, "failed to get gcc axim clock\n"); 928 - return ret; 929 - } 916 + if (IS_ERR(wcss->gcc_axim_cbcr)) 917 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->gcc_axim_cbcr), 918 + "failed to get gcc axim clock\n"); 930 919 931 920 wcss->ahbfabric_cbcr_clk = devm_clk_get(wcss->dev, 932 921 "lcc_ahbfabric_cbc"); 933 - if (IS_ERR(wcss->ahbfabric_cbcr_clk)) { 934 - ret = PTR_ERR(wcss->ahbfabric_cbcr_clk); 935 - if (ret != -EPROBE_DEFER) 936 - dev_err(wcss->dev, "failed to get ahbfabric clock\n"); 937 - return ret; 938 - } 922 + if (IS_ERR(wcss->ahbfabric_cbcr_clk)) 923 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->ahbfabric_cbcr_clk), 924 + "failed to get ahbfabric clock\n"); 939 925 940 926 wcss->lcc_csr_cbcr = devm_clk_get(wcss->dev, "tcsr_lcc_cbc"); 941 - if (IS_ERR(wcss->lcc_csr_cbcr)) { 942 - ret = PTR_ERR(wcss->lcc_csr_cbcr); 943 - if (ret != -EPROBE_DEFER) 944 - dev_err(wcss->dev, "failed to get csr cbcr clk\n"); 945 - return ret; 946 - } 927 + if (IS_ERR(wcss->lcc_csr_cbcr)) 928 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->lcc_csr_cbcr), 929 + "failed to get csr cbcr clk\n"); 947 930 948 931 wcss->ahbs_cbcr = devm_clk_get(wcss->dev, 949 932 "lcc_abhs_cbc"); 950 - if (IS_ERR(wcss->ahbs_cbcr)) { 951 - ret = PTR_ERR(wcss->ahbs_cbcr); 952 - if (ret != -EPROBE_DEFER) 953 - dev_err(wcss->dev, "failed to get ahbs_cbcr clk\n"); 954 - return ret; 955 - } 933 + if (IS_ERR(wcss->ahbs_cbcr)) 934 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->ahbs_cbcr), 935 + "failed to get ahbs_cbcr clk\n"); 956 936 957 937 wcss->tcm_slave_cbcr = devm_clk_get(wcss->dev, 958 938 "lcc_tcm_slave_cbc"); 959 - if (IS_ERR(wcss->tcm_slave_cbcr)) { 960 - ret = PTR_ERR(wcss->tcm_slave_cbcr); 961 - if (ret != -EPROBE_DEFER) 962 - dev_err(wcss->dev, "failed to get tcm cbcr clk\n"); 963 - return ret; 964 - } 939 + if (IS_ERR(wcss->tcm_slave_cbcr)) 940 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->tcm_slave_cbcr), 941 + "failed to get tcm cbcr clk\n"); 965 942 966 943 wcss->qdsp6ss_abhm_cbcr = devm_clk_get(wcss->dev, "lcc_abhm_cbc"); 967 - if (IS_ERR(wcss->qdsp6ss_abhm_cbcr)) { 968 - ret = PTR_ERR(wcss->qdsp6ss_abhm_cbcr); 969 - if (ret != -EPROBE_DEFER) 970 - dev_err(wcss->dev, "failed to get abhm cbcr clk\n"); 971 - return ret; 972 - } 944 + if (IS_ERR(wcss->qdsp6ss_abhm_cbcr)) 945 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->qdsp6ss_abhm_cbcr), 946 + "failed to get abhm cbcr clk\n"); 973 947 974 948 wcss->qdsp6ss_axim_cbcr = devm_clk_get(wcss->dev, "lcc_axim_cbc"); 975 - if (IS_ERR(wcss->qdsp6ss_axim_cbcr)) { 976 - ret = PTR_ERR(wcss->qdsp6ss_axim_cbcr); 977 - if (ret != -EPROBE_DEFER) 978 - dev_err(wcss->dev, "failed to get axim cbcr clk\n"); 979 - return ret; 980 - } 949 + if (IS_ERR(wcss->qdsp6ss_axim_cbcr)) 950 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->qdsp6ss_axim_cbcr), 951 + "failed to get axim cbcr clk\n"); 981 952 982 953 wcss->lcc_bcr_sleep = devm_clk_get(wcss->dev, "lcc_bcr_sleep"); 983 - if (IS_ERR(wcss->lcc_bcr_sleep)) { 984 - ret = PTR_ERR(wcss->lcc_bcr_sleep); 985 - if (ret != -EPROBE_DEFER) 986 - dev_err(wcss->dev, "failed to get bcr cbcr clk\n"); 987 - return ret; 988 - } 954 + if (IS_ERR(wcss->lcc_bcr_sleep)) 955 + return dev_err_probe(wcss->dev, PTR_ERR(wcss->lcc_bcr_sleep), 956 + "failed to get bcr cbcr clk\n"); 989 957 990 958 return 0; 991 959 } ··· 989 1021 990 1022 wcss = rproc->priv; 991 1023 wcss->dev = &pdev->dev; 992 - wcss->version = desc->version; 993 1024 994 1025 wcss->version = desc->version; 995 1026 wcss->requires_force_stop = desc->requires_force_stop; ··· 1023 1056 qcom_add_pdm_subdev(rproc, &wcss->pdm_subdev); 1024 1057 qcom_add_ssr_subdev(rproc, &wcss->ssr_subdev, "q6wcss"); 1025 1058 1026 - if (desc->ssctl_id) 1059 + if (desc->ssctl_id) { 1027 1060 wcss->sysmon = qcom_add_sysmon_subdev(rproc, 1028 1061 desc->sysmon_name, 1029 1062 desc->ssctl_id); 1063 + if (IS_ERR(wcss->sysmon)) { 1064 + ret = PTR_ERR(wcss->sysmon); 1065 + goto deinit_remove_subdevs; 1066 + } 1067 + } 1030 1068 1031 1069 ret = rproc_add(rproc); 1032 1070 if (ret) 1033 - return ret; 1071 + goto remove_sysmon_subdev; 1034 1072 1035 1073 platform_set_drvdata(pdev, rproc); 1036 1074 1037 1075 return 0; 1076 + 1077 + remove_sysmon_subdev: 1078 + if (desc->ssctl_id) 1079 + qcom_remove_sysmon_subdev(wcss->sysmon); 1080 + deinit_remove_subdevs: 1081 + qcom_q6v5_deinit(&wcss->q6v5); 1082 + qcom_remove_glink_subdev(rproc, &wcss->glink_subdev); 1083 + qcom_remove_pdm_subdev(rproc, &wcss->pdm_subdev); 1084 + qcom_remove_ssr_subdev(rproc, &wcss->ssr_subdev); 1085 + return ret; 1038 1086 } 1039 1087 1040 1088 static void q6v5_wcss_remove(struct platform_device *pdev) ··· 1093 1111 1094 1112 static struct platform_driver q6v5_wcss_driver = { 1095 1113 .probe = q6v5_wcss_probe, 1096 - .remove_new = q6v5_wcss_remove, 1114 + .remove = q6v5_wcss_remove, 1097 1115 .driver = { 1098 1116 .name = "qcom-q6v5-wcss-pil", 1099 1117 .of_match_table = q6v5_wcss_of_match,
+1 -1
drivers/remoteproc/qcom_wcnss.c
··· 682 682 683 683 static struct platform_driver wcnss_driver = { 684 684 .probe = wcnss_probe, 685 - .remove_new = wcnss_remove, 685 + .remove = wcnss_remove, 686 686 .driver = { 687 687 .name = "qcom-wcnss-pil", 688 688 .of_match_table = wcnss_of_match,
+2 -3
drivers/remoteproc/qcom_wcnss_iris.c
··· 155 155 156 156 iris->xo_clk = devm_clk_get(&iris->dev, "xo"); 157 157 if (IS_ERR(iris->xo_clk)) { 158 - ret = PTR_ERR(iris->xo_clk); 159 - if (ret != -EPROBE_DEFER) 160 - dev_err(&iris->dev, "failed to acquire xo clk\n"); 158 + ret = dev_err_probe(&iris->dev, PTR_ERR(iris->xo_clk), 159 + "failed to acquire xo clk\n"); 161 160 goto err_device_del; 162 161 } 163 162
+1 -1
drivers/remoteproc/rcar_rproc.c
··· 214 214 215 215 static struct platform_driver rcar_rproc_driver = { 216 216 .probe = rcar_rproc_probe, 217 - .remove_new = rcar_rproc_remove, 217 + .remove = rcar_rproc_remove, 218 218 .driver = { 219 219 .name = "rcar-rproc", 220 220 .of_match_table = rcar_rproc_of_match,
+1 -1
drivers/remoteproc/remoteproc_virtio.c
··· 593 593 /* Platform driver */ 594 594 static struct platform_driver rproc_virtio_driver = { 595 595 .probe = rproc_virtio_probe, 596 - .remove_new = rproc_virtio_remove, 596 + .remove = rproc_virtio_remove, 597 597 .driver = { 598 598 .name = "rproc-virtio", 599 599 },
+1 -1
drivers/remoteproc/st_remoteproc.c
··· 457 457 458 458 static struct platform_driver st_rproc_driver = { 459 459 .probe = st_rproc_probe, 460 - .remove_new = st_rproc_remove, 460 + .remove = st_rproc_remove, 461 461 .driver = { 462 462 .name = "st-rproc", 463 463 .of_match_table = of_match_ptr(st_rproc_match),
+1 -1
drivers/remoteproc/stm32_rproc.c
··· 946 946 947 947 static struct platform_driver stm32_rproc_driver = { 948 948 .probe = stm32_rproc_probe, 949 - .remove_new = stm32_rproc_remove, 949 + .remove = stm32_rproc_remove, 950 950 .driver = { 951 951 .name = "stm32-rproc", 952 952 .pm = pm_ptr(&stm32_rproc_pm_ops),
+4 -6
drivers/remoteproc/ti_k3_dsp_remoteproc.c
··· 403 403 * the hard-coded value suffices to support the IPC-only mode. 404 404 */ 405 405 *rsc_table_sz = 256; 406 - return (struct resource_table *)kproc->rmem[0].cpu_addr; 406 + return (__force struct resource_table *)kproc->rmem[0].cpu_addr; 407 407 } 408 408 409 409 /* ··· 576 576 return -EINVAL; 577 577 578 578 rmem = of_reserved_mem_lookup(rmem_np); 579 - if (!rmem) { 580 - of_node_put(rmem_np); 581 - return -EINVAL; 582 - } 583 579 of_node_put(rmem_np); 580 + if (!rmem) 581 + return -EINVAL; 584 582 585 583 kproc->rmem[i].bus_addr = rmem->base; 586 584 /* 64-bit address regions currently not supported */ ··· 791 793 792 794 static struct platform_driver k3_dsp_rproc_driver = { 793 795 .probe = k3_dsp_rproc_probe, 794 - .remove_new = k3_dsp_rproc_remove, 796 + .remove = k3_dsp_rproc_remove, 795 797 .driver = { 796 798 .name = "k3-dsp-rproc", 797 799 .of_match_table = k3_dsp_of_match,
+2 -4
drivers/remoteproc/ti_k3_m4_remoteproc.c
··· 433 433 return -EINVAL; 434 434 435 435 rmem = of_reserved_mem_lookup(rmem_np); 436 - if (!rmem) { 437 - of_node_put(rmem_np); 438 - return -EINVAL; 439 - } 440 436 of_node_put(rmem_np); 437 + if (!rmem) 438 + return -EINVAL; 441 439 442 440 kproc->rmem[i].bus_addr = rmem->base; 443 441 /* 64-bit address regions currently not supported */
+29 -54
drivers/remoteproc/ti_k3_r5_remoteproc.c
··· 487 487 * can be effective on all TCM addresses. 488 488 */ 489 489 dev_dbg(dev, "zeroing out ATCM memory\n"); 490 - memset(core->mem[0].cpu_addr, 0x00, core->mem[0].size); 490 + memset_io(core->mem[0].cpu_addr, 0x00, core->mem[0].size); 491 491 492 492 dev_dbg(dev, "zeroing out BTCM memory\n"); 493 - memset(core->mem[1].cpu_addr, 0x00, core->mem[1].size); 493 + memset_io(core->mem[1].cpu_addr, 0x00, core->mem[1].size); 494 494 495 495 return 0; 496 496 } ··· 717 717 * the hard-coded value suffices to support the IPC-only mode. 718 718 */ 719 719 *rsc_table_sz = 256; 720 - return (struct resource_table *)kproc->rmem[0].cpu_addr; 720 + return (__force struct resource_table *)kproc->rmem[0].cpu_addr; 721 721 } 722 722 723 723 /* ··· 1001 1001 } 1002 1002 1003 1003 rmem = of_reserved_mem_lookup(rmem_np); 1004 + of_node_put(rmem_np); 1004 1005 if (!rmem) { 1005 - of_node_put(rmem_np); 1006 1006 ret = -EINVAL; 1007 1007 goto unmap_rmem; 1008 1008 } 1009 - of_node_put(rmem_np); 1010 1009 1011 1010 kproc->rmem[i].bus_addr = rmem->base; 1012 1011 /* ··· 1557 1558 1558 1559 core->ti_sci = devm_ti_sci_get_by_phandle(dev, "ti,sci"); 1559 1560 if (IS_ERR(core->ti_sci)) { 1560 - ret = PTR_ERR(core->ti_sci); 1561 - if (ret != -EPROBE_DEFER) { 1562 - dev_err(dev, "failed to get ti-sci handle, ret = %d\n", 1563 - ret); 1564 - } 1561 + ret = dev_err_probe(dev, PTR_ERR(core->ti_sci), "failed to get ti-sci handle\n"); 1565 1562 core->ti_sci = NULL; 1566 1563 goto err; 1567 1564 } ··· 1573 1578 ret = PTR_ERR_OR_ZERO(core->reset); 1574 1579 if (!ret) 1575 1580 ret = -ENODEV; 1576 - if (ret != -EPROBE_DEFER) { 1577 - dev_err(dev, "failed to get reset handle, ret = %d\n", 1578 - ret); 1579 - } 1581 + dev_err_probe(dev, ret, "failed to get reset handle\n"); 1580 1582 goto err; 1581 1583 } 1582 1584 1583 1585 core->tsp = ti_sci_proc_of_get_tsp(dev, core->ti_sci); 1584 1586 if (IS_ERR(core->tsp)) { 1585 - ret = PTR_ERR(core->tsp); 1586 - dev_err(dev, "failed to construct ti-sci proc control, ret = %d\n", 1587 - ret); 1587 + ret = dev_err_probe(dev, PTR_ERR(core->tsp), 1588 + "failed to construct ti-sci proc control\n"); 1588 1589 goto err; 1589 1590 } 1590 1591 ··· 1650 1659 struct device *dev = &pdev->dev; 1651 1660 struct device_node *np = dev_of_node(dev); 1652 1661 struct platform_device *cpdev; 1653 - struct device_node *child; 1654 1662 struct k3_r5_core *core; 1655 1663 int ret; 1656 1664 1657 - for_each_available_child_of_node(np, child) { 1665 + for_each_available_child_of_node_scoped(np, child) { 1658 1666 cpdev = of_find_device_by_node(child); 1659 1667 if (!cpdev) { 1660 1668 ret = -ENODEV; 1661 1669 dev_err(dev, "could not get R5 core platform device\n"); 1662 - of_node_put(child); 1663 1670 goto fail; 1664 1671 } 1665 1672 ··· 1666 1677 dev_err(dev, "k3_r5_core_of_init failed, ret = %d\n", 1667 1678 ret); 1668 1679 put_device(&cpdev->dev); 1669 - of_node_put(child); 1670 1680 goto fail; 1671 1681 } 1672 1682 ··· 1706 1718 init_waitqueue_head(&cluster->core_transition); 1707 1719 1708 1720 ret = of_property_read_u32(np, "ti,cluster-mode", &cluster->mode); 1709 - if (ret < 0 && ret != -EINVAL) { 1710 - dev_err(dev, "invalid format for ti,cluster-mode, ret = %d\n", 1711 - ret); 1712 - return ret; 1713 - } 1721 + if (ret < 0 && ret != -EINVAL) 1722 + return dev_err_probe(dev, ret, "invalid format for ti,cluster-mode\n"); 1714 1723 1715 1724 if (ret == -EINVAL) { 1716 1725 /* ··· 1726 1741 } 1727 1742 1728 1743 if ((cluster->mode == CLUSTER_MODE_SINGLECPU && !data->single_cpu_mode) || 1729 - (cluster->mode == CLUSTER_MODE_SINGLECORE && !data->is_single_core)) { 1730 - dev_err(dev, "Cluster mode = %d is not supported on this SoC\n", cluster->mode); 1731 - return -EINVAL; 1732 - } 1744 + (cluster->mode == CLUSTER_MODE_SINGLECORE && !data->is_single_core)) 1745 + return dev_err_probe(dev, -EINVAL, 1746 + "Cluster mode = %d is not supported on this SoC\n", 1747 + cluster->mode); 1733 1748 1734 1749 num_cores = of_get_available_child_count(np); 1735 - if (num_cores != 2 && !data->is_single_core) { 1736 - dev_err(dev, "MCU cluster requires both R5F cores to be enabled but num_cores is set to = %d\n", 1737 - num_cores); 1738 - return -ENODEV; 1739 - } 1750 + if (num_cores != 2 && !data->is_single_core) 1751 + return dev_err_probe(dev, -ENODEV, 1752 + "MCU cluster requires both R5F cores to be enabled but num_cores is set to = %d\n", 1753 + num_cores); 1740 1754 1741 - if (num_cores != 1 && data->is_single_core) { 1742 - dev_err(dev, "SoC supports only single core R5 but num_cores is set to %d\n", 1743 - num_cores); 1744 - return -ENODEV; 1745 - } 1755 + if (num_cores != 1 && data->is_single_core) 1756 + return dev_err_probe(dev, -ENODEV, 1757 + "SoC supports only single core R5 but num_cores is set to %d\n", 1758 + num_cores); 1746 1759 1747 1760 platform_set_drvdata(pdev, cluster); 1748 1761 1749 1762 ret = devm_of_platform_populate(dev); 1750 - if (ret) { 1751 - dev_err(dev, "devm_of_platform_populate failed, ret = %d\n", 1752 - ret); 1753 - return ret; 1754 - } 1763 + if (ret) 1764 + return dev_err_probe(dev, ret, "devm_of_platform_populate failed\n"); 1755 1765 1756 1766 ret = k3_r5_cluster_of_init(pdev); 1757 - if (ret) { 1758 - dev_err(dev, "k3_r5_cluster_of_init failed, ret = %d\n", ret); 1759 - return ret; 1760 - } 1767 + if (ret) 1768 + return dev_err_probe(dev, ret, "k3_r5_cluster_of_init failed\n"); 1761 1769 1762 1770 ret = devm_add_action_or_reset(dev, k3_r5_cluster_of_exit, pdev); 1763 1771 if (ret) 1764 1772 return ret; 1765 1773 1766 1774 ret = k3_r5_cluster_rproc_init(pdev); 1767 - if (ret) { 1768 - dev_err(dev, "k3_r5_cluster_rproc_init failed, ret = %d\n", 1769 - ret); 1770 - return ret; 1771 - } 1775 + if (ret) 1776 + return dev_err_probe(dev, ret, "k3_r5_cluster_rproc_init failed\n"); 1772 1777 1773 1778 ret = devm_add_action_or_reset(dev, k3_r5_cluster_rproc_exit, pdev); 1774 1779 if (ret)
+1 -1
drivers/remoteproc/wkup_m3_rproc.c
··· 251 251 252 252 static struct platform_driver wkup_m3_rproc_driver = { 253 253 .probe = wkup_m3_rproc_probe, 254 - .remove_new = wkup_m3_rproc_remove, 254 + .remove = wkup_m3_rproc_remove, 255 255 .driver = { 256 256 .name = "wkup_m3_rproc", 257 257 .of_match_table = wkup_m3_rproc_of_match,