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

+12 -14

Documentation/devicetree/bindings/remoteproc/qcom,adsp.yaml

··· 24 24 - qcom,msm8998-adsp-pas 25 25 - qcom,msm8998-slpi-pas 26 26 - qcom,sdm660-adsp-pas 27 + - qcom,sdm660-cdsp-pas 27 28 - qcom,sdm845-adsp-pas 28 29 - qcom,sdm845-cdsp-pas 29 30 - qcom,sdm845-slpi-pas 30 31 31 32 reg: 32 33 maxItems: 1 33 - 34 - cx-supply: 35 - description: Phandle to the CX regulator 36 34 37 35 px-supply: 38 36 description: Phandle to the PX regulator ··· 67 69 - qcom,msm8996-slpi-pil 68 70 - qcom,msm8998-adsp-pas 69 71 - qcom,msm8998-slpi-pas 72 + - qcom,sdm660-adsp-pas 73 + - qcom,sdm660-cdsp-pas 70 74 - qcom,sdm845-adsp-pas 71 75 - qcom,sdm845-cdsp-pas 72 76 - qcom,sdm845-slpi-pas ··· 93 93 - qcom,msm8996-slpi-pil 94 94 - qcom,msm8998-adsp-pas 95 95 - qcom,msm8998-slpi-pas 96 + - qcom,sdm660-adsp-pas 97 + - qcom,sdm660-cdsp-pas 96 98 - qcom,sdm845-adsp-pas 97 99 - qcom,sdm845-cdsp-pas 98 100 - qcom,sdm845-slpi-pas ··· 110 108 compatible: 111 109 contains: 112 110 enum: 113 - - qcom,msm8974-adsp-pil 114 - then: 115 - required: 116 - - cx-supply 117 - 118 - - if: 119 - properties: 120 - compatible: 121 - contains: 122 - enum: 123 111 - qcom,msm8226-adsp-pil 124 112 - qcom,msm8953-adsp-pil 113 + - qcom,msm8974-adsp-pil 125 114 - qcom,msm8996-adsp-pil 126 115 - qcom,msm8998-adsp-pas 116 + - qcom,sdm660-adsp-pas 117 + - qcom,sdm660-cdsp-pas 127 118 then: 128 119 properties: 129 120 power-domains: ··· 173 178 - qcom,msm8998-adsp-pas 174 179 - qcom,msm8998-slpi-pas 175 180 - qcom,sdm660-adsp-pas 181 + - qcom,sdm660-cdsp-pas 176 182 then: 177 183 properties: 178 184 qcom,qmp: false ··· 183 187 #include <dt-bindings/clock/qcom,rpmcc.h> 184 188 #include <dt-bindings/interrupt-controller/arm-gic.h> 185 189 #include <dt-bindings/interrupt-controller/irq.h> 190 + #include <dt-bindings/power/qcom-rpmpd.h> 186 191 adsp { 187 192 compatible = "qcom,msm8974-adsp-pil"; 188 193 ··· 201 204 clocks = <&rpmcc RPM_CXO_CLK>; 202 205 clock-names = "xo"; 203 206 204 - cx-supply = <&pm8841_s2>; 207 + power-domains = <&rpmpd MSM8974_VDDCX>; 208 + power-domain-names = "cx"; 205 209 206 210 memory-region = <&adsp_region>; 207 211

+4

Documentation/devicetree/bindings/remoteproc/qcom,sc8280xp-pas.yaml

··· 91 91 power-domains: 92 92 items: 93 93 - description: NSP power domain 94 + - description: CX power domain 95 + - description: MXC power domain 94 96 power-domain-names: 95 97 items: 96 98 - const: nsp 99 + - const: cx 100 + - const: mxc 97 101 98 102 unevaluatedProperties: false 99 103

+206 -198

drivers/remoteproc/imx_dsp_rproc.c

··· 261 261 return 0; 262 262 } 263 263 264 - /* Specific configuration for i.MX8MP */ 265 - static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8mp = { 266 - .att = imx_dsp_rproc_att_imx8mp, 267 - .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8mp), 268 - .method = IMX_RPROC_RESET_CONTROLLER, 269 - }; 270 - 271 - static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8mp = { 272 - .dcfg = &dsp_rproc_cfg_imx8mp, 273 - .reset = imx8mp_dsp_reset, 274 - }; 275 - 276 - /* Specific configuration for i.MX8ULP */ 277 - static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8ulp = { 278 - .src_reg = IMX8ULP_SIM_LPAV_REG_SYSCTRL0, 279 - .src_mask = IMX8ULP_SYSCTRL0_DSP_STALL, 280 - .src_start = 0, 281 - .src_stop = IMX8ULP_SYSCTRL0_DSP_STALL, 282 - .att = imx_dsp_rproc_att_imx8ulp, 283 - .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8ulp), 284 - .method = IMX_RPROC_MMIO, 285 - }; 286 - 287 - static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8ulp = { 288 - .dcfg = &dsp_rproc_cfg_imx8ulp, 289 - .reset = imx8ulp_dsp_reset, 290 - }; 291 - 292 - /* Specific configuration for i.MX8QXP */ 293 - static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8qxp = { 294 - .att = imx_dsp_rproc_att_imx8qxp, 295 - .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8qxp), 296 - .method = IMX_RPROC_SCU_API, 297 - }; 298 - 299 - static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8qxp = { 300 - .dcfg = &dsp_rproc_cfg_imx8qxp, 301 - }; 302 - 303 - /* Specific configuration for i.MX8QM */ 304 - static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8qm = { 305 - .att = imx_dsp_rproc_att_imx8qm, 306 - .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8qm), 307 - .method = IMX_RPROC_SCU_API, 308 - }; 309 - 310 - static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8qm = { 311 - .dcfg = &dsp_rproc_cfg_imx8qm, 312 - }; 313 - 314 264 static int imx_dsp_rproc_ready(struct rproc *rproc) 315 265 { 316 266 struct imx_dsp_rproc *priv = rproc->priv; ··· 338 388 return RSC_HANDLED; 339 389 } 340 390 391 + static int imx_dsp_rproc_mmio_start(struct rproc *rproc) 392 + { 393 + struct imx_dsp_rproc *priv = rproc->priv; 394 + const struct imx_rproc_dcfg *dcfg = priv->dsp_dcfg->dcfg; 395 + 396 + return regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask, dcfg->src_start); 397 + } 398 + 399 + static int imx_dsp_rproc_reset_ctrl_start(struct rproc *rproc) 400 + { 401 + struct imx_dsp_rproc *priv = rproc->priv; 402 + 403 + return reset_control_deassert(priv->run_stall); 404 + } 405 + 406 + static int imx_dsp_rproc_scu_api_start(struct rproc *rproc) 407 + { 408 + struct imx_dsp_rproc *priv = rproc->priv; 409 + 410 + return imx_sc_pm_cpu_start(priv->ipc_handle, IMX_SC_R_DSP, true, rproc->bootaddr); 411 + } 412 + 341 413 /* 342 414 * Start function for rproc_ops 343 415 * ··· 376 404 struct device *dev = rproc->dev.parent; 377 405 int ret; 378 406 379 - switch (dcfg->method) { 380 - case IMX_RPROC_MMIO: 381 - ret = regmap_update_bits(priv->regmap, 382 - dcfg->src_reg, 383 - dcfg->src_mask, 384 - dcfg->src_start); 385 - break; 386 - case IMX_RPROC_SCU_API: 387 - ret = imx_sc_pm_cpu_start(priv->ipc_handle, 388 - IMX_SC_R_DSP, 389 - true, 390 - rproc->bootaddr); 391 - break; 392 - case IMX_RPROC_RESET_CONTROLLER: 393 - ret = reset_control_deassert(priv->run_stall); 394 - break; 395 - default: 407 + if (!dcfg->ops || !dcfg->ops->start) 396 408 return -EOPNOTSUPP; 409 + 410 + ret = dcfg->ops->start(rproc); 411 + if (ret) { 412 + dev_err(dev, "Failed to enable remote core!\n"); 413 + return ret; 397 414 } 398 415 399 - if (ret) 400 - dev_err(dev, "Failed to enable remote core!\n"); 401 - else if (priv->flags & WAIT_FW_READY) 416 + if (priv->flags & WAIT_FW_READY) 402 417 return imx_dsp_rproc_ready(rproc); 403 418 404 - return ret; 419 + return 0; 420 + } 421 + 422 + static int imx_dsp_rproc_mmio_stop(struct rproc *rproc) 423 + { 424 + struct imx_dsp_rproc *priv = rproc->priv; 425 + const struct imx_rproc_dcfg *dcfg = priv->dsp_dcfg->dcfg; 426 + 427 + return regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask, dcfg->src_stop); 428 + } 429 + 430 + static int imx_dsp_rproc_reset_ctrl_stop(struct rproc *rproc) 431 + { 432 + struct imx_dsp_rproc *priv = rproc->priv; 433 + 434 + return reset_control_assert(priv->run_stall); 435 + } 436 + 437 + static int imx_dsp_rproc_scu_api_stop(struct rproc *rproc) 438 + { 439 + struct imx_dsp_rproc *priv = rproc->priv; 440 + 441 + return imx_sc_pm_cpu_start(priv->ipc_handle, IMX_SC_R_DSP, false, rproc->bootaddr); 405 442 } 406 443 407 444 /* ··· 430 449 return 0; 431 450 } 432 451 433 - switch (dcfg->method) { 434 - case IMX_RPROC_MMIO: 435 - ret = regmap_update_bits(priv->regmap, dcfg->src_reg, dcfg->src_mask, 436 - dcfg->src_stop); 437 - break; 438 - case IMX_RPROC_SCU_API: 439 - ret = imx_sc_pm_cpu_start(priv->ipc_handle, 440 - IMX_SC_R_DSP, 441 - false, 442 - rproc->bootaddr); 443 - break; 444 - case IMX_RPROC_RESET_CONTROLLER: 445 - ret = reset_control_assert(priv->run_stall); 446 - break; 447 - default: 452 + if (!dcfg->ops || !dcfg->ops->stop) 448 453 return -EOPNOTSUPP; 454 + 455 + ret = dcfg->ops->stop(rproc); 456 + if (ret) { 457 + dev_err(dev, "Failed to stop remote core\n"); 458 + return ret; 449 459 } 450 460 451 - if (ret) 452 - dev_err(dev, "Failed to stop remote core\n"); 453 - else 454 - priv->flags &= ~REMOTE_IS_READY; 461 + priv->flags &= ~REMOTE_IS_READY; 455 462 456 - return ret; 463 + return 0; 457 464 } 458 465 459 466 /** ··· 658 689 struct rproc *rproc = priv->rproc; 659 690 struct device *dev = rproc->dev.parent; 660 691 struct device_node *np = dev->of_node; 661 - struct of_phandle_iterator it; 662 692 struct rproc_mem_entry *mem; 663 - struct reserved_mem *rmem; 664 693 void __iomem *cpu_addr; 665 - int a; 694 + int a, i = 0; 666 695 u64 da; 667 696 668 697 /* Remap required addresses */ ··· 691 724 rproc_add_carveout(rproc, mem); 692 725 } 693 726 694 - of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); 695 - while (of_phandle_iterator_next(&it) == 0) { 727 + while (1) { 728 + int err; 729 + struct resource res; 730 + 731 + err = of_reserved_mem_region_to_resource(np, i++, &res); 732 + if (err) 733 + return 0; 734 + 696 735 /* 697 736 * Ignore the first memory region which will be used vdev buffer. 698 737 * No need to do extra handlings, rproc_add_virtio_dev will handle it. 699 738 */ 700 - if (!strcmp(it.node->name, "vdev0buffer")) 739 + if (strstarts(res.name, "vdev0buffer")) 701 740 continue; 702 741 703 - rmem = of_reserved_mem_lookup(it.node); 704 - if (!rmem) { 705 - of_node_put(it.node); 706 - dev_err(dev, "unable to acquire memory-region\n"); 742 + if (imx_dsp_rproc_sys_to_da(priv, res.start, resource_size(&res), &da)) 707 743 return -EINVAL; 708 - } 709 744 710 - if (imx_dsp_rproc_sys_to_da(priv, rmem->base, rmem->size, &da)) { 711 - of_node_put(it.node); 712 - return -EINVAL; 713 - } 714 - 715 - cpu_addr = devm_ioremap_wc(dev, rmem->base, rmem->size); 716 - if (!cpu_addr) { 717 - of_node_put(it.node); 718 - dev_err(dev, "failed to map memory %p\n", &rmem->base); 719 - return -ENOMEM; 745 + cpu_addr = devm_ioremap_resource_wc(dev, &res); 746 + if (IS_ERR(cpu_addr)) { 747 + dev_err(dev, "failed to map memory %pR\n", &res); 748 + return PTR_ERR(cpu_addr); 720 749 } 721 750 722 751 /* Register memory region */ 723 - mem = rproc_mem_entry_init(dev, (void __force *)cpu_addr, (dma_addr_t)rmem->base, 724 - rmem->size, da, NULL, NULL, it.node->name); 725 - 726 - if (mem) { 727 - rproc_coredump_add_segment(rproc, da, rmem->size); 728 - } else { 729 - of_node_put(it.node); 752 + mem = rproc_mem_entry_init(dev, (void __force *)cpu_addr, (dma_addr_t)res.start, 753 + resource_size(&res), da, NULL, NULL, 754 + "%.*s", strchrnul(res.name, '@') - res.name, res.name); 755 + if (!mem) 730 756 return -ENOMEM; 731 - } 732 757 758 + rproc_coredump_add_segment(rproc, da, resource_size(&res)); 733 759 rproc_add_carveout(rproc, mem); 734 760 } 735 - 736 - return 0; 737 761 } 738 762 739 763 /* Prepare function for rproc_ops */ ··· 742 784 743 785 pm_runtime_get_sync(dev); 744 786 745 - return 0; 787 + return 0; 746 788 } 747 789 748 790 /* Unprepare function for rproc_ops */ ··· 750 792 { 751 793 pm_runtime_put_sync(rproc->dev.parent); 752 794 753 - return 0; 795 + return 0; 754 796 } 755 797 756 798 /* Kick function for rproc_ops */ ··· 1020 1062 static int imx_dsp_attach_pm_domains(struct imx_dsp_rproc *priv) 1021 1063 { 1022 1064 struct device *dev = priv->rproc->dev.parent; 1023 - int ret; 1024 1065 1025 1066 /* A single PM domain is already attached. */ 1026 1067 if (dev->pm_domain) 1027 1068 return 0; 1028 1069 1029 - ret = dev_pm_domain_attach_list(dev, NULL, &priv->pd_list); 1030 - return ret < 0 ? ret : 0; 1070 + return devm_pm_domain_attach_list(dev, NULL, &priv->pd_list); 1071 + } 1072 + 1073 + static int imx_dsp_rproc_mmio_detect_mode(struct rproc *rproc) 1074 + { 1075 + struct imx_dsp_rproc *priv = rproc->priv; 1076 + struct device *dev = rproc->dev.parent; 1077 + struct regmap *regmap; 1078 + 1079 + regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "fsl,dsp-ctrl"); 1080 + if (IS_ERR(regmap)) { 1081 + dev_err(dev, "failed to find syscon\n"); 1082 + return PTR_ERR(regmap); 1083 + } 1084 + 1085 + priv->regmap = regmap; 1086 + 1087 + return 0; 1088 + } 1089 + 1090 + static int imx_dsp_rproc_reset_ctrl_detect_mode(struct rproc *rproc) 1091 + { 1092 + struct imx_dsp_rproc *priv = rproc->priv; 1093 + struct device *dev = rproc->dev.parent; 1094 + 1095 + priv->run_stall = devm_reset_control_get_exclusive(dev, "runstall"); 1096 + if (IS_ERR(priv->run_stall)) { 1097 + dev_err(dev, "Failed to get DSP runstall reset control\n"); 1098 + return PTR_ERR(priv->run_stall); 1099 + } 1100 + 1101 + return 0; 1102 + } 1103 + 1104 + static int imx_dsp_rproc_scu_api_detect_mode(struct rproc *rproc) 1105 + { 1106 + struct imx_dsp_rproc *priv = rproc->priv; 1107 + 1108 + return imx_scu_get_handle(&priv->ipc_handle); 1031 1109 } 1032 1110 1033 1111 /** ··· 1081 1087 static int imx_dsp_rproc_detect_mode(struct imx_dsp_rproc *priv) 1082 1088 { 1083 1089 const struct imx_dsp_rproc_dcfg *dsp_dcfg = priv->dsp_dcfg; 1084 - struct device *dev = priv->rproc->dev.parent; 1085 - struct regmap *regmap; 1086 - int ret = 0; 1090 + const struct imx_rproc_dcfg *dcfg = dsp_dcfg->dcfg; 1087 1091 1088 - switch (dsp_dcfg->dcfg->method) { 1089 - case IMX_RPROC_SCU_API: 1090 - ret = imx_scu_get_handle(&priv->ipc_handle); 1091 - if (ret) 1092 - return ret; 1093 - break; 1094 - case IMX_RPROC_MMIO: 1095 - regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "fsl,dsp-ctrl"); 1096 - if (IS_ERR(regmap)) { 1097 - dev_err(dev, "failed to find syscon\n"); 1098 - return PTR_ERR(regmap); 1099 - } 1092 + if (dcfg->ops && dcfg->ops->detect_mode) 1093 + return dcfg->ops->detect_mode(priv->rproc); 1100 1094 1101 - priv->regmap = regmap; 1102 - break; 1103 - case IMX_RPROC_RESET_CONTROLLER: 1104 - priv->run_stall = devm_reset_control_get_exclusive(dev, "runstall"); 1105 - if (IS_ERR(priv->run_stall)) { 1106 - dev_err(dev, "Failed to get DSP runstall reset control\n"); 1107 - return PTR_ERR(priv->run_stall); 1108 - } 1109 - break; 1110 - default: 1111 - ret = -EOPNOTSUPP; 1112 - break; 1113 - } 1114 - 1115 - return ret; 1095 + return -EOPNOTSUPP; 1116 1096 } 1117 1097 1118 1098 static const char *imx_dsp_clks_names[DSP_RPROC_CLK_MAX] = { ··· 1120 1152 return -ENODEV; 1121 1153 1122 1154 ret = rproc_of_parse_firmware(dev, 0, &fw_name); 1123 - if (ret) { 1124 - dev_err(dev, "failed to parse firmware-name property, ret = %d\n", 1125 - ret); 1126 - return ret; 1127 - } 1155 + if (ret) 1156 + return dev_err_probe(dev, ret, "failed to parse firmware-name property\n"); 1128 1157 1129 1158 rproc = devm_rproc_alloc(dev, "imx-dsp-rproc", &imx_dsp_rproc_ops, 1130 1159 fw_name, sizeof(*priv)); ··· 1144 1179 INIT_WORK(&priv->rproc_work, imx_dsp_rproc_vq_work); 1145 1180 1146 1181 ret = imx_dsp_rproc_detect_mode(priv); 1147 - if (ret) { 1148 - dev_err(dev, "failed on imx_dsp_rproc_detect_mode\n"); 1149 - return ret; 1150 - } 1182 + if (ret) 1183 + return dev_err_probe(dev, ret, "failed on imx_dsp_rproc_detect_mode\n"); 1151 1184 1152 1185 /* There are multiple power domains required by DSP on some platform */ 1153 1186 ret = imx_dsp_attach_pm_domains(priv); 1154 - if (ret) { 1155 - dev_err(dev, "failed on imx_dsp_attach_pm_domains\n"); 1156 - return ret; 1157 - } 1187 + if (ret < 0) 1188 + return dev_err_probe(dev, ret, "failed on imx_dsp_attach_pm_domains\n"); 1189 + 1158 1190 /* Get clocks */ 1159 1191 ret = imx_dsp_rproc_clk_get(priv); 1160 - if (ret) { 1161 - dev_err(dev, "failed on imx_dsp_rproc_clk_get\n"); 1162 - goto err_detach_domains; 1163 - } 1192 + if (ret) 1193 + return dev_err_probe(dev, ret, "failed on imx_dsp_rproc_clk_get\n"); 1164 1194 1165 1195 init_completion(&priv->pm_comp); 1166 1196 rproc->auto_boot = false; 1167 - ret = rproc_add(rproc); 1168 - if (ret) { 1169 - dev_err(dev, "rproc_add failed\n"); 1170 - goto err_detach_domains; 1171 - } 1197 + ret = devm_rproc_add(dev, rproc); 1198 + if (ret) 1199 + return dev_err_probe(dev, ret, "rproc_add failed\n"); 1172 1200 1173 1201 rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_XTENSA); 1174 1202 1175 - pm_runtime_enable(dev); 1176 - 1177 - return 0; 1178 - 1179 - err_detach_domains: 1180 - dev_pm_domain_detach_list(priv->pd_list); 1181 - 1182 - return ret; 1183 - } 1184 - 1185 - static void imx_dsp_rproc_remove(struct platform_device *pdev) 1186 - { 1187 - struct rproc *rproc = platform_get_drvdata(pdev); 1188 - struct imx_dsp_rproc *priv = rproc->priv; 1189 - 1190 - pm_runtime_disable(&pdev->dev); 1191 - rproc_del(rproc); 1192 - dev_pm_domain_detach_list(priv->pd_list); 1203 + return devm_pm_runtime_enable(dev); 1193 1204 } 1194 1205 1195 1206 /* pm runtime functions */ ··· 1305 1364 RUNTIME_PM_OPS(imx_dsp_runtime_suspend, imx_dsp_runtime_resume, NULL) 1306 1365 }; 1307 1366 1367 + static const struct imx_rproc_plat_ops imx_dsp_rproc_ops_mmio = { 1368 + .start = imx_dsp_rproc_mmio_start, 1369 + .stop = imx_dsp_rproc_mmio_stop, 1370 + .detect_mode = imx_dsp_rproc_mmio_detect_mode, 1371 + }; 1372 + 1373 + static const struct imx_rproc_plat_ops imx_dsp_rproc_ops_reset_ctrl = { 1374 + .start = imx_dsp_rproc_reset_ctrl_start, 1375 + .stop = imx_dsp_rproc_reset_ctrl_stop, 1376 + .detect_mode = imx_dsp_rproc_reset_ctrl_detect_mode, 1377 + }; 1378 + 1379 + static const struct imx_rproc_plat_ops imx_dsp_rproc_ops_scu_api = { 1380 + .start = imx_dsp_rproc_scu_api_start, 1381 + .stop = imx_dsp_rproc_scu_api_stop, 1382 + .detect_mode = imx_dsp_rproc_scu_api_detect_mode, 1383 + }; 1384 + 1385 + /* Specific configuration for i.MX8MP */ 1386 + static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8mp = { 1387 + .att = imx_dsp_rproc_att_imx8mp, 1388 + .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8mp), 1389 + .ops = &imx_dsp_rproc_ops_reset_ctrl, 1390 + }; 1391 + 1392 + static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8mp = { 1393 + .dcfg = &dsp_rproc_cfg_imx8mp, 1394 + .reset = imx8mp_dsp_reset, 1395 + }; 1396 + 1397 + /* Specific configuration for i.MX8ULP */ 1398 + static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8ulp = { 1399 + .src_reg = IMX8ULP_SIM_LPAV_REG_SYSCTRL0, 1400 + .src_mask = IMX8ULP_SYSCTRL0_DSP_STALL, 1401 + .src_start = 0, 1402 + .src_stop = IMX8ULP_SYSCTRL0_DSP_STALL, 1403 + .att = imx_dsp_rproc_att_imx8ulp, 1404 + .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8ulp), 1405 + .ops = &imx_dsp_rproc_ops_mmio, 1406 + }; 1407 + 1408 + static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8ulp = { 1409 + .dcfg = &dsp_rproc_cfg_imx8ulp, 1410 + .reset = imx8ulp_dsp_reset, 1411 + }; 1412 + 1413 + /* Specific configuration for i.MX8QXP */ 1414 + static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8qxp = { 1415 + .att = imx_dsp_rproc_att_imx8qxp, 1416 + .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8qxp), 1417 + .ops = &imx_dsp_rproc_ops_scu_api, 1418 + }; 1419 + 1420 + static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8qxp = { 1421 + .dcfg = &dsp_rproc_cfg_imx8qxp, 1422 + }; 1423 + 1424 + /* Specific configuration for i.MX8QM */ 1425 + static const struct imx_rproc_dcfg dsp_rproc_cfg_imx8qm = { 1426 + .att = imx_dsp_rproc_att_imx8qm, 1427 + .att_size = ARRAY_SIZE(imx_dsp_rproc_att_imx8qm), 1428 + .ops = &imx_dsp_rproc_ops_scu_api, 1429 + }; 1430 + 1431 + static const struct imx_dsp_rproc_dcfg imx_dsp_rproc_cfg_imx8qm = { 1432 + .dcfg = &dsp_rproc_cfg_imx8qm, 1433 + }; 1434 + 1308 1435 static const struct of_device_id imx_dsp_rproc_of_match[] = { 1309 1436 { .compatible = "fsl,imx8qxp-hifi4", .data = &imx_dsp_rproc_cfg_imx8qxp }, 1310 1437 { .compatible = "fsl,imx8qm-hifi4", .data = &imx_dsp_rproc_cfg_imx8qm }, ··· 1384 1375 1385 1376 static struct platform_driver imx_dsp_rproc_driver = { 1386 1377 .probe = imx_dsp_rproc_probe, 1387 - .remove = imx_dsp_rproc_remove, 1388 1378 .driver = { 1389 1379 .name = "imx-dsp-rproc", 1390 1380 .of_match_table = imx_dsp_rproc_of_match,

+99 -139

drivers/remoteproc/imx_rproc.c

··· 93 93 #define ATT_CORE(I) BIT((I)) 94 94 95 95 static int imx_rproc_xtr_mbox_init(struct rproc *rproc, bool tx_block); 96 - static void imx_rproc_free_mbox(struct rproc *rproc); 96 + static void imx_rproc_free_mbox(void *data); 97 97 98 98 struct imx_rproc { 99 99 struct device *dev; ··· 490 490 { 491 491 struct imx_rproc *priv = rproc->priv; 492 492 struct device_node *np = priv->dev->of_node; 493 - struct of_phandle_iterator it; 494 493 struct rproc_mem_entry *mem; 495 - struct reserved_mem *rmem; 494 + int i = 0; 496 495 u32 da; 497 496 498 497 /* Register associated reserved memory regions */ 499 - of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); 500 - while (of_phandle_iterator_next(&it) == 0) { 498 + while (1) { 499 + int err; 500 + struct resource res; 501 + 502 + err = of_reserved_mem_region_to_resource(np, i++, &res); 503 + if (err) 504 + return 0; 505 + 501 506 /* 502 507 * Ignore the first memory region which will be used vdev buffer. 503 508 * No need to do extra handlings, rproc_add_virtio_dev will handle it. 504 509 */ 505 - if (!strcmp(it.node->name, "vdev0buffer")) 510 + if (strstarts(res.name, "vdev0buffer")) 506 511 continue; 507 512 508 - if (!strcmp(it.node->name, "rsc-table")) 513 + if (strstarts(res.name, "rsc-table")) 509 514 continue; 510 - 511 - rmem = of_reserved_mem_lookup(it.node); 512 - if (!rmem) { 513 - of_node_put(it.node); 514 - dev_err(priv->dev, "unable to acquire memory-region\n"); 515 - return -EINVAL; 516 - } 517 515 518 516 /* No need to translate pa to da, i.MX use same map */ 519 - da = rmem->base; 517 + da = res.start; 520 518 521 519 /* Register memory region */ 522 - mem = rproc_mem_entry_init(priv->dev, NULL, (dma_addr_t)rmem->base, rmem->size, da, 520 + mem = rproc_mem_entry_init(priv->dev, NULL, (dma_addr_t)res.start, 521 + resource_size(&res), da, 523 522 imx_rproc_mem_alloc, imx_rproc_mem_release, 524 - it.node->name); 525 - 526 - if (mem) { 527 - rproc_coredump_add_segment(rproc, da, rmem->size); 528 - } else { 529 - of_node_put(it.node); 523 + "%.*s", strchrnul(res.name, '@') - res.name, 524 + res.name); 525 + if (!mem) 530 526 return -ENOMEM; 531 - } 532 527 528 + rproc_coredump_add_segment(rproc, da, resource_size(&res)); 533 529 rproc_add_carveout(rproc, mem); 534 530 } 535 - 536 - return 0; 537 531 } 538 532 539 533 static int imx_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) ··· 569 575 return imx_rproc_xtr_mbox_init(rproc, true); 570 576 } 571 577 572 - static int imx_rproc_detach(struct rproc *rproc) 578 + static int imx_rproc_scu_api_detach(struct rproc *rproc) 573 579 { 574 580 struct imx_rproc *priv = rproc->priv; 575 - const struct imx_rproc_dcfg *dcfg = priv->dcfg; 576 - 577 - if (dcfg->method != IMX_RPROC_SCU_API) 578 - return -EOPNOTSUPP; 579 581 580 582 if (imx_sc_rm_is_resource_owned(priv->ipc_handle, priv->rsrc_id)) 581 583 return -EOPNOTSUPP; ··· 579 589 imx_rproc_free_mbox(rproc); 580 590 581 591 return 0; 592 + } 593 + 594 + static int imx_rproc_detach(struct rproc *rproc) 595 + { 596 + struct imx_rproc *priv = rproc->priv; 597 + const struct imx_rproc_dcfg *dcfg = priv->dcfg; 598 + 599 + if (!dcfg->ops || !dcfg->ops->detach) 600 + return -EOPNOTSUPP; 601 + 602 + return dcfg->ops->detach(rproc); 582 603 } 583 604 584 605 static struct resource_table *imx_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz) ··· 665 664 } 666 665 667 666 /* memory-region is optional property */ 668 - nph = of_count_phandle_with_args(np, "memory-region", NULL); 667 + nph = of_reserved_mem_region_count(np); 669 668 if (nph <= 0) 670 669 return 0; 671 670 672 671 /* remap optional addresses */ 673 672 for (a = 0; a < nph; a++) { 674 - struct device_node *node; 675 673 struct resource res; 676 674 677 - node = of_parse_phandle(np, "memory-region", a); 678 - if (!node) 679 - continue; 680 - /* Not map vdevbuffer, vdevring region */ 681 - if (!strncmp(node->name, "vdev", strlen("vdev"))) { 682 - of_node_put(node); 683 - continue; 684 - } 685 - err = of_address_to_resource(node, 0, &res); 675 + err = of_reserved_mem_region_to_resource(np, a, &res); 686 676 if (err) { 687 677 dev_err(dev, "unable to resolve memory region\n"); 688 - of_node_put(node); 689 678 return err; 690 679 } 691 680 692 - if (b >= IMX_RPROC_MEM_MAX) { 693 - of_node_put(node); 681 + /* Not map vdevbuffer, vdevring region */ 682 + if (strstarts(res.name, "vdev")) 683 + continue; 684 + 685 + if (b >= IMX_RPROC_MEM_MAX) 694 686 break; 695 - } 696 687 697 688 /* Not use resource version, because we might share region */ 698 - priv->mem[b].cpu_addr = devm_ioremap_wc(&pdev->dev, res.start, resource_size(&res)); 689 + priv->mem[b].cpu_addr = devm_ioremap_resource_wc(&pdev->dev, &res); 699 690 if (!priv->mem[b].cpu_addr) { 700 691 dev_err(dev, "failed to remap %pr\n", &res); 701 - of_node_put(node); 702 692 return -ENOMEM; 703 693 } 704 694 priv->mem[b].sys_addr = res.start; 705 695 priv->mem[b].size = resource_size(&res); 706 - if (!strcmp(node->name, "rsc-table")) 696 + if (!strcmp(res.name, "rsc-table")) 707 697 priv->rsc_table = priv->mem[b].cpu_addr; 708 - of_node_put(node); 709 698 b++; 710 699 } 711 700 ··· 771 780 return 0; 772 781 } 773 782 774 - static void imx_rproc_free_mbox(struct rproc *rproc) 783 + static void imx_rproc_free_mbox(void *data) 775 784 { 785 + struct rproc *rproc = data; 776 786 struct imx_rproc *priv = rproc->priv; 777 787 778 788 if (priv->tx_ch) { ··· 787 795 } 788 796 } 789 797 790 - static void imx_rproc_put_scu(struct rproc *rproc) 798 + static void imx_rproc_put_scu(void *data) 791 799 { 792 - struct imx_rproc *priv = rproc->priv; 793 - const struct imx_rproc_dcfg *dcfg = priv->dcfg; 794 - 795 - if (dcfg->method != IMX_RPROC_SCU_API) 796 - return; 800 + struct imx_rproc *priv = data; 797 801 798 802 if (imx_sc_rm_is_resource_owned(priv->ipc_handle, priv->rsrc_id)) { 799 803 dev_pm_domain_detach_list(priv->pd_list); ··· 931 943 else 932 944 priv->core_index = 0; 933 945 946 + ret = devm_add_action_or_reset(dev, imx_rproc_put_scu, priv); 947 + if (ret) 948 + return dev_err_probe(dev, ret, "Failed to add action for put scu\n"); 949 + 934 950 /* 935 951 * If Mcore resource is not owned by Acore partition, It is kicked by ROM, 936 952 * and Linux could only do IPC with Mcore and nothing else. ··· 993 1001 return dcfg->ops->detect_mode(priv->rproc); 994 1002 } 995 1003 996 - static int imx_rproc_clk_enable(struct imx_rproc *priv) 997 - { 998 - const struct imx_rproc_dcfg *dcfg = priv->dcfg; 999 - struct device *dev = priv->dev; 1000 - int ret; 1001 - 1002 - /* Remote core is not under control of Linux or it is managed by SCU API */ 1003 - if (dcfg->method == IMX_RPROC_NONE || dcfg->method == IMX_RPROC_SCU_API) 1004 - return 0; 1005 - 1006 - priv->clk = devm_clk_get(dev, NULL); 1007 - if (IS_ERR(priv->clk)) { 1008 - dev_err(dev, "Failed to get clock\n"); 1009 - return PTR_ERR(priv->clk); 1010 - } 1011 - 1012 - /* 1013 - * clk for M4 block including memory. Should be 1014 - * enabled before .start for FW transfer. 1015 - */ 1016 - ret = clk_prepare_enable(priv->clk); 1017 - if (ret) { 1018 - dev_err(dev, "Failed to enable clock\n"); 1019 - return ret; 1020 - } 1021 - 1022 - return 0; 1023 - } 1024 - 1025 1004 static int imx_rproc_sys_off_handler(struct sys_off_data *data) 1026 1005 { 1027 1006 struct rproc *rproc = data->cb_data; ··· 1007 1044 } 1008 1045 1009 1046 return NOTIFY_DONE; 1047 + } 1048 + 1049 + static void imx_rproc_destroy_workqueue(void *data) 1050 + { 1051 + struct workqueue_struct *workqueue = data; 1052 + 1053 + destroy_workqueue(workqueue); 1010 1054 } 1011 1055 1012 1056 static int imx_rproc_probe(struct platform_device *pdev) ··· 1047 1077 return -ENOMEM; 1048 1078 } 1049 1079 1080 + ret = devm_add_action_or_reset(dev, imx_rproc_destroy_workqueue, priv->workqueue); 1081 + if (ret) 1082 + return dev_err_probe(dev, ret, "Failed to add devm destroy workqueue action\n"); 1083 + 1050 1084 INIT_WORK(&priv->rproc_work, imx_rproc_vq_work); 1051 1085 1052 1086 ret = imx_rproc_xtr_mbox_init(rproc, true); 1053 1087 if (ret) 1054 - goto err_put_wkq; 1088 + return ret; 1089 + 1090 + ret = devm_add_action_or_reset(dev, imx_rproc_free_mbox, rproc); 1091 + if (ret) 1092 + return dev_err_probe(dev, ret, 1093 + "Failed to add devm free mbox action: %d\n", ret); 1055 1094 1056 1095 ret = imx_rproc_addr_init(priv, pdev); 1057 - if (ret) { 1058 - dev_err(dev, "failed on imx_rproc_addr_init\n"); 1059 - goto err_put_mbox; 1060 - } 1096 + if (ret) 1097 + return dev_err_probe(dev, ret, "failed on imx_rproc_addr_init\n"); 1061 1098 1062 1099 ret = imx_rproc_detect_mode(priv); 1063 1100 if (ret) 1064 - goto err_put_mbox; 1101 + return dev_err_probe(dev, ret, "failed on detect mode\n"); 1065 1102 1066 - ret = imx_rproc_clk_enable(priv); 1067 - if (ret) 1068 - goto err_put_scu; 1103 + /* 1104 + * Handle clocks when remote core is under control of Linux AND the 1105 + * clocks are not managed by system firmware. 1106 + */ 1107 + if (dcfg->flags & IMX_RPROC_NEED_CLKS) { 1108 + priv->clk = devm_clk_get_enabled(dev, NULL); 1109 + if (IS_ERR(priv->clk)) 1110 + return dev_err_probe(dev, PTR_ERR(priv->clk), "Failed to enable clock\n"); 1111 + } 1069 1112 1070 1113 if (rproc->state != RPROC_DETACHED) 1071 1114 rproc->auto_boot = of_property_read_bool(np, "fsl,auto-boot"); ··· 1093 1110 ret = devm_register_sys_off_handler(dev, SYS_OFF_MODE_POWER_OFF_PREPARE, 1094 1111 SYS_OFF_PRIO_DEFAULT, 1095 1112 imx_rproc_sys_off_handler, rproc); 1096 - if (ret) { 1097 - dev_err(dev, "register power off handler failure\n"); 1098 - goto err_put_clk; 1099 - } 1113 + if (ret) 1114 + return dev_err_probe(dev, ret, "register power off handler failure\n"); 1100 1115 1101 1116 ret = devm_register_sys_off_handler(dev, SYS_OFF_MODE_RESTART_PREPARE, 1102 1117 SYS_OFF_PRIO_DEFAULT, 1103 1118 imx_rproc_sys_off_handler, rproc); 1104 - if (ret) { 1105 - dev_err(dev, "register restart handler failure\n"); 1106 - goto err_put_clk; 1107 - } 1119 + if (ret) 1120 + return dev_err_probe(dev, ret, "register restart handler failure\n"); 1108 1121 } 1109 1122 1110 - if (dcfg->method == IMX_RPROC_SCU_API) { 1111 - pm_runtime_enable(dev); 1112 - ret = pm_runtime_resume_and_get(dev); 1113 - if (ret) { 1114 - dev_err(dev, "pm_runtime get failed: %d\n", ret); 1115 - goto err_put_clk; 1116 - } 1117 - } 1123 + pm_runtime_enable(dev); 1124 + ret = pm_runtime_resume_and_get(dev); 1125 + if (ret) 1126 + return dev_err_probe(dev, ret, "pm_runtime get failed\n"); 1118 1127 1119 - ret = rproc_add(rproc); 1128 + ret = devm_rproc_add(dev, rproc); 1120 1129 if (ret) { 1121 1130 dev_err(dev, "rproc_add failed\n"); 1122 - goto err_put_clk; 1131 + goto err_put_pm; 1123 1132 } 1124 1133 1125 1134 return 0; 1126 1135 1127 - err_put_clk: 1128 - clk_disable_unprepare(priv->clk); 1129 - err_put_scu: 1130 - imx_rproc_put_scu(rproc); 1131 - err_put_mbox: 1132 - imx_rproc_free_mbox(rproc); 1133 - err_put_wkq: 1134 - destroy_workqueue(priv->workqueue); 1136 + err_put_pm: 1137 + pm_runtime_disable(dev); 1138 + pm_runtime_put_noidle(dev); 1135 1139 1136 1140 return ret; 1137 1141 } ··· 1128 1158 struct rproc *rproc = platform_get_drvdata(pdev); 1129 1159 struct imx_rproc *priv = rproc->priv; 1130 1160 1131 - if (priv->dcfg->method == IMX_RPROC_SCU_API) { 1132 - pm_runtime_disable(priv->dev); 1133 - pm_runtime_put(priv->dev); 1134 - } 1135 - clk_disable_unprepare(priv->clk); 1136 - rproc_del(rproc); 1137 - imx_rproc_put_scu(rproc); 1138 - imx_rproc_free_mbox(rproc); 1139 - destroy_workqueue(priv->workqueue); 1161 + pm_runtime_disable(priv->dev); 1162 + pm_runtime_put_noidle(priv->dev); 1140 1163 } 1141 1164 1142 1165 static const struct imx_rproc_plat_ops imx_rproc_ops_arm_smc = { ··· 1147 1184 static const struct imx_rproc_plat_ops imx_rproc_ops_scu_api = { 1148 1185 .start = imx_rproc_scu_api_start, 1149 1186 .stop = imx_rproc_scu_api_stop, 1187 + .detach = imx_rproc_scu_api_detach, 1150 1188 .detect_mode = imx_rproc_scu_api_detect_mode, 1151 1189 }; 1152 1190 ··· 1160 1196 .gpr_wait = IMX8M_GPR22_CM7_CPUWAIT, 1161 1197 .att = imx_rproc_att_imx8mn, 1162 1198 .att_size = ARRAY_SIZE(imx_rproc_att_imx8mn), 1163 - .method = IMX_RPROC_MMIO, 1164 1199 .ops = &imx_rproc_ops_mmio, 1200 + .flags = IMX_RPROC_NEED_CLKS, 1165 1201 }; 1166 1202 1167 1203 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8mn = { 1168 1204 .att = imx_rproc_att_imx8mn, 1169 1205 .att_size = ARRAY_SIZE(imx_rproc_att_imx8mn), 1170 - .method = IMX_RPROC_SMC, 1171 1206 .ops = &imx_rproc_ops_arm_smc, 1207 + .flags = IMX_RPROC_NEED_CLKS, 1172 1208 }; 1173 1209 1174 1210 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8mq = { ··· 1178 1214 .src_stop = IMX7D_M4_STOP, 1179 1215 .att = imx_rproc_att_imx8mq, 1180 1216 .att_size = ARRAY_SIZE(imx_rproc_att_imx8mq), 1181 - .method = IMX_RPROC_MMIO, 1182 1217 .ops = &imx_rproc_ops_mmio, 1218 + .flags = IMX_RPROC_NEED_CLKS, 1183 1219 }; 1184 1220 1185 1221 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8qm = { 1186 1222 .att = imx_rproc_att_imx8qm, 1187 1223 .att_size = ARRAY_SIZE(imx_rproc_att_imx8qm), 1188 - .method = IMX_RPROC_SCU_API, 1189 1224 .ops = &imx_rproc_ops_scu_api, 1190 1225 }; 1191 1226 1192 1227 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8qxp = { 1193 1228 .att = imx_rproc_att_imx8qxp, 1194 1229 .att_size = ARRAY_SIZE(imx_rproc_att_imx8qxp), 1195 - .method = IMX_RPROC_SCU_API, 1196 1230 .ops = &imx_rproc_ops_scu_api, 1197 1231 }; 1198 1232 1199 1233 static const struct imx_rproc_dcfg imx_rproc_cfg_imx8ulp = { 1200 1234 .att = imx_rproc_att_imx8ulp, 1201 1235 .att_size = ARRAY_SIZE(imx_rproc_att_imx8ulp), 1202 - .method = IMX_RPROC_NONE, 1203 1236 }; 1204 1237 1205 1238 static const struct imx_rproc_dcfg imx_rproc_cfg_imx7ulp = { 1206 1239 .att = imx_rproc_att_imx7ulp, 1207 1240 .att_size = ARRAY_SIZE(imx_rproc_att_imx7ulp), 1208 - .method = IMX_RPROC_NONE, 1209 1241 .flags = IMX_RPROC_NEED_SYSTEM_OFF, 1210 1242 }; 1211 1243 ··· 1212 1252 .src_stop = IMX7D_M4_STOP, 1213 1253 .att = imx_rproc_att_imx7d, 1214 1254 .att_size = ARRAY_SIZE(imx_rproc_att_imx7d), 1215 - .method = IMX_RPROC_MMIO, 1216 1255 .ops = &imx_rproc_ops_mmio, 1256 + .flags = IMX_RPROC_NEED_CLKS, 1217 1257 }; 1218 1258 1219 1259 static const struct imx_rproc_dcfg imx_rproc_cfg_imx6sx = { ··· 1223 1263 .src_stop = IMX6SX_M4_STOP, 1224 1264 .att = imx_rproc_att_imx6sx, 1225 1265 .att_size = ARRAY_SIZE(imx_rproc_att_imx6sx), 1226 - .method = IMX_RPROC_MMIO, 1227 1266 .ops = &imx_rproc_ops_mmio, 1267 + .flags = IMX_RPROC_NEED_CLKS, 1228 1268 }; 1229 1269 1230 1270 static const struct imx_rproc_dcfg imx_rproc_cfg_imx93 = { 1231 1271 .att = imx_rproc_att_imx93, 1232 1272 .att_size = ARRAY_SIZE(imx_rproc_att_imx93), 1233 - .method = IMX_RPROC_SMC, 1234 1273 .ops = &imx_rproc_ops_arm_smc, 1274 + .flags = IMX_RPROC_NEED_CLKS, 1235 1275 }; 1236 1276 1237 1277 static const struct of_device_id imx_rproc_of_match[] = {

+2 -14

drivers/remoteproc/imx_rproc.h

··· 15 15 int flags; 16 16 }; 17 17 18 - /* Remote core start/stop method */ 19 - enum imx_rproc_method { 20 - IMX_RPROC_NONE, 21 - /* Through syscon regmap */ 22 - IMX_RPROC_MMIO, 23 - /* Through ARM SMCCC */ 24 - IMX_RPROC_SMC, 25 - /* Through System Control Unit API */ 26 - IMX_RPROC_SCU_API, 27 - /* Through Reset Controller API */ 28 - IMX_RPROC_RESET_CONTROLLER, 29 - }; 30 - 31 18 /* dcfg flags */ 32 19 #define IMX_RPROC_NEED_SYSTEM_OFF BIT(0) 20 + #define IMX_RPROC_NEED_CLKS BIT(1) 33 21 34 22 struct imx_rproc_plat_ops { 35 23 int (*start)(struct rproc *rproc); 36 24 int (*stop)(struct rproc *rproc); 25 + int (*detach)(struct rproc *rproc); 37 26 int (*detect_mode)(struct rproc *rproc); 38 27 }; 39 28 ··· 35 46 u32 gpr_wait; 36 47 const struct imx_rproc_att *att; 37 48 size_t att_size; 38 - enum imx_rproc_method method; 39 49 u32 flags; 40 50 const struct imx_rproc_plat_ops *ops; 41 51 };

+59 -6

drivers/remoteproc/mtk_scp.c

··· 16 16 #include <linux/remoteproc.h> 17 17 #include <linux/remoteproc/mtk_scp.h> 18 18 #include <linux/rpmsg/mtk_rpmsg.h> 19 + #include <linux/string.h> 19 20 20 21 #include "mtk_common.h" 21 22 #include "remoteproc_internal.h" ··· 1094 1093 } 1095 1094 } 1096 1095 1096 + /** 1097 + * scp_get_default_fw_path() - Get default SCP firmware path 1098 + * @dev: SCP Device 1099 + * @core_id: SCP Core number 1100 + * 1101 + * This function generates a path based on the following format: 1102 + * mediatek/(soc_model)/scp(_cX).img; for multi-core or 1103 + * mediatek/(soc_model)/scp.img for single core SCP HW 1104 + * 1105 + * Return: A devm allocated string containing the full path to 1106 + * a SCP firmware or an error pointer 1107 + */ 1108 + static const char *scp_get_default_fw_path(struct device *dev, int core_id) 1109 + { 1110 + struct device_node *np = core_id < 0 ? dev->of_node : dev->parent->of_node; 1111 + const char *compatible, *soc; 1112 + char scp_fw_file[7]; 1113 + int ret; 1114 + 1115 + /* Use only the first compatible string */ 1116 + ret = of_property_read_string_index(np, "compatible", 0, &compatible); 1117 + if (ret) 1118 + return ERR_PTR(ret); 1119 + 1120 + /* If the compatible string's length is implausible bail out early */ 1121 + if (strlen(compatible) < strlen("mediatek,mtXXXX-scp")) 1122 + return ERR_PTR(-EINVAL); 1123 + 1124 + /* If the compatible string starts with "mediatek,mt" assume that it's ok */ 1125 + if (!str_has_prefix(compatible, "mediatek,mt")) 1126 + return ERR_PTR(-EINVAL); 1127 + 1128 + if (core_id >= 0) 1129 + ret = snprintf(scp_fw_file, sizeof(scp_fw_file), "scp_c%d", core_id); 1130 + else 1131 + ret = snprintf(scp_fw_file, sizeof(scp_fw_file), "scp"); 1132 + if (ret >= sizeof(scp_fw_file)) 1133 + return ERR_PTR(-ENAMETOOLONG); 1134 + 1135 + /* Not using strchr here, as strlen of a const gets optimized by compiler */ 1136 + soc = &compatible[strlen("mediatek,")]; 1137 + 1138 + return devm_kasprintf(dev, GFP_KERNEL, "mediatek/%.*s/%s.img", 1139 + (int)strlen("mtXXXX"), soc, scp_fw_file); 1140 + } 1141 + 1097 1142 static struct mtk_scp *scp_rproc_init(struct platform_device *pdev, 1098 1143 struct mtk_scp_of_cluster *scp_cluster, 1099 - const struct mtk_scp_of_data *of_data) 1144 + const struct mtk_scp_of_data *of_data, 1145 + int core_id) 1100 1146 { 1101 1147 struct device *dev = &pdev->dev; 1102 1148 struct device_node *np = dev->of_node; 1103 1149 struct mtk_scp *scp; 1104 1150 struct rproc *rproc; 1105 1151 struct resource *res; 1106 - const char *fw_name = "scp.img"; 1152 + const char *fw_name; 1107 1153 int ret, i; 1108 1154 const struct mtk_scp_sizes_data *scp_sizes; 1109 1155 1110 1156 ret = rproc_of_parse_firmware(dev, 0, &fw_name); 1111 - if (ret < 0 && ret != -EINVAL) 1112 - return ERR_PTR(ret); 1157 + if (ret) { 1158 + fw_name = scp_get_default_fw_path(dev, core_id); 1159 + if (IS_ERR(fw_name)) { 1160 + dev_err(dev, "Cannot get firmware path: %ld\n", PTR_ERR(fw_name)); 1161 + return ERR_CAST(fw_name); 1162 + } 1163 + } 1113 1164 1114 1165 rproc = devm_rproc_alloc(dev, np->name, &scp_ops, fw_name, sizeof(*scp)); 1115 1166 if (!rproc) { ··· 1265 1212 struct mtk_scp *scp; 1266 1213 int ret; 1267 1214 1268 - scp = scp_rproc_init(pdev, scp_cluster, of_device_get_match_data(dev)); 1215 + scp = scp_rproc_init(pdev, scp_cluster, of_device_get_match_data(dev), -1); 1269 1216 if (IS_ERR(scp)) 1270 1217 return PTR_ERR(scp); 1271 1218 ··· 1312 1259 goto init_fail; 1313 1260 } 1314 1261 1315 - scp = scp_rproc_init(cpdev, scp_cluster, cluster_of_data[core_id]); 1262 + scp = scp_rproc_init(cpdev, scp_cluster, cluster_of_data[core_id], core_id); 1316 1263 put_device(&cpdev->dev); 1317 1264 if (IS_ERR(scp)) { 1318 1265 ret = PTR_ERR(scp);

-3

drivers/remoteproc/omap_remoteproc.c

··· 555 555 dev_err(dev, "failed to send mailbox message, status = %d\n", 556 556 ret); 557 557 558 - pm_runtime_mark_last_busy(dev); 559 558 pm_runtime_put_autosuspend(dev); 560 559 } 561 560 ··· 655 656 pm_runtime_use_autosuspend(dev); 656 657 pm_runtime_get_noresume(dev); 657 658 pm_runtime_enable(dev); 658 - pm_runtime_mark_last_busy(dev); 659 659 pm_runtime_put_autosuspend(dev); 660 660 661 661 return 0; ··· 712 714 reset_control_deassert(oproc->reset); 713 715 out: 714 716 /* schedule the next auto-suspend */ 715 - pm_runtime_mark_last_busy(dev); 716 717 pm_runtime_put_autosuspend(dev); 717 718 return ret; 718 719 }

+12 -17

drivers/remoteproc/qcom_q6v5_adsp.c

··· 625 625 626 626 static int adsp_alloc_memory_region(struct qcom_adsp *adsp) 627 627 { 628 - struct reserved_mem *rmem = NULL; 629 - struct device_node *node; 628 + int ret; 629 + struct resource res; 630 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) { 631 + ret = of_reserved_mem_region_to_resource(adsp->dev->of_node, 0, &res); 632 + if (ret) { 637 633 dev_err(adsp->dev, "unable to resolve memory-region\n"); 638 - return -EINVAL; 634 + return ret; 639 635 } 640 636 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; 637 + adsp->mem_phys = adsp->mem_reloc = res.start; 638 + adsp->mem_size = resource_size(&res); 639 + adsp->mem_region = devm_ioremap_resource_wc(adsp->dev, &res); 640 + if (IS_ERR(adsp->mem_region)) { 641 + dev_err(adsp->dev, "unable to map memory region: %pR\n", &res); 642 + return PTR_ERR(adsp->mem_region); 643 + 649 644 } 650 645 651 646 return 0;

+19 -41

drivers/remoteproc/qcom_q6v5_mss.c

··· 1970 1970 static int q6v5_alloc_memory_region(struct q6v5 *qproc) 1971 1971 { 1972 1972 struct device_node *child; 1973 - struct reserved_mem *rmem; 1974 - struct device_node *node; 1973 + struct resource res; 1974 + int ret; 1975 1975 1976 1976 /* 1977 1977 * In the absence of mba/mpss sub-child, extract the mba and mpss ··· 1979 1979 */ 1980 1980 child = of_get_child_by_name(qproc->dev->of_node, "mba"); 1981 1981 if (!child) { 1982 - node = of_parse_phandle(qproc->dev->of_node, 1983 - "memory-region", 0); 1982 + ret = of_reserved_mem_region_to_resource(qproc->dev->of_node, 0, &res); 1984 1983 } else { 1985 - node = of_parse_phandle(child, "memory-region", 0); 1984 + ret = of_reserved_mem_region_to_resource(child, 0, &res); 1986 1985 of_node_put(child); 1987 1986 } 1988 1987 1989 - if (!node) { 1990 - dev_err(qproc->dev, "no mba memory-region specified\n"); 1991 - return -EINVAL; 1992 - } 1993 - 1994 - rmem = of_reserved_mem_lookup(node); 1995 - of_node_put(node); 1996 - if (!rmem) { 1988 + if (ret) { 1997 1989 dev_err(qproc->dev, "unable to resolve mba region\n"); 1998 - return -EINVAL; 1990 + return ret; 1999 1991 } 2000 1992 2001 - qproc->mba_phys = rmem->base; 2002 - qproc->mba_size = rmem->size; 1993 + qproc->mba_phys = res.start; 1994 + qproc->mba_size = resource_size(&res); 2003 1995 2004 1996 if (!child) { 2005 - node = of_parse_phandle(qproc->dev->of_node, 2006 - "memory-region", 1); 1997 + ret = of_reserved_mem_region_to_resource(qproc->dev->of_node, 1, &res); 2007 1998 } else { 2008 1999 child = of_get_child_by_name(qproc->dev->of_node, "mpss"); 2009 - node = of_parse_phandle(child, "memory-region", 0); 2000 + ret = of_reserved_mem_region_to_resource(child, 0, &res); 2010 2001 of_node_put(child); 2011 2002 } 2012 2003 2013 - if (!node) { 2014 - dev_err(qproc->dev, "no mpss memory-region specified\n"); 2015 - return -EINVAL; 2016 - } 2017 - 2018 - rmem = of_reserved_mem_lookup(node); 2019 - of_node_put(node); 2020 - if (!rmem) { 2004 + if (ret) { 2021 2005 dev_err(qproc->dev, "unable to resolve mpss region\n"); 2022 - return -EINVAL; 2006 + return ret; 2023 2007 } 2024 2008 2025 - qproc->mpss_phys = qproc->mpss_reloc = rmem->base; 2026 - qproc->mpss_size = rmem->size; 2009 + qproc->mpss_phys = qproc->mpss_reloc = res.start; 2010 + qproc->mpss_size = resource_size(&res); 2027 2011 2028 2012 if (!child) { 2029 - node = of_parse_phandle(qproc->dev->of_node, "memory-region", 2); 2013 + ret = of_reserved_mem_region_to_resource(qproc->dev->of_node, 2, &res); 2030 2014 } else { 2031 2015 child = of_get_child_by_name(qproc->dev->of_node, "metadata"); 2032 - node = of_parse_phandle(child, "memory-region", 0); 2016 + ret = of_reserved_mem_region_to_resource(child, 0, &res); 2033 2017 of_node_put(child); 2034 2018 } 2035 2019 2036 - if (!node) 2020 + if (ret) 2037 2021 return 0; 2038 2022 2039 - rmem = of_reserved_mem_lookup(node); 2040 - if (!rmem) { 2041 - dev_err(qproc->dev, "unable to resolve metadata region\n"); 2042 - return -EINVAL; 2043 - } 2044 - 2045 - qproc->mdata_phys = rmem->base; 2046 - qproc->mdata_size = rmem->size; 2023 + qproc->mdata_phys = res.start; 2024 + qproc->mdata_size = resource_size(&res); 2047 2025 2048 2026 return 0; 2049 2027 }

+30 -48

drivers/remoteproc/qcom_q6v5_pas.c

··· 547 547 548 548 static int qcom_pas_alloc_memory_region(struct qcom_pas *pas) 549 549 { 550 - struct reserved_mem *rmem; 551 - struct device_node *node; 550 + struct resource res; 551 + int ret; 552 552 553 - node = of_parse_phandle(pas->dev->of_node, "memory-region", 0); 554 - if (!node) { 555 - dev_err(pas->dev, "no memory-region specified\n"); 556 - return -EINVAL; 557 - } 558 - 559 - rmem = of_reserved_mem_lookup(node); 560 - of_node_put(node); 561 - if (!rmem) { 553 + ret = of_reserved_mem_region_to_resource(pas->dev->of_node, 0, &res); 554 + if (ret) { 562 555 dev_err(pas->dev, "unable to resolve memory-region\n"); 563 - return -EINVAL; 556 + return ret; 564 557 } 565 558 566 - pas->mem_phys = pas->mem_reloc = rmem->base; 567 - pas->mem_size = rmem->size; 568 - pas->mem_region = devm_ioremap_wc(pas->dev, pas->mem_phys, pas->mem_size); 569 - if (!pas->mem_region) { 570 - dev_err(pas->dev, "unable to map memory region: %pa+%zx\n", 571 - &rmem->base, pas->mem_size); 572 - return -EBUSY; 559 + pas->mem_phys = pas->mem_reloc = res.start; 560 + pas->mem_size = resource_size(&res); 561 + pas->mem_region = devm_ioremap_resource_wc(pas->dev, &res); 562 + if (IS_ERR(pas->mem_region)) { 563 + dev_err(pas->dev, "unable to map memory region: %pR\n", &res); 564 + return PTR_ERR(pas->mem_region); 573 565 } 574 566 575 567 if (!pas->dtb_pas_id) 576 568 return 0; 577 569 578 - node = of_parse_phandle(pas->dev->of_node, "memory-region", 1); 579 - if (!node) { 580 - dev_err(pas->dev, "no dtb memory-region specified\n"); 581 - return -EINVAL; 582 - } 583 - 584 - rmem = of_reserved_mem_lookup(node); 585 - of_node_put(node); 586 - if (!rmem) { 570 + ret = of_reserved_mem_region_to_resource(pas->dev->of_node, 1, &res); 571 + if (ret) { 587 572 dev_err(pas->dev, "unable to resolve dtb memory-region\n"); 588 - return -EINVAL; 573 + return ret; 589 574 } 590 575 591 - pas->dtb_mem_phys = pas->dtb_mem_reloc = rmem->base; 592 - pas->dtb_mem_size = rmem->size; 593 - pas->dtb_mem_region = devm_ioremap_wc(pas->dev, pas->dtb_mem_phys, pas->dtb_mem_size); 594 - if (!pas->dtb_mem_region) { 595 - dev_err(pas->dev, "unable to map dtb memory region: %pa+%zx\n", 596 - &rmem->base, pas->dtb_mem_size); 597 - return -EBUSY; 576 + pas->dtb_mem_phys = pas->dtb_mem_reloc = res.start; 577 + pas->dtb_mem_size = resource_size(&res); 578 + pas->dtb_mem_region = devm_ioremap_resource_wc(pas->dev, &res); 579 + if (IS_ERR(pas->dtb_mem_region)) { 580 + dev_err(pas->dev, "unable to map dtb memory region: %pR\n", &res); 581 + return PTR_ERR(pas->dtb_mem_region); 598 582 } 599 583 600 584 return 0; ··· 587 603 static int qcom_pas_assign_memory_region(struct qcom_pas *pas) 588 604 { 589 605 struct qcom_scm_vmperm perm[MAX_ASSIGN_COUNT]; 590 - struct device_node *node; 591 606 unsigned int perm_size; 592 607 int offset; 593 608 int ret; ··· 595 612 return 0; 596 613 597 614 for (offset = 0; offset < pas->region_assign_count; ++offset) { 598 - struct reserved_mem *rmem = NULL; 615 + struct resource res; 599 616 600 - node = of_parse_phandle(pas->dev->of_node, "memory-region", 601 - pas->region_assign_idx + offset); 602 - if (node) 603 - rmem = of_reserved_mem_lookup(node); 604 - of_node_put(node); 605 - if (!rmem) { 617 + ret = of_reserved_mem_region_to_resource(pas->dev->of_node, 618 + pas->region_assign_idx + offset, 619 + &res); 620 + if (ret) { 606 621 dev_err(pas->dev, "unable to resolve shareable memory-region index %d\n", 607 622 offset); 608 - return -EINVAL; 623 + return ret; 609 624 } 610 625 611 626 if (pas->region_assign_shared) { ··· 618 637 perm_size = 1; 619 638 } 620 639 621 - pas->region_assign_phys[offset] = rmem->base; 622 - pas->region_assign_size[offset] = rmem->size; 640 + pas->region_assign_phys[offset] = res.start; 641 + pas->region_assign_size[offset] = resource_size(&res); 623 642 pas->region_assign_owners[offset] = BIT(QCOM_SCM_VMID_HLOS); 624 643 625 644 ret = qcom_scm_assign_mem(pas->region_assign_phys[offset], ··· 1442 1461 { .compatible = "qcom,milos-wpss-pas", .data = &sc7280_wpss_resource}, 1443 1462 { .compatible = "qcom,msm8226-adsp-pil", .data = &msm8996_adsp_resource}, 1444 1463 { .compatible = "qcom,msm8953-adsp-pil", .data = &msm8996_adsp_resource}, 1445 - { .compatible = "qcom,msm8974-adsp-pil", .data = &adsp_resource_init}, 1464 + { .compatible = "qcom,msm8974-adsp-pil", .data = &msm8996_adsp_resource}, 1446 1465 { .compatible = "qcom,msm8996-adsp-pil", .data = &msm8996_adsp_resource}, 1447 1466 { .compatible = "qcom,msm8996-slpi-pil", .data = &msm8996_slpi_resource_init}, 1448 1467 { .compatible = "qcom,msm8998-adsp-pas", .data = &msm8996_adsp_resource}, ··· 1469 1488 { .compatible = "qcom,sc8280xp-nsp0-pas", .data = &sc8280xp_nsp0_resource}, 1470 1489 { .compatible = "qcom,sc8280xp-nsp1-pas", .data = &sc8280xp_nsp1_resource}, 1471 1490 { .compatible = "qcom,sdm660-adsp-pas", .data = &adsp_resource_init}, 1491 + { .compatible = "qcom,sdm660-cdsp-pas", .data = &cdsp_resource_init}, 1472 1492 { .compatible = "qcom,sdm845-adsp-pas", .data = &sdm845_adsp_resource_init}, 1473 1493 { .compatible = "qcom,sdm845-cdsp-pas", .data = &sdm845_cdsp_resource_init}, 1474 1494 { .compatible = "qcom,sdm845-slpi-pas", .data = &sdm845_slpi_resource_init},

+18 -22

drivers/remoteproc/qcom_q6v5_wcss.c

··· 85 85 #define TCSR_WCSS_CLK_MASK 0x1F 86 86 #define TCSR_WCSS_CLK_ENABLE 0x14 87 87 88 - #define MAX_HALT_REG 3 88 + #define MAX_HALT_REG 4 89 89 enum { 90 90 WCSS_IPQ8074, 91 91 WCSS_QCS404, ··· 811 811 } 812 812 } 813 813 814 - wcss->wcss_q6_bcr_reset = devm_reset_control_get_exclusive(dev, "wcss_q6_bcr_reset"); 814 + wcss->wcss_q6_bcr_reset = devm_reset_control_get_optional_exclusive(dev, 815 + "wcss_q6_bcr_reset"); 815 816 if (IS_ERR(wcss->wcss_q6_bcr_reset)) { 816 817 dev_err(wcss->dev, "unable to acquire wcss_q6_bcr_reset\n"); 817 818 return PTR_ERR(wcss->wcss_q6_bcr_reset); ··· 865 864 return -EINVAL; 866 865 } 867 866 868 - wcss->halt_q6 = halt_reg[0]; 869 - wcss->halt_wcss = halt_reg[1]; 870 - wcss->halt_nc = halt_reg[2]; 867 + wcss->halt_q6 = halt_reg[1]; 868 + wcss->halt_wcss = halt_reg[2]; 869 + wcss->halt_nc = halt_reg[3]; 871 870 872 871 return 0; 873 872 } 874 873 875 874 static int q6v5_alloc_memory_region(struct q6v5_wcss *wcss) 876 875 { 877 - struct reserved_mem *rmem = NULL; 878 - struct device_node *node; 879 876 struct device *dev = wcss->dev; 877 + struct resource res; 878 + int ret; 880 879 881 - node = of_parse_phandle(dev->of_node, "memory-region", 0); 882 - if (node) 883 - rmem = of_reserved_mem_lookup(node); 884 - of_node_put(node); 885 - 886 - if (!rmem) { 880 + ret = of_reserved_mem_region_to_resource(dev->of_node, 0, &res); 881 + if (ret) { 887 882 dev_err(dev, "unable to acquire memory-region\n"); 888 - return -EINVAL; 883 + return ret; 889 884 } 890 885 891 - wcss->mem_phys = rmem->base; 892 - wcss->mem_reloc = rmem->base; 893 - wcss->mem_size = rmem->size; 894 - wcss->mem_region = devm_ioremap_wc(dev, wcss->mem_phys, wcss->mem_size); 895 - if (!wcss->mem_region) { 896 - dev_err(dev, "unable to map memory region: %pa+%pa\n", 897 - &rmem->base, &rmem->size); 898 - return -EBUSY; 886 + wcss->mem_phys = res.start; 887 + wcss->mem_reloc = res.start; 888 + wcss->mem_size = resource_size(&res); 889 + wcss->mem_region = devm_ioremap_resource_wc(dev, &res); 890 + if (IS_ERR(wcss->mem_region)) { 891 + dev_err(dev, "unable to map memory region: %pR\n", &res); 892 + return PTR_ERR(wcss->mem_region); 899 893 } 900 894 901 895 return 0;

+11 -16

drivers/remoteproc/qcom_wcnss.c

··· 526 526 527 527 static int wcnss_alloc_memory_region(struct qcom_wcnss *wcnss) 528 528 { 529 - struct reserved_mem *rmem = NULL; 530 - struct device_node *node; 529 + struct resource res; 530 + int ret; 531 531 532 - node = of_parse_phandle(wcnss->dev->of_node, "memory-region", 0); 533 - if (node) 534 - rmem = of_reserved_mem_lookup(node); 535 - of_node_put(node); 536 - 537 - if (!rmem) { 532 + ret = of_reserved_mem_region_to_resource(wcnss->dev->of_node, 0, &res); 533 + if (ret) { 538 534 dev_err(wcnss->dev, "unable to resolve memory-region\n"); 539 - return -EINVAL; 535 + return ret; 540 536 } 541 537 542 - wcnss->mem_phys = wcnss->mem_reloc = rmem->base; 543 - wcnss->mem_size = rmem->size; 544 - wcnss->mem_region = devm_ioremap_wc(wcnss->dev, wcnss->mem_phys, wcnss->mem_size); 545 - if (!wcnss->mem_region) { 546 - dev_err(wcnss->dev, "unable to map memory region: %pa+%zx\n", 547 - &rmem->base, wcnss->mem_size); 548 - return -EBUSY; 538 + wcnss->mem_phys = wcnss->mem_reloc = res.start; 539 + wcnss->mem_size = resource_size(&res); 540 + wcnss->mem_region = devm_ioremap_resource_wc(wcnss->dev, &res); 541 + if (IS_ERR(wcnss->mem_region)) { 542 + dev_err(wcnss->dev, "unable to map memory region: %pR\n", &res); 543 + return PTR_ERR(wcnss->mem_region); 549 544 } 550 545 551 546 return 0;

+13 -23

drivers/remoteproc/rcar_rproc.c

··· 52 52 { 53 53 struct device *dev = rproc->dev.parent; 54 54 struct device_node *np = dev->of_node; 55 - struct of_phandle_iterator it; 56 55 struct rproc_mem_entry *mem; 57 - struct reserved_mem *rmem; 56 + int i = 0; 58 57 u32 da; 59 58 60 59 /* Register associated reserved memory regions */ 61 - of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); 62 - while (of_phandle_iterator_next(&it) == 0) { 60 + while (1) { 61 + struct resource res; 62 + int ret; 63 63 64 - rmem = of_reserved_mem_lookup(it.node); 65 - if (!rmem) { 66 - of_node_put(it.node); 67 - dev_err(&rproc->dev, 68 - "unable to acquire memory-region\n"); 69 - return -EINVAL; 70 - } 64 + ret = of_reserved_mem_region_to_resource(np, i++, &res); 65 + if (ret) 66 + return 0; 71 67 72 - if (rmem->base > U32_MAX) { 73 - of_node_put(it.node); 68 + if (res.start > U32_MAX) 74 69 return -EINVAL; 75 - } 76 70 77 71 /* No need to translate pa to da, R-Car use same map */ 78 - da = rmem->base; 72 + da = res.start; 79 73 mem = rproc_mem_entry_init(dev, NULL, 80 - rmem->base, 81 - rmem->size, da, 74 + res.start, 75 + resource_size(&res), da, 82 76 rcar_rproc_mem_alloc, 83 77 rcar_rproc_mem_release, 84 - it.node->name); 78 + res.name); 85 79 86 - if (!mem) { 87 - of_node_put(it.node); 80 + if (!mem) 88 81 return -ENOMEM; 89 - } 90 82 91 83 rproc_add_carveout(rproc, mem); 92 84 } 93 - 94 - return 0; 95 85 } 96 86 97 87 static int rcar_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)

+13 -18

drivers/remoteproc/remoteproc_core.c

··· 16 16 17 17 #define pr_fmt(fmt) "%s: " fmt, __func__ 18 18 19 + #include <asm/byteorder.h> 19 20 #include <linux/delay.h> 21 + #include <linux/device.h> 22 + #include <linux/dma-mapping.h> 23 + #include <linux/elf.h> 24 + #include <linux/firmware.h> 25 + #include <linux/idr.h> 26 + #include <linux/iommu.h> 20 27 #include <linux/kernel.h> 21 28 #include <linux/module.h> 22 - #include <linux/device.h> 23 - #include <linux/panic_notifier.h> 24 - #include <linux/slab.h> 25 29 #include <linux/mutex.h> 26 - #include <linux/dma-mapping.h> 27 - #include <linux/firmware.h> 28 - #include <linux/string.h> 29 - #include <linux/debugfs.h> 30 + #include <linux/of_platform.h> 31 + #include <linux/panic_notifier.h> 32 + #include <linux/platform_device.h> 30 33 #include <linux/rculist.h> 31 34 #include <linux/remoteproc.h> 32 - #include <linux/iommu.h> 33 - #include <linux/idr.h> 34 - #include <linux/elf.h> 35 - #include <linux/crc32.h> 36 - #include <linux/of_platform.h> 37 - #include <linux/of_reserved_mem.h> 38 - #include <linux/virtio_ids.h> 35 + #include <linux/slab.h> 36 + #include <linux/string.h> 39 37 #include <linux/virtio_ring.h> 40 - #include <asm/byteorder.h> 41 - #include <linux/platform_device.h> 42 38 43 39 #include "remoteproc_internal.h" 44 40 ··· 155 159 WARN_ON(!virt_addr_valid(cpu_addr)); 156 160 return virt_to_phys(cpu_addr); 157 161 } 158 - EXPORT_SYMBOL(rproc_va_to_pa); 159 162 160 163 /** 161 164 * rproc_da_to_va() - lookup the kernel virtual address for a remoteproc address ··· 1984 1989 int rproc_shutdown(struct rproc *rproc) 1985 1990 { 1986 1991 struct device *dev = &rproc->dev; 1987 - int ret = 0; 1992 + int ret; 1988 1993 1989 1994 ret = mutex_lock_interruptible(&rproc->lock); 1990 1995 if (ret) {

+20 -22

drivers/remoteproc/st_remoteproc.c

··· 120 120 struct device *dev = rproc->dev.parent; 121 121 struct device_node *np = dev->of_node; 122 122 struct rproc_mem_entry *mem; 123 - struct reserved_mem *rmem; 124 - struct of_phandle_iterator it; 125 - int index = 0; 123 + int entries; 126 124 127 - of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); 128 - while (of_phandle_iterator_next(&it) == 0) { 129 - rmem = of_reserved_mem_lookup(it.node); 130 - if (!rmem) { 131 - of_node_put(it.node); 132 - dev_err(dev, "unable to acquire memory-region\n"); 133 - return -EINVAL; 134 - } 125 + entries = of_reserved_mem_region_count(np); 126 + 127 + for (int index = 0; index < entries; index++) { 128 + struct resource res; 129 + int ret; 130 + 131 + ret = of_reserved_mem_region_to_resource(np, index, &res); 132 + if (ret) 133 + return ret; 135 134 136 135 /* No need to map vdev buffer */ 137 - if (strcmp(it.node->name, "vdev0buffer")) { 136 + if (!strstarts(res.name, "vdev0buffer")) { 138 137 /* Register memory region */ 139 138 mem = rproc_mem_entry_init(dev, NULL, 140 - (dma_addr_t)rmem->base, 141 - rmem->size, rmem->base, 139 + (dma_addr_t)res.start, 140 + resource_size(&res), res.start, 142 141 st_rproc_mem_alloc, 143 142 st_rproc_mem_release, 144 - it.node->name); 143 + "%.*s", 144 + strchrnul(res.name, '@') - res.name, 145 + res.name); 145 146 } else { 146 147 /* Register reserved memory for vdev buffer allocation */ 147 148 mem = rproc_of_resm_mem_entry_init(dev, index, 148 - rmem->size, 149 - rmem->base, 150 - it.node->name); 149 + resource_size(&res), 150 + res.start, 151 + "vdev0buffer"); 151 152 } 152 153 153 - if (!mem) { 154 - of_node_put(it.node); 154 + if (!mem) 155 155 return -ENOMEM; 156 - } 157 156 158 157 rproc_add_carveout(rproc, mem); 159 - index++; 160 158 } 161 159 162 160 return rproc_elf_load_rsc_table(rproc, fw);

+19 -27

drivers/remoteproc/stm32_rproc.c

··· 213 213 { 214 214 struct device *dev = rproc->dev.parent; 215 215 struct device_node *np = dev->of_node; 216 - struct of_phandle_iterator it; 217 216 struct rproc_mem_entry *mem; 218 - struct reserved_mem *rmem; 219 217 u64 da; 220 - int index = 0; 218 + int index = 0, mr = 0; 221 219 222 220 /* Register associated reserved memory regions */ 223 - of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); 224 - while (of_phandle_iterator_next(&it) == 0) { 225 - rmem = of_reserved_mem_lookup(it.node); 226 - if (!rmem) { 227 - of_node_put(it.node); 228 - dev_err(dev, "unable to acquire memory-region\n"); 229 - return -EINVAL; 230 - } 221 + while (1) { 222 + struct resource res; 223 + int ret; 231 224 232 - if (stm32_rproc_pa_to_da(rproc, rmem->base, &da) < 0) { 233 - of_node_put(it.node); 234 - dev_err(dev, "memory region not valid %pa\n", 235 - &rmem->base); 225 + ret = of_reserved_mem_region_to_resource(np, mr++, &res); 226 + if (ret) 227 + return 0; 228 + 229 + if (stm32_rproc_pa_to_da(rproc, res.start, &da) < 0) { 230 + dev_err(dev, "memory region not valid %pR\n", &res); 236 231 return -EINVAL; 237 232 } 238 233 239 234 /* No need to map vdev buffer */ 240 - if (strcmp(it.node->name, "vdev0buffer")) { 235 + if (!strstarts(res.name, "vdev0buffer")) { 241 236 /* Register memory region */ 242 237 mem = rproc_mem_entry_init(dev, NULL, 243 - (dma_addr_t)rmem->base, 244 - rmem->size, da, 238 + (dma_addr_t)res.start, 239 + resource_size(&res), da, 245 240 stm32_rproc_mem_alloc, 246 241 stm32_rproc_mem_release, 247 - it.node->name); 248 - 242 + "%.*s", strchrnul(res.name, '@') - res.name, 243 + res.name); 249 244 if (mem) 250 245 rproc_coredump_add_segment(rproc, da, 251 - rmem->size); 246 + resource_size(&res)); 252 247 } else { 253 248 /* Register reserved memory for vdev buffer alloc */ 254 249 mem = rproc_of_resm_mem_entry_init(dev, index, 255 - rmem->size, 256 - rmem->base, 257 - it.node->name); 250 + resource_size(&res), 251 + res.start, 252 + "vdev0buffer"); 258 253 } 259 254 260 255 if (!mem) { 261 - of_node_put(it.node); 262 256 return -ENOMEM; 263 257 } 264 258 265 259 rproc_add_carveout(rproc, mem); 266 260 index++; 267 261 } 268 - 269 - return 0; 270 262 } 271 263 272 264 static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)

+11 -17

drivers/remoteproc/ti_k3_common.c

··· 470 470 { 471 471 struct device *dev = kproc->dev; 472 472 struct device_node *np = dev->of_node; 473 - struct device_node *rmem_np; 474 - struct reserved_mem *rmem; 475 473 int num_rmems; 476 474 int ret, i; 477 475 478 - num_rmems = of_property_count_elems_of_size(np, "memory-region", 479 - sizeof(phandle)); 476 + num_rmems = of_reserved_mem_region_count(np); 480 477 if (num_rmems < 0) { 481 478 dev_err(dev, "device does not reserved memory regions (%d)\n", 482 479 num_rmems); ··· 502 505 503 506 /* use remaining reserved memory regions for static carveouts */ 504 507 for (i = 0; i < num_rmems; i++) { 505 - rmem_np = of_parse_phandle(np, "memory-region", i + 1); 506 - if (!rmem_np) 507 - return -EINVAL; 508 + struct resource res; 508 509 509 - rmem = of_reserved_mem_lookup(rmem_np); 510 - of_node_put(rmem_np); 511 - if (!rmem) 512 - return -EINVAL; 510 + ret = of_reserved_mem_region_to_resource(np, i + 1, &res); 511 + if (ret) 512 + return ret; 513 513 514 - kproc->rmem[i].bus_addr = rmem->base; 514 + kproc->rmem[i].bus_addr = res.start; 515 515 /* 64-bit address regions currently not supported */ 516 - kproc->rmem[i].dev_addr = (u32)rmem->base; 517 - kproc->rmem[i].size = rmem->size; 518 - kproc->rmem[i].cpu_addr = devm_ioremap_wc(dev, rmem->base, rmem->size); 516 + kproc->rmem[i].dev_addr = (u32)res.start; 517 + kproc->rmem[i].size = resource_size(&res); 518 + kproc->rmem[i].cpu_addr = devm_ioremap_resource_wc(dev, &res); 519 519 if (!kproc->rmem[i].cpu_addr) { 520 - dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n", 521 - i + 1, &rmem->base, &rmem->size); 520 + dev_err(dev, "failed to map reserved memory#%d at %pR\n", 521 + i + 1, &res); 522 522 return -ENOMEM; 523 523 } 524 524

+19 -34

drivers/remoteproc/xlnx_r5_remoteproc.c

··· 492 492 { 493 493 struct rproc_mem_entry *rproc_mem; 494 494 struct zynqmp_r5_core *r5_core; 495 - struct of_phandle_iterator it; 496 - struct reserved_mem *rmem; 497 495 int i = 0; 498 496 499 497 r5_core = rproc->priv; 500 498 501 499 /* Register associated reserved memory regions */ 502 - of_phandle_iterator_init(&it, r5_core->np, "memory-region", NULL, 0); 500 + while (1) { 501 + int err; 502 + struct resource res; 503 503 504 - while (of_phandle_iterator_next(&it) == 0) { 505 - rmem = of_reserved_mem_lookup(it.node); 506 - if (!rmem) { 507 - of_node_put(it.node); 508 - dev_err(&rproc->dev, "unable to acquire memory-region\n"); 509 - return -EINVAL; 510 - } 504 + err = of_reserved_mem_region_to_resource(r5_core->np, i, &res); 505 + if (err) 506 + return 0; 511 507 512 - if (!strcmp(it.node->name, "vdev0buffer")) { 508 + if (strstarts(res.name, "vdev0buffer")) { 513 509 /* Init reserved memory for vdev buffer */ 514 510 rproc_mem = rproc_of_resm_mem_entry_init(&rproc->dev, i, 515 - rmem->size, 516 - rmem->base, 517 - it.node->name); 511 + resource_size(&res), 512 + res.start, 513 + "vdev0buffer"); 518 514 } else { 519 515 /* Register associated reserved memory regions */ 520 516 rproc_mem = rproc_mem_entry_init(&rproc->dev, NULL, 521 - (dma_addr_t)rmem->base, 522 - rmem->size, rmem->base, 517 + (dma_addr_t)res.start, 518 + resource_size(&res), res.start, 523 519 zynqmp_r5_mem_region_map, 524 520 zynqmp_r5_mem_region_unmap, 525 - it.node->name); 521 + "%.*s", 522 + strchrnul(res.name, '@') - res.name, 523 + res.name); 526 524 } 527 525 528 - if (!rproc_mem) { 529 - of_node_put(it.node); 526 + if (!rproc_mem) 530 527 return -ENOMEM; 531 - } 532 528 533 529 rproc_add_carveout(rproc, rproc_mem); 534 - rproc_coredump_add_segment(rproc, rmem->base, rmem->size); 530 + rproc_coredump_add_segment(rproc, res.start, resource_size(&res)); 535 531 536 - dev_dbg(&rproc->dev, "reserved mem carveout %s addr=%llx, size=0x%llx", 537 - it.node->name, rmem->base, rmem->size); 532 + dev_dbg(&rproc->dev, "reserved mem carveout %pR\n", &res); 538 533 i++; 539 534 } 540 - 541 - return 0; 542 535 } 543 536 544 537 static int add_sram_carveouts(struct rproc *rproc) ··· 801 808 struct device *dev = r5_core->dev; 802 809 struct rsc_tbl_data *rsc_data_va; 803 810 struct resource res_mem; 804 - struct device_node *np; 805 811 int ret; 806 812 807 813 /* ··· 810 818 * contains that data structure which holds resource table address, size 811 819 * and some magic number to validate correct resource table entry. 812 820 */ 813 - np = of_parse_phandle(r5_core->np, "memory-region", 0); 814 - if (!np) { 815 - dev_err(dev, "failed to get memory region dev node\n"); 816 - return -EINVAL; 817 - } 818 - 819 - ret = of_address_to_resource(np, 0, &res_mem); 820 - of_node_put(np); 821 + ret = of_reserved_mem_region_to_resource(r5_core->np, 0, &res_mem); 821 822 if (ret) { 822 823 dev_err(dev, "failed to get memory-region resource addr\n"); 823 824 return -EINVAL;

Configure Feed

Configure Feed