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.9' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux

Pull remoteproc updates from Bjorn Andersson:
"Qualcomm SM8650 audio, compute and modem remoteproc are added.
Qualcomm X1 Elite audio and compute remoteprocs are added, after
support for shutting down the bootloader-loaded firmware loaded into
the audio DSP..

A dozen drivers in the subsystem are transitioned to use devres
helpers for remoteproc and memory allocations - this makes it possible
to acquire in-kernel handle to individual remoteproc instances in a
cluster.

The release of DMA memory for remoteproc virtio is corrected to ensure
that restarting due to a watchdog bite doesn't attempt to allocate the
memory again without first freeing it.

Last, but not least, a couple of DeviceTree binding cleanups"

* tag 'rproc-v6.9' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux: (30 commits)
remoteproc: qcom_q6v5_pas: Unload lite firmware on ADSP
remoteproc: qcom_q6v5_pas: Add support for X1E80100 ADSP/CDSP
dt-bindings: remoteproc: qcom,sm8550-pas: document the X1E80100 aDSP & cDSP
remoteproc: qcom_wcnss: Use devm_rproc_alloc() helper
remoteproc: qcom_q6v5_wcss: Use devm_rproc_alloc() helper
remoteproc: qcom_q6v5_pas: Use devm_rproc_alloc() helper
remoteproc: qcom_q6v5_mss: Use devm_rproc_alloc() helper
remoteproc: qcom_q6v5_adsp: Use devm_rproc_alloc() helper
dt-bindings: remoteproc: do not override firmware-name $ref
dt-bindings: remoteproc: qcom,glink-rpm-edge: drop redundant type from label
remoteproc: qcom: pas: correct data indentation
remoteproc: Make rproc_get_by_phandle() work for clusters
remoteproc: qcom: pas: Add SM8650 remoteproc support
remoteproc: qcom: pas: make region assign more generic
dt-bindings: remoteproc: qcom,sm8550-pas: document the SM8650 PAS
remoteproc: k3-dsp: Use devm_rproc_add() helper
remoteproc: k3-dsp: Use devm_ioremap_wc() helper
remoteproc: k3-dsp: Add devm action to release tsp
remoteproc: k3-dsp: Use devm_kzalloc() helper
remoteproc: k3-dsp: Use devm_ti_sci_get_by_phandle() helper
...

Linus Torvalds 0e875ee5 ebc9bee8

+419 -309
+2 -2
Documentation/devicetree/bindings/remoteproc/mtk,scp.yaml
··· 47 47 maxItems: 1 48 48 49 49 firmware-name: 50 - $ref: /schemas/types.yaml#/definitions/string 50 + maxItems: 1 51 51 description: 52 52 If present, name (or relative path) of the file within the 53 53 firmware search path containing the firmware image used when ··· 115 115 maxItems: 1 116 116 117 117 firmware-name: 118 - $ref: /schemas/types.yaml#/definitions/string 118 + maxItems: 1 119 119 description: 120 120 If present, name (or relative path) of the file within the 121 121 firmware search path containing the firmware image used when
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,qcs404-pas.yaml
··· 46 46 description: Reference to the reserved-memory for the Hexagon core 47 47 48 48 firmware-name: 49 - $ref: /schemas/types.yaml#/definitions/string 49 + maxItems: 1 50 50 description: Firmware name for the Hexagon core 51 51 52 52 required:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sc7180-pas.yaml
··· 45 45 smd-edge: false 46 46 47 47 firmware-name: 48 - $ref: /schemas/types.yaml#/definitions/string 48 + maxItems: 1 49 49 description: Firmware name for the Hexagon core 50 50 51 51 required:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sc7280-wpss-pil.yaml
··· 80 80 description: Reference to the reserved-memory for the Hexagon core 81 81 82 82 firmware-name: 83 - $ref: /schemas/types.yaml#/definitions/string 83 + maxItems: 1 84 84 description: 85 85 The name of the firmware which should be loaded for this remote 86 86 processor.
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sc8180x-pas.yaml
··· 42 42 description: Reference to the reserved-memory for the Hexagon core 43 43 44 44 firmware-name: 45 - $ref: /schemas/types.yaml#/definitions/string 45 + maxItems: 1 46 46 description: Firmware name for the Hexagon core 47 47 48 48 required:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sm6115-pas.yaml
··· 47 47 smd-edge: false 48 48 49 49 firmware-name: 50 - $ref: /schemas/types.yaml#/definitions/string 50 + maxItems: 1 51 51 description: Firmware name for the Hexagon core 52 52 53 53 required:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sm6350-pas.yaml
··· 42 42 smd-edge: false 43 43 44 44 firmware-name: 45 - $ref: /schemas/types.yaml#/definitions/string 45 + maxItems: 1 46 46 description: Firmware name for the Hexagon core 47 47 48 48 required:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sm6375-pas.yaml
··· 36 36 description: Reference to the reserved-memory for the Hexagon core 37 37 38 38 firmware-name: 39 - $ref: /schemas/types.yaml#/definitions/string 39 + maxItems: 1 40 40 description: Firmware name for the Hexagon core 41 41 42 42 smd-edge: false
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sm8150-pas.yaml
··· 46 46 smd-edge: false 47 47 48 48 firmware-name: 49 - $ref: /schemas/types.yaml#/definitions/string 49 + maxItems: 1 50 50 description: Firmware name for the Hexagon core 51 51 52 52 required:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,sm8350-pas.yaml
··· 47 47 description: Reference to the reserved-memory for the Hexagon core 48 48 49 49 firmware-name: 50 - $ref: /schemas/types.yaml#/definitions/string 50 + maxItems: 1 51 51 description: Firmware name for the Hexagon core 52 52 53 53 required:
+50 -1
Documentation/devicetree/bindings/remoteproc/qcom,sm8550-pas.yaml
··· 19 19 - qcom,sm8550-adsp-pas 20 20 - qcom,sm8550-cdsp-pas 21 21 - qcom,sm8550-mpss-pas 22 + - qcom,sm8650-adsp-pas 23 + - qcom,sm8650-cdsp-pas 24 + - qcom,sm8650-mpss-pas 25 + - qcom,x1e80100-adsp-pas 26 + - qcom,x1e80100-cdsp-pas 22 27 23 28 reg: 24 29 maxItems: 1 ··· 54 49 - description: Memory region for main Firmware authentication 55 50 - description: Memory region for Devicetree Firmware authentication 56 51 - description: DSM Memory region 52 + - description: DSM Memory region 2 53 + - description: Memory region for Qlink Logging 57 54 58 55 required: 59 56 - compatible ··· 70 63 enum: 71 64 - qcom,sm8550-adsp-pas 72 65 - qcom,sm8550-cdsp-pas 66 + - qcom,sm8650-adsp-pas 67 + - qcom,x1e80100-adsp-pas 68 + - qcom,x1e80100-cdsp-pas 73 69 then: 74 70 properties: 75 71 interrupts: ··· 81 71 maxItems: 5 82 72 memory-region: 83 73 maxItems: 2 84 - else: 74 + - if: 75 + properties: 76 + compatible: 77 + enum: 78 + - qcom,sm8650-cdsp-pas 79 + then: 80 + properties: 81 + interrupts: 82 + maxItems: 5 83 + interrupt-names: 84 + maxItems: 5 85 + memory-region: 86 + minItems: 3 87 + maxItems: 3 88 + - if: 89 + properties: 90 + compatible: 91 + enum: 92 + - qcom,sm8550-mpss-pas 93 + then: 85 94 properties: 86 95 interrupts: 87 96 minItems: 6 ··· 108 79 minItems: 6 109 80 memory-region: 110 81 minItems: 3 82 + maxItems: 3 83 + - if: 84 + properties: 85 + compatible: 86 + enum: 87 + - qcom,sm8650-mpss-pas 88 + then: 89 + properties: 90 + interrupts: 91 + minItems: 6 92 + interrupt-names: 93 + minItems: 6 94 + memory-region: 95 + minItems: 5 96 + maxItems: 5 111 97 112 98 - if: 113 99 properties: 114 100 compatible: 115 101 enum: 116 102 - qcom,sm8550-adsp-pas 103 + - qcom,sm8650-adsp-pas 104 + - qcom,x1e80100-adsp-pas 117 105 then: 118 106 properties: 119 107 power-domains: ··· 147 101 compatible: 148 102 enum: 149 103 - qcom,sm8550-mpss-pas 104 + - qcom,sm8650-mpss-pas 150 105 then: 151 106 properties: 152 107 power-domains: ··· 163 116 compatible: 164 117 enum: 165 118 - qcom,sm8550-cdsp-pas 119 + - qcom,sm8650-cdsp-pas 120 + - qcom,x1e80100-cdsp-pas 166 121 then: 167 122 properties: 168 123 power-domains:
+1 -1
Documentation/devicetree/bindings/remoteproc/qcom,wcnss-pil.yaml
··· 51 51 - const: stop-ack 52 52 53 53 firmware-name: 54 - $ref: /schemas/types.yaml#/definitions/string 54 + maxItems: 1 55 55 description: 56 56 Relative firmware image path for the WCNSS core. Defaults to 57 57 "wcnss.mdt".
+4 -7
drivers/remoteproc/imx_dsp_rproc.c
··· 1040 1040 return ret; 1041 1041 } 1042 1042 1043 - rproc = rproc_alloc(dev, "imx-dsp-rproc", &imx_dsp_rproc_ops, fw_name, 1044 - sizeof(*priv)); 1043 + rproc = devm_rproc_alloc(dev, "imx-dsp-rproc", &imx_dsp_rproc_ops, 1044 + fw_name, sizeof(*priv)); 1045 1045 if (!rproc) 1046 1046 return -ENOMEM; 1047 1047 ··· 1061 1061 ret = imx_dsp_rproc_detect_mode(priv); 1062 1062 if (ret) { 1063 1063 dev_err(dev, "failed on imx_dsp_rproc_detect_mode\n"); 1064 - goto err_put_rproc; 1064 + return ret; 1065 1065 } 1066 1066 1067 1067 /* There are multiple power domains required by DSP on some platform */ 1068 1068 ret = imx_dsp_attach_pm_domains(priv); 1069 1069 if (ret) { 1070 1070 dev_err(dev, "failed on imx_dsp_attach_pm_domains\n"); 1071 - goto err_put_rproc; 1071 + return ret; 1072 1072 } 1073 1073 /* Get clocks */ 1074 1074 ret = imx_dsp_rproc_clk_get(priv); ··· 1091 1091 1092 1092 err_detach_domains: 1093 1093 dev_pm_domain_detach_list(priv->pd_list); 1094 - err_put_rproc: 1095 - rproc_free(rproc); 1096 1094 1097 1095 return ret; 1098 1096 } ··· 1103 1105 pm_runtime_disable(&pdev->dev); 1104 1106 rproc_del(rproc); 1105 1107 dev_pm_domain_detach_list(priv->pd_list); 1106 - rproc_free(rproc); 1107 1108 } 1108 1109 1109 1110 /* pm runtime functions */
+5 -11
drivers/remoteproc/imx_rproc.c
··· 1049 1049 int ret; 1050 1050 1051 1051 /* set some other name then imx */ 1052 - rproc = rproc_alloc(dev, "imx-rproc", &imx_rproc_ops, 1053 - NULL, sizeof(*priv)); 1052 + rproc = devm_rproc_alloc(dev, "imx-rproc", &imx_rproc_ops, 1053 + NULL, sizeof(*priv)); 1054 1054 if (!rproc) 1055 1055 return -ENOMEM; 1056 1056 1057 1057 dcfg = of_device_get_match_data(dev); 1058 - if (!dcfg) { 1059 - ret = -EINVAL; 1060 - goto err_put_rproc; 1061 - } 1058 + if (!dcfg) 1059 + return -EINVAL; 1062 1060 1063 1061 priv = rproc->priv; 1064 1062 priv->rproc = rproc; ··· 1067 1069 priv->workqueue = create_workqueue(dev_name(dev)); 1068 1070 if (!priv->workqueue) { 1069 1071 dev_err(dev, "cannot create workqueue\n"); 1070 - ret = -ENOMEM; 1071 - goto err_put_rproc; 1072 + return -ENOMEM; 1072 1073 } 1073 1074 1074 1075 ret = imx_rproc_xtr_mbox_init(rproc); ··· 1109 1112 imx_rproc_free_mbox(rproc); 1110 1113 err_put_wkq: 1111 1114 destroy_workqueue(priv->workqueue); 1112 - err_put_rproc: 1113 - rproc_free(rproc); 1114 1115 1115 1116 return ret; 1116 1117 } ··· 1123 1128 imx_rproc_put_scu(rproc); 1124 1129 imx_rproc_free_mbox(rproc); 1125 1130 destroy_workqueue(priv->workqueue); 1126 - rproc_free(rproc); 1127 1131 } 1128 1132 1129 1133 static const struct of_device_id imx_rproc_of_match[] = {
+5 -9
drivers/remoteproc/qcom_q6v5_adsp.c
··· 674 674 return ret; 675 675 } 676 676 677 - rproc = rproc_alloc(&pdev->dev, pdev->name, &adsp_ops, 678 - firmware_name, sizeof(*adsp)); 677 + rproc = devm_rproc_alloc(&pdev->dev, pdev->name, &adsp_ops, 678 + firmware_name, sizeof(*adsp)); 679 679 if (!rproc) { 680 680 dev_err(&pdev->dev, "unable to allocate remoteproc\n"); 681 681 return -ENOMEM; ··· 700 700 701 701 ret = adsp_alloc_memory_region(adsp); 702 702 if (ret) 703 - goto free_rproc; 703 + return ret; 704 704 705 705 ret = adsp_init_clock(adsp, desc->clk_ids); 706 706 if (ret) 707 - goto free_rproc; 707 + return ret; 708 708 709 709 ret = qcom_rproc_pds_attach(adsp, desc->pd_names, desc->num_pds); 710 710 if (ret < 0) { 711 711 dev_err(&pdev->dev, "Failed to attach proxy power domains\n"); 712 - goto free_rproc; 712 + return ret; 713 713 } 714 714 715 715 ret = adsp_init_reset(adsp); ··· 744 744 disable_pm: 745 745 qcom_rproc_pds_detach(adsp); 746 746 747 - free_rproc: 748 - rproc_free(rproc); 749 - 750 747 return ret; 751 748 } 752 749 ··· 758 761 qcom_remove_sysmon_subdev(adsp->sysmon); 759 762 qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev); 760 763 qcom_rproc_pds_detach(adsp); 761 - rproc_free(adsp->rproc); 762 764 } 763 765 764 766 static const struct adsp_pil_data adsp_resource_init = {
+12 -16
drivers/remoteproc/qcom_q6v5_mss.c
··· 1990 1990 return ret; 1991 1991 } 1992 1992 1993 - rproc = rproc_alloc(&pdev->dev, pdev->name, &q6v5_ops, 1994 - mba_image, sizeof(*qproc)); 1993 + rproc = devm_rproc_alloc(&pdev->dev, pdev->name, &q6v5_ops, 1994 + mba_image, sizeof(*qproc)); 1995 1995 if (!rproc) { 1996 1996 dev_err(&pdev->dev, "failed to allocate rproc\n"); 1997 1997 return -ENOMEM; ··· 2008 2008 1, &qproc->hexagon_mdt_image); 2009 2009 if (ret < 0 && ret != -EINVAL) { 2010 2010 dev_err(&pdev->dev, "unable to read mpss firmware-name\n"); 2011 - goto free_rproc; 2011 + return ret; 2012 2012 } 2013 2013 2014 2014 platform_set_drvdata(pdev, qproc); ··· 2019 2019 qproc->has_spare_reg = desc->has_spare_reg; 2020 2020 ret = q6v5_init_mem(qproc, pdev); 2021 2021 if (ret) 2022 - goto free_rproc; 2022 + return ret; 2023 2023 2024 2024 ret = q6v5_alloc_memory_region(qproc); 2025 2025 if (ret) 2026 - goto free_rproc; 2026 + return ret; 2027 2027 2028 2028 ret = q6v5_init_clocks(&pdev->dev, qproc->proxy_clks, 2029 2029 desc->proxy_clk_names); 2030 2030 if (ret < 0) { 2031 2031 dev_err(&pdev->dev, "Failed to get proxy clocks.\n"); 2032 - goto free_rproc; 2032 + return ret; 2033 2033 } 2034 2034 qproc->proxy_clk_count = ret; 2035 2035 ··· 2037 2037 desc->reset_clk_names); 2038 2038 if (ret < 0) { 2039 2039 dev_err(&pdev->dev, "Failed to get reset clocks.\n"); 2040 - goto free_rproc; 2040 + return ret; 2041 2041 } 2042 2042 qproc->reset_clk_count = ret; 2043 2043 ··· 2045 2045 desc->active_clk_names); 2046 2046 if (ret < 0) { 2047 2047 dev_err(&pdev->dev, "Failed to get active clocks.\n"); 2048 - goto free_rproc; 2048 + return ret; 2049 2049 } 2050 2050 qproc->active_clk_count = ret; 2051 2051 ··· 2053 2053 desc->proxy_supply); 2054 2054 if (ret < 0) { 2055 2055 dev_err(&pdev->dev, "Failed to get proxy regulators.\n"); 2056 - goto free_rproc; 2056 + return ret; 2057 2057 } 2058 2058 qproc->proxy_reg_count = ret; 2059 2059 ··· 2061 2061 desc->active_supply); 2062 2062 if (ret < 0) { 2063 2063 dev_err(&pdev->dev, "Failed to get active regulators.\n"); 2064 - goto free_rproc; 2064 + return ret; 2065 2065 } 2066 2066 qproc->active_reg_count = ret; 2067 2067 ··· 2074 2074 desc->fallback_proxy_supply); 2075 2075 if (ret < 0) { 2076 2076 dev_err(&pdev->dev, "Failed to get fallback proxy regulators.\n"); 2077 - goto free_rproc; 2077 + return ret; 2078 2078 } 2079 2079 qproc->fallback_proxy_reg_count = ret; 2080 2080 } else if (ret < 0) { 2081 2081 dev_err(&pdev->dev, "Failed to init power domains\n"); 2082 - goto free_rproc; 2082 + return ret; 2083 2083 } else { 2084 2084 qproc->proxy_pd_count = ret; 2085 2085 } ··· 2127 2127 qcom_remove_glink_subdev(rproc, &qproc->glink_subdev); 2128 2128 detach_proxy_pds: 2129 2129 q6v5_pds_detach(qproc, qproc->proxy_pds, qproc->proxy_pd_count); 2130 - free_rproc: 2131 - rproc_free(rproc); 2132 2130 2133 2131 return ret; 2134 2132 } ··· 2147 2149 qcom_remove_glink_subdev(rproc, &qproc->glink_subdev); 2148 2150 2149 2151 q6v5_pds_detach(qproc, qproc->proxy_pds, qproc->proxy_pd_count); 2150 - 2151 - rproc_free(rproc); 2152 2152 } 2153 2153 2154 2154 static const struct rproc_hexagon_res sc7180_mss = {
+227 -99
drivers/remoteproc/qcom_q6v5_pas.c
··· 33 33 34 34 #define ADSP_DECRYPT_SHUTDOWN_DELAY_MS 100 35 35 36 + #define MAX_ASSIGN_COUNT 3 37 + 36 38 struct adsp_data { 37 39 int crash_reason_smem; 38 40 const char *firmware_name; 39 41 const char *dtb_firmware_name; 40 42 int pas_id; 41 43 int dtb_pas_id; 44 + int lite_pas_id; 42 45 unsigned int minidump_id; 43 46 bool auto_boot; 44 47 bool decrypt_shutdown; ··· 54 51 int ssctl_id; 55 52 56 53 int region_assign_idx; 54 + int region_assign_count; 55 + bool region_assign_shared; 56 + int region_assign_vmid; 57 57 }; 58 58 59 59 struct qcom_adsp { ··· 78 72 const char *dtb_firmware_name; 79 73 int pas_id; 80 74 int dtb_pas_id; 75 + int lite_pas_id; 81 76 unsigned int minidump_id; 82 77 int crash_reason_smem; 83 78 bool decrypt_shutdown; ··· 94 87 phys_addr_t dtb_mem_phys; 95 88 phys_addr_t mem_reloc; 96 89 phys_addr_t dtb_mem_reloc; 97 - phys_addr_t region_assign_phys; 90 + phys_addr_t region_assign_phys[MAX_ASSIGN_COUNT]; 98 91 void *mem_region; 99 92 void *dtb_mem_region; 100 93 size_t mem_size; 101 94 size_t dtb_mem_size; 102 - size_t region_assign_size; 95 + size_t region_assign_size[MAX_ASSIGN_COUNT]; 103 96 104 97 int region_assign_idx; 105 - u64 region_assign_perms; 98 + int region_assign_count; 99 + bool region_assign_shared; 100 + int region_assign_vmid; 101 + u64 region_assign_owners[MAX_ASSIGN_COUNT]; 106 102 107 103 struct qcom_rproc_glink glink_subdev; 108 104 struct qcom_rproc_subdev smd_subdev; ··· 219 209 220 210 /* Store firmware handle to be used in adsp_start() */ 221 211 adsp->firmware = fw; 212 + 213 + if (adsp->lite_pas_id) 214 + ret = qcom_scm_pas_shutdown(adsp->lite_pas_id); 222 215 223 216 if (adsp->dtb_pas_id) { 224 217 ret = request_firmware(&adsp->dtb_firmware, adsp->dtb_firmware_name, adsp->dev); ··· 603 590 604 591 static int adsp_assign_memory_region(struct qcom_adsp *adsp) 605 592 { 606 - struct reserved_mem *rmem = NULL; 607 - struct qcom_scm_vmperm perm; 593 + struct qcom_scm_vmperm perm[MAX_ASSIGN_COUNT]; 608 594 struct device_node *node; 595 + unsigned int perm_size; 596 + int offset; 609 597 int ret; 610 598 611 599 if (!adsp->region_assign_idx) 612 600 return 0; 613 601 614 - node = of_parse_phandle(adsp->dev->of_node, "memory-region", adsp->region_assign_idx); 615 - if (node) 616 - rmem = of_reserved_mem_lookup(node); 617 - of_node_put(node); 618 - if (!rmem) { 619 - dev_err(adsp->dev, "unable to resolve shareable memory-region\n"); 620 - return -EINVAL; 621 - } 602 + for (offset = 0; offset < adsp->region_assign_count; ++offset) { 603 + struct reserved_mem *rmem = NULL; 622 604 623 - perm.vmid = QCOM_SCM_VMID_MSS_MSA; 624 - perm.perm = QCOM_SCM_PERM_RW; 605 + node = of_parse_phandle(adsp->dev->of_node, "memory-region", 606 + adsp->region_assign_idx + offset); 607 + if (node) 608 + rmem = of_reserved_mem_lookup(node); 609 + of_node_put(node); 610 + if (!rmem) { 611 + dev_err(adsp->dev, "unable to resolve shareable memory-region index %d\n", 612 + offset); 613 + return -EINVAL; 614 + } 625 615 626 - adsp->region_assign_phys = rmem->base; 627 - adsp->region_assign_size = rmem->size; 628 - adsp->region_assign_perms = BIT(QCOM_SCM_VMID_HLOS); 616 + if (adsp->region_assign_shared) { 617 + perm[0].vmid = QCOM_SCM_VMID_HLOS; 618 + perm[0].perm = QCOM_SCM_PERM_RW; 619 + perm[1].vmid = adsp->region_assign_vmid; 620 + perm[1].perm = QCOM_SCM_PERM_RW; 621 + perm_size = 2; 622 + } else { 623 + perm[0].vmid = adsp->region_assign_vmid; 624 + perm[0].perm = QCOM_SCM_PERM_RW; 625 + perm_size = 1; 626 + } 629 627 630 - ret = qcom_scm_assign_mem(adsp->region_assign_phys, 631 - adsp->region_assign_size, 632 - &adsp->region_assign_perms, 633 - &perm, 1); 634 - if (ret < 0) { 635 - dev_err(adsp->dev, "assign memory failed\n"); 636 - return ret; 628 + adsp->region_assign_phys[offset] = rmem->base; 629 + adsp->region_assign_size[offset] = rmem->size; 630 + adsp->region_assign_owners[offset] = BIT(QCOM_SCM_VMID_HLOS); 631 + 632 + ret = qcom_scm_assign_mem(adsp->region_assign_phys[offset], 633 + adsp->region_assign_size[offset], 634 + &adsp->region_assign_owners[offset], 635 + perm, perm_size); 636 + if (ret < 0) { 637 + dev_err(adsp->dev, "assign memory %d failed\n", offset); 638 + return ret; 639 + } 637 640 } 638 641 639 642 return 0; ··· 658 629 static void adsp_unassign_memory_region(struct qcom_adsp *adsp) 659 630 { 660 631 struct qcom_scm_vmperm perm; 632 + int offset; 661 633 int ret; 662 634 663 - if (!adsp->region_assign_idx) 635 + if (!adsp->region_assign_idx || adsp->region_assign_shared) 664 636 return; 665 637 666 - perm.vmid = QCOM_SCM_VMID_HLOS; 667 - perm.perm = QCOM_SCM_PERM_RW; 638 + for (offset = 0; offset < adsp->region_assign_count; ++offset) { 639 + perm.vmid = QCOM_SCM_VMID_HLOS; 640 + perm.perm = QCOM_SCM_PERM_RW; 668 641 669 - ret = qcom_scm_assign_mem(adsp->region_assign_phys, 670 - adsp->region_assign_size, 671 - &adsp->region_assign_perms, 672 - &perm, 1); 673 - if (ret < 0) 674 - dev_err(adsp->dev, "unassign memory failed\n"); 642 + ret = qcom_scm_assign_mem(adsp->region_assign_phys[offset], 643 + adsp->region_assign_size[offset], 644 + &adsp->region_assign_owners[offset], 645 + &perm, 1); 646 + if (ret < 0) 647 + dev_err(adsp->dev, "unassign memory %d failed\n", offset); 648 + } 675 649 } 676 650 677 651 static int adsp_probe(struct platform_device *pdev) ··· 710 678 if (desc->minidump_id) 711 679 ops = &adsp_minidump_ops; 712 680 713 - rproc = rproc_alloc(&pdev->dev, pdev->name, ops, fw_name, sizeof(*adsp)); 681 + rproc = devm_rproc_alloc(&pdev->dev, pdev->name, ops, fw_name, sizeof(*adsp)); 714 682 715 683 if (!rproc) { 716 684 dev_err(&pdev->dev, "unable to allocate remoteproc\n"); ··· 725 693 adsp->rproc = rproc; 726 694 adsp->minidump_id = desc->minidump_id; 727 695 adsp->pas_id = desc->pas_id; 696 + adsp->lite_pas_id = desc->lite_pas_id; 728 697 adsp->info_name = desc->sysmon_name; 729 698 adsp->decrypt_shutdown = desc->decrypt_shutdown; 730 699 adsp->region_assign_idx = desc->region_assign_idx; 700 + adsp->region_assign_count = min_t(int, MAX_ASSIGN_COUNT, desc->region_assign_count); 701 + adsp->region_assign_vmid = desc->region_assign_vmid; 702 + adsp->region_assign_shared = desc->region_assign_shared; 731 703 if (dtb_fw_name) { 732 704 adsp->dtb_firmware_name = dtb_fw_name; 733 705 adsp->dtb_pas_id = desc->dtb_pas_id; ··· 790 754 adsp_pds_detach(adsp, adsp->proxy_pds, adsp->proxy_pd_count); 791 755 free_rproc: 792 756 device_init_wakeup(adsp->dev, false); 793 - rproc_free(rproc); 794 757 795 758 return ret; 796 759 } ··· 808 773 qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev); 809 774 adsp_pds_detach(adsp, adsp->proxy_pds, adsp->proxy_pd_count); 810 775 device_init_wakeup(adsp->dev, false); 811 - rproc_free(adsp->rproc); 812 776 } 813 777 814 778 static const struct adsp_data adsp_resource_init = { 815 - .crash_reason_smem = 423, 816 - .firmware_name = "adsp.mdt", 817 - .pas_id = 1, 818 - .auto_boot = true, 819 - .ssr_name = "lpass", 820 - .sysmon_name = "adsp", 821 - .ssctl_id = 0x14, 779 + .crash_reason_smem = 423, 780 + .firmware_name = "adsp.mdt", 781 + .pas_id = 1, 782 + .auto_boot = true, 783 + .ssr_name = "lpass", 784 + .sysmon_name = "adsp", 785 + .ssctl_id = 0x14, 822 786 }; 823 787 824 788 static const struct adsp_data sdm845_adsp_resource_init = { 825 - .crash_reason_smem = 423, 826 - .firmware_name = "adsp.mdt", 827 - .pas_id = 1, 828 - .auto_boot = true, 829 - .load_state = "adsp", 830 - .ssr_name = "lpass", 831 - .sysmon_name = "adsp", 832 - .ssctl_id = 0x14, 789 + .crash_reason_smem = 423, 790 + .firmware_name = "adsp.mdt", 791 + .pas_id = 1, 792 + .auto_boot = true, 793 + .load_state = "adsp", 794 + .ssr_name = "lpass", 795 + .sysmon_name = "adsp", 796 + .ssctl_id = 0x14, 833 797 }; 834 798 835 799 static const struct adsp_data sm6350_adsp_resource = { ··· 863 829 }; 864 830 865 831 static const struct adsp_data sm8150_adsp_resource = { 866 - .crash_reason_smem = 423, 867 - .firmware_name = "adsp.mdt", 868 - .pas_id = 1, 869 - .auto_boot = true, 870 - .proxy_pd_names = (char*[]){ 871 - "cx", 872 - NULL 873 - }, 874 - .load_state = "adsp", 875 - .ssr_name = "lpass", 876 - .sysmon_name = "adsp", 877 - .ssctl_id = 0x14, 832 + .crash_reason_smem = 423, 833 + .firmware_name = "adsp.mdt", 834 + .pas_id = 1, 835 + .auto_boot = true, 836 + .proxy_pd_names = (char*[]){ 837 + "cx", 838 + NULL 839 + }, 840 + .load_state = "adsp", 841 + .ssr_name = "lpass", 842 + .sysmon_name = "adsp", 843 + .ssctl_id = 0x14, 878 844 }; 879 845 880 846 static const struct adsp_data sm8250_adsp_resource = { ··· 910 876 }; 911 877 912 878 static const struct adsp_data msm8996_adsp_resource = { 913 - .crash_reason_smem = 423, 914 - .firmware_name = "adsp.mdt", 915 - .pas_id = 1, 916 - .auto_boot = true, 917 - .proxy_pd_names = (char*[]){ 918 - "cx", 919 - NULL 920 - }, 921 - .ssr_name = "lpass", 922 - .sysmon_name = "adsp", 923 - .ssctl_id = 0x14, 879 + .crash_reason_smem = 423, 880 + .firmware_name = "adsp.mdt", 881 + .pas_id = 1, 882 + .auto_boot = true, 883 + .proxy_pd_names = (char*[]){ 884 + "cx", 885 + NULL 886 + }, 887 + .ssr_name = "lpass", 888 + .sysmon_name = "adsp", 889 + .ssctl_id = 0x14, 924 890 }; 925 891 926 892 static const struct adsp_data cdsp_resource_init = { ··· 1018 984 .ssctl_id = 0x20, 1019 985 }; 1020 986 987 + static const struct adsp_data x1e80100_adsp_resource = { 988 + .crash_reason_smem = 423, 989 + .firmware_name = "adsp.mdt", 990 + .dtb_firmware_name = "adsp_dtb.mdt", 991 + .pas_id = 1, 992 + .dtb_pas_id = 0x24, 993 + .lite_pas_id = 0x1f, 994 + .minidump_id = 5, 995 + .auto_boot = true, 996 + .proxy_pd_names = (char*[]){ 997 + "lcx", 998 + "lmx", 999 + NULL 1000 + }, 1001 + .load_state = "adsp", 1002 + .ssr_name = "lpass", 1003 + .sysmon_name = "adsp", 1004 + .ssctl_id = 0x14, 1005 + }; 1006 + 1007 + static const struct adsp_data x1e80100_cdsp_resource = { 1008 + .crash_reason_smem = 601, 1009 + .firmware_name = "cdsp.mdt", 1010 + .dtb_firmware_name = "cdsp_dtb.mdt", 1011 + .pas_id = 18, 1012 + .dtb_pas_id = 0x25, 1013 + .minidump_id = 7, 1014 + .auto_boot = true, 1015 + .proxy_pd_names = (char*[]){ 1016 + "cx", 1017 + "mxc", 1018 + "nsp", 1019 + NULL 1020 + }, 1021 + .load_state = "cdsp", 1022 + .ssr_name = "cdsp", 1023 + .sysmon_name = "cdsp", 1024 + .ssctl_id = 0x17, 1025 + }; 1026 + 1021 1027 static const struct adsp_data sm8350_cdsp_resource = { 1022 1028 .crash_reason_smem = 601, 1023 1029 .firmware_name = "cdsp.mdt", ··· 1107 1033 }; 1108 1034 1109 1035 static const struct adsp_data msm8996_slpi_resource_init = { 1110 - .crash_reason_smem = 424, 1111 - .firmware_name = "slpi.mdt", 1112 - .pas_id = 12, 1113 - .auto_boot = true, 1114 - .proxy_pd_names = (char*[]){ 1115 - "ssc_cx", 1116 - NULL 1117 - }, 1118 - .ssr_name = "dsps", 1119 - .sysmon_name = "slpi", 1120 - .ssctl_id = 0x16, 1036 + .crash_reason_smem = 424, 1037 + .firmware_name = "slpi.mdt", 1038 + .pas_id = 12, 1039 + .auto_boot = true, 1040 + .proxy_pd_names = (char*[]){ 1041 + "ssc_cx", 1042 + NULL 1043 + }, 1044 + .ssr_name = "dsps", 1045 + .sysmon_name = "slpi", 1046 + .ssctl_id = 0x16, 1121 1047 }; 1122 1048 1123 1049 static const struct adsp_data sdm845_slpi_resource_init = { 1124 - .crash_reason_smem = 424, 1125 - .firmware_name = "slpi.mdt", 1126 - .pas_id = 12, 1127 - .auto_boot = true, 1128 - .proxy_pd_names = (char*[]){ 1129 - "lcx", 1130 - "lmx", 1131 - NULL 1132 - }, 1133 - .load_state = "slpi", 1134 - .ssr_name = "dsps", 1135 - .sysmon_name = "slpi", 1136 - .ssctl_id = 0x16, 1050 + .crash_reason_smem = 424, 1051 + .firmware_name = "slpi.mdt", 1052 + .pas_id = 12, 1053 + .auto_boot = true, 1054 + .proxy_pd_names = (char*[]){ 1055 + "lcx", 1056 + "lmx", 1057 + NULL 1058 + }, 1059 + .load_state = "slpi", 1060 + .ssr_name = "dsps", 1061 + .sysmon_name = "slpi", 1062 + .ssctl_id = 0x16, 1137 1063 }; 1138 1064 1139 1065 static const struct adsp_data wcss_resource_init = { ··· 1237 1163 .sysmon_name = "modem", 1238 1164 .ssctl_id = 0x12, 1239 1165 .region_assign_idx = 2, 1166 + .region_assign_count = 1, 1167 + .region_assign_vmid = QCOM_SCM_VMID_MSS_MSA, 1240 1168 }; 1241 1169 1242 1170 static const struct adsp_data sc7280_wpss_resource = { ··· 1255 1179 .ssr_name = "wpss", 1256 1180 .sysmon_name = "wpss", 1257 1181 .ssctl_id = 0x19, 1182 + }; 1183 + 1184 + static const struct adsp_data sm8650_cdsp_resource = { 1185 + .crash_reason_smem = 601, 1186 + .firmware_name = "cdsp.mdt", 1187 + .dtb_firmware_name = "cdsp_dtb.mdt", 1188 + .pas_id = 18, 1189 + .dtb_pas_id = 0x25, 1190 + .minidump_id = 7, 1191 + .auto_boot = true, 1192 + .proxy_pd_names = (char*[]){ 1193 + "cx", 1194 + "mxc", 1195 + "nsp", 1196 + NULL 1197 + }, 1198 + .load_state = "cdsp", 1199 + .ssr_name = "cdsp", 1200 + .sysmon_name = "cdsp", 1201 + .ssctl_id = 0x17, 1202 + .region_assign_idx = 2, 1203 + .region_assign_count = 1, 1204 + .region_assign_shared = true, 1205 + .region_assign_vmid = QCOM_SCM_VMID_CDSP, 1206 + }; 1207 + 1208 + static const struct adsp_data sm8650_mpss_resource = { 1209 + .crash_reason_smem = 421, 1210 + .firmware_name = "modem.mdt", 1211 + .dtb_firmware_name = "modem_dtb.mdt", 1212 + .pas_id = 4, 1213 + .dtb_pas_id = 0x26, 1214 + .minidump_id = 3, 1215 + .auto_boot = false, 1216 + .decrypt_shutdown = true, 1217 + .proxy_pd_names = (char*[]){ 1218 + "cx", 1219 + "mss", 1220 + NULL 1221 + }, 1222 + .load_state = "modem", 1223 + .ssr_name = "mpss", 1224 + .sysmon_name = "modem", 1225 + .ssctl_id = 0x12, 1226 + .region_assign_idx = 2, 1227 + .region_assign_count = 3, 1228 + .region_assign_vmid = QCOM_SCM_VMID_MSS_MSA, 1258 1229 }; 1259 1230 1260 1231 static const struct of_device_id adsp_of_match[] = { ··· 1359 1236 { .compatible = "qcom,sm8550-adsp-pas", .data = &sm8550_adsp_resource}, 1360 1237 { .compatible = "qcom,sm8550-cdsp-pas", .data = &sm8550_cdsp_resource}, 1361 1238 { .compatible = "qcom,sm8550-mpss-pas", .data = &sm8550_mpss_resource}, 1239 + { .compatible = "qcom,sm8650-adsp-pas", .data = &sm8550_adsp_resource}, 1240 + { .compatible = "qcom,sm8650-cdsp-pas", .data = &sm8650_cdsp_resource}, 1241 + { .compatible = "qcom,sm8650-mpss-pas", .data = &sm8650_mpss_resource}, 1242 + { .compatible = "qcom,x1e80100-adsp-pas", .data = &x1e80100_adsp_resource}, 1243 + { .compatible = "qcom,x1e80100-cdsp-pas", .data = &x1e80100_cdsp_resource}, 1362 1244 { }, 1363 1245 }; 1364 1246 MODULE_DEVICE_TABLE(of, adsp_of_match);
+9 -15
drivers/remoteproc/qcom_q6v5_wcss.c
··· 1011 1011 if (!desc) 1012 1012 return -EINVAL; 1013 1013 1014 - rproc = rproc_alloc(&pdev->dev, pdev->name, desc->ops, 1015 - desc->firmware_name, sizeof(*wcss)); 1014 + rproc = devm_rproc_alloc(&pdev->dev, pdev->name, desc->ops, 1015 + desc->firmware_name, sizeof(*wcss)); 1016 1016 if (!rproc) { 1017 1017 dev_err(&pdev->dev, "failed to allocate rproc\n"); 1018 1018 return -ENOMEM; ··· 1027 1027 1028 1028 ret = q6v5_wcss_init_mmio(wcss, pdev); 1029 1029 if (ret) 1030 - goto free_rproc; 1030 + return ret; 1031 1031 1032 1032 ret = q6v5_alloc_memory_region(wcss); 1033 1033 if (ret) 1034 - goto free_rproc; 1034 + return ret; 1035 1035 1036 1036 if (wcss->version == WCSS_QCS404) { 1037 1037 ret = q6v5_wcss_init_clock(wcss); 1038 1038 if (ret) 1039 - goto free_rproc; 1039 + return ret; 1040 1040 1041 1041 ret = q6v5_wcss_init_regulator(wcss); 1042 1042 if (ret) 1043 - goto free_rproc; 1043 + return ret; 1044 1044 } 1045 1045 1046 1046 ret = q6v5_wcss_init_reset(wcss, desc); 1047 1047 if (ret) 1048 - goto free_rproc; 1048 + return ret; 1049 1049 1050 1050 ret = qcom_q6v5_init(&wcss->q6v5, pdev, rproc, desc->crash_reason_smem, NULL, NULL); 1051 1051 if (ret) 1052 - goto free_rproc; 1052 + return ret; 1053 1053 1054 1054 qcom_add_glink_subdev(rproc, &wcss->glink_subdev, "q6wcss"); 1055 1055 qcom_add_ssr_subdev(rproc, &wcss->ssr_subdev, "q6wcss"); ··· 1061 1061 1062 1062 ret = rproc_add(rproc); 1063 1063 if (ret) 1064 - goto free_rproc; 1064 + return ret; 1065 1065 1066 1066 platform_set_drvdata(pdev, rproc); 1067 1067 1068 1068 return 0; 1069 - 1070 - free_rproc: 1071 - rproc_free(rproc); 1072 - 1073 - return ret; 1074 1069 } 1075 1070 1076 1071 static void q6v5_wcss_remove(struct platform_device *pdev) ··· 1075 1080 1076 1081 qcom_q6v5_deinit(&wcss->q6v5); 1077 1082 rproc_del(rproc); 1078 - rproc_free(rproc); 1079 1083 } 1080 1084 1081 1085 static const struct wcss_data wcss_ipq8074_res_init = {
+6 -11
drivers/remoteproc/qcom_wcnss.c
··· 555 555 if (ret < 0 && ret != -EINVAL) 556 556 return ret; 557 557 558 - rproc = rproc_alloc(&pdev->dev, pdev->name, &wcnss_ops, 559 - fw_name, sizeof(*wcnss)); 558 + rproc = devm_rproc_alloc(&pdev->dev, pdev->name, &wcnss_ops, 559 + fw_name, sizeof(*wcnss)); 560 560 if (!rproc) { 561 561 dev_err(&pdev->dev, "unable to allocate remoteproc\n"); 562 562 return -ENOMEM; ··· 574 574 mutex_init(&wcnss->iris_lock); 575 575 576 576 mmio = devm_platform_ioremap_resource_byname(pdev, "pmu"); 577 - if (IS_ERR(mmio)) { 578 - ret = PTR_ERR(mmio); 579 - goto free_rproc; 580 - } 577 + if (IS_ERR(mmio)) 578 + return PTR_ERR(mmio); 581 579 582 580 ret = wcnss_alloc_memory_region(wcnss); 583 581 if (ret) 584 - goto free_rproc; 582 + return ret; 585 583 586 584 wcnss->pmu_cfg = mmio + data->pmu_offset; 587 585 wcnss->spare_out = mmio + data->spare_offset; ··· 590 592 */ 591 593 ret = wcnss_init_pds(wcnss, data->pd_names); 592 594 if (ret && (ret != -ENODATA || !data->num_pd_vregs)) 593 - goto free_rproc; 595 + return ret; 594 596 595 597 ret = wcnss_init_regulators(wcnss, data->vregs, data->num_vregs, 596 598 data->num_pd_vregs); ··· 654 656 qcom_iris_remove(wcnss->iris); 655 657 detach_pds: 656 658 wcnss_release_pds(wcnss); 657 - free_rproc: 658 - rproc_free(rproc); 659 659 660 660 return ret; 661 661 } ··· 669 673 qcom_remove_sysmon_subdev(wcnss->sysmon); 670 674 qcom_remove_smd_subdev(wcnss->rproc, &wcnss->smd_subdev); 671 675 wcnss_release_pds(wcnss); 672 - rproc_free(wcnss->rproc); 673 676 } 674 677 675 678 static const struct of_device_id wcnss_of_match[] = {
+27 -2
drivers/remoteproc/remoteproc_core.c
··· 33 33 #include <linux/idr.h> 34 34 #include <linux/elf.h> 35 35 #include <linux/crc32.h> 36 + #include <linux/of_platform.h> 36 37 #include <linux/of_reserved_mem.h> 37 38 #include <linux/virtio_ids.h> 38 39 #include <linux/virtio_ring.h> ··· 2113 2112 struct rproc *rproc_get_by_phandle(phandle phandle) 2114 2113 { 2115 2114 struct rproc *rproc = NULL, *r; 2115 + struct device_driver *driver; 2116 2116 struct device_node *np; 2117 2117 2118 2118 np = of_find_node_by_phandle(phandle); ··· 2124 2122 list_for_each_entry_rcu(r, &rproc_list, node) { 2125 2123 if (r->dev.parent && device_match_of_node(r->dev.parent, np)) { 2126 2124 /* prevent underlying implementation from being removed */ 2127 - if (!try_module_get(r->dev.parent->driver->owner)) { 2125 + 2126 + /* 2127 + * If the remoteproc's parent has a driver, the 2128 + * remoteproc is not part of a cluster and we can use 2129 + * that driver. 2130 + */ 2131 + driver = r->dev.parent->driver; 2132 + 2133 + /* 2134 + * If the remoteproc's parent does not have a driver, 2135 + * look for the driver associated with the cluster. 2136 + */ 2137 + if (!driver) { 2138 + if (r->dev.parent->parent) 2139 + driver = r->dev.parent->parent->driver; 2140 + if (!driver) 2141 + break; 2142 + } 2143 + 2144 + if (!try_module_get(driver->owner)) { 2128 2145 dev_err(&r->dev, "can't get owner\n"); 2129 2146 break; 2130 2147 } ··· 2554 2533 */ 2555 2534 void rproc_put(struct rproc *rproc) 2556 2535 { 2557 - module_put(rproc->dev.parent->driver->owner); 2536 + if (rproc->dev.parent->driver) 2537 + module_put(rproc->dev.parent->driver->owner); 2538 + else 2539 + module_put(rproc->dev.parent->parent->driver->owner); 2540 + 2558 2541 put_device(&rproc->dev); 2559 2542 } 2560 2543 EXPORT_SYMBOL(rproc_put);
+3 -3
drivers/remoteproc/remoteproc_virtio.c
··· 351 351 352 352 kfree(vdev); 353 353 354 + of_reserved_mem_device_release(&rvdev->pdev->dev); 355 + dma_release_coherent_memory(&rvdev->pdev->dev); 356 + 354 357 put_device(&rvdev->pdev->dev); 355 358 } 356 359 ··· 586 583 587 584 rproc_remove_subdev(rproc, &rvdev->subdev); 588 585 rproc_remove_rvdev(rvdev); 589 - 590 - of_reserved_mem_device_release(&pdev->dev); 591 - dma_release_coherent_memory(&pdev->dev); 592 586 593 587 put_device(&rproc->dev); 594 588 }
+5 -10
drivers/remoteproc/st_remoteproc.c
··· 347 347 int enabled; 348 348 int ret, i; 349 349 350 - rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata)); 350 + rproc = devm_rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata)); 351 351 if (!rproc) 352 352 return -ENOMEM; 353 353 354 354 rproc->has_iommu = false; 355 355 ddata = rproc->priv; 356 356 ddata->config = (struct st_rproc_config *)device_get_match_data(dev); 357 - if (!ddata->config) { 358 - ret = -ENODEV; 359 - goto free_rproc; 360 - } 357 + if (!ddata->config) 358 + return -ENODEV; 361 359 362 360 platform_set_drvdata(pdev, rproc); 363 361 364 362 ret = st_rproc_parse_dt(pdev); 365 363 if (ret) 366 - goto free_rproc; 364 + return ret; 367 365 368 366 enabled = st_rproc_state(pdev); 369 367 if (enabled < 0) { ··· 437 439 mbox_free_channel(ddata->mbox_chan[i]); 438 440 free_clk: 439 441 clk_unprepare(ddata->clk); 440 - free_rproc: 441 - rproc_free(rproc); 442 + 442 443 return ret; 443 444 } 444 445 ··· 453 456 454 457 for (i = 0; i < ST_RPROC_MAX_VRING * MBOX_MAX; i++) 455 458 mbox_free_channel(ddata->mbox_chan[i]); 456 - 457 - rproc_free(rproc); 458 459 } 459 460 460 461 static struct platform_driver st_rproc_driver = {
+4 -6
drivers/remoteproc/stm32_rproc.c
··· 120 120 void *va; 121 121 122 122 dev_dbg(dev, "map memory: %pad+%zx\n", &mem->dma, mem->len); 123 - va = ioremap_wc(mem->dma, mem->len); 123 + va = (__force void *)ioremap_wc(mem->dma, mem->len); 124 124 if (IS_ERR_OR_NULL(va)) { 125 125 dev_err(dev, "Unable to map memory region: %pad+0x%zx\n", 126 126 &mem->dma, mem->len); ··· 137 137 struct rproc_mem_entry *mem) 138 138 { 139 139 dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma); 140 - iounmap(mem->va); 140 + iounmap((__force __iomem void *)mem->va); 141 141 142 142 return 0; 143 143 } ··· 657 657 * entire area by overwriting it with the initial values stored in rproc->clean_table. 658 658 */ 659 659 *table_sz = RSC_TBL_SIZE; 660 - return (struct resource_table *)ddata->rsc_va; 660 + return (__force struct resource_table *)ddata->rsc_va; 661 661 } 662 662 663 663 static const struct rproc_ops st_rproc_ops = { ··· 843 843 if (ret) 844 844 return ret; 845 845 846 - rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata)); 846 + rproc = devm_rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata)); 847 847 if (!rproc) 848 848 return -ENOMEM; 849 849 ··· 897 897 dev_pm_clear_wake_irq(dev); 898 898 device_init_wakeup(dev, false); 899 899 } 900 - rproc_free(rproc); 901 900 return ret; 902 901 } 903 902 ··· 917 918 dev_pm_clear_wake_irq(dev); 918 919 device_init_wakeup(dev, false); 919 920 } 920 - rproc_free(rproc); 921 921 } 922 922 923 923 static int stm32_rproc_suspend(struct device *dev)
+50 -106
drivers/remoteproc/ti_k3_dsp_remoteproc.c
··· 550 550 return 0; 551 551 } 552 552 553 + static void k3_dsp_mem_release(void *data) 554 + { 555 + struct device *dev = data; 556 + 557 + of_reserved_mem_device_release(dev); 558 + } 559 + 553 560 static int k3_dsp_reserved_mem_init(struct k3_dsp_rproc *kproc) 554 561 { 555 562 struct device *dev = kproc->dev; ··· 586 579 ERR_PTR(ret)); 587 580 return ret; 588 581 } 582 + ret = devm_add_action_or_reset(dev, k3_dsp_mem_release, dev); 583 + if (ret) 584 + return ret; 589 585 590 586 num_rmems--; 591 - kproc->rmem = kcalloc(num_rmems, sizeof(*kproc->rmem), GFP_KERNEL); 592 - if (!kproc->rmem) { 593 - ret = -ENOMEM; 594 - goto release_rmem; 595 - } 587 + kproc->rmem = devm_kcalloc(dev, num_rmems, sizeof(*kproc->rmem), GFP_KERNEL); 588 + if (!kproc->rmem) 589 + return -ENOMEM; 596 590 597 591 /* use remaining reserved memory regions for static carveouts */ 598 592 for (i = 0; i < num_rmems; i++) { 599 593 rmem_np = of_parse_phandle(np, "memory-region", i + 1); 600 - if (!rmem_np) { 601 - ret = -EINVAL; 602 - goto unmap_rmem; 603 - } 594 + if (!rmem_np) 595 + return -EINVAL; 604 596 605 597 rmem = of_reserved_mem_lookup(rmem_np); 606 598 if (!rmem) { 607 599 of_node_put(rmem_np); 608 - ret = -EINVAL; 609 - goto unmap_rmem; 600 + return -EINVAL; 610 601 } 611 602 of_node_put(rmem_np); 612 603 ··· 612 607 /* 64-bit address regions currently not supported */ 613 608 kproc->rmem[i].dev_addr = (u32)rmem->base; 614 609 kproc->rmem[i].size = rmem->size; 615 - kproc->rmem[i].cpu_addr = ioremap_wc(rmem->base, rmem->size); 610 + kproc->rmem[i].cpu_addr = devm_ioremap_wc(dev, rmem->base, rmem->size); 616 611 if (!kproc->rmem[i].cpu_addr) { 617 612 dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n", 618 613 i + 1, &rmem->base, &rmem->size); 619 - ret = -ENOMEM; 620 - goto unmap_rmem; 614 + return -ENOMEM; 621 615 } 622 616 623 617 dev_dbg(dev, "reserved memory%d: bus addr %pa size 0x%zx va %pK da 0x%x\n", ··· 627 623 kproc->num_rmems = num_rmems; 628 624 629 625 return 0; 630 - 631 - unmap_rmem: 632 - for (i--; i >= 0; i--) 633 - iounmap(kproc->rmem[i].cpu_addr); 634 - kfree(kproc->rmem); 635 - release_rmem: 636 - of_reserved_mem_device_release(kproc->dev); 637 - return ret; 638 626 } 639 627 640 - static void k3_dsp_reserved_mem_exit(struct k3_dsp_rproc *kproc) 628 + static void k3_dsp_release_tsp(void *data) 641 629 { 642 - int i; 630 + struct ti_sci_proc *tsp = data; 643 631 644 - for (i = 0; i < kproc->num_rmems; i++) 645 - iounmap(kproc->rmem[i].cpu_addr); 646 - kfree(kproc->rmem); 647 - 648 - of_reserved_mem_device_release(kproc->dev); 632 + ti_sci_proc_release(tsp); 649 633 } 650 634 651 635 static ··· 649 657 if (ret < 0) 650 658 return ERR_PTR(ret); 651 659 652 - tsp = kzalloc(sizeof(*tsp), GFP_KERNEL); 660 + tsp = devm_kzalloc(dev, sizeof(*tsp), GFP_KERNEL); 653 661 if (!tsp) 654 662 return ERR_PTR(-ENOMEM); 655 663 ··· 672 680 const char *fw_name; 673 681 bool p_state = false; 674 682 int ret = 0; 675 - int ret1; 676 683 677 684 data = of_device_get_match_data(dev); 678 685 if (!data) ··· 681 690 if (ret) 682 691 return dev_err_probe(dev, ret, "failed to parse firmware-name property\n"); 683 692 684 - rproc = rproc_alloc(dev, dev_name(dev), &k3_dsp_rproc_ops, fw_name, 685 - sizeof(*kproc)); 693 + rproc = devm_rproc_alloc(dev, dev_name(dev), &k3_dsp_rproc_ops, 694 + fw_name, sizeof(*kproc)); 686 695 if (!rproc) 687 696 return -ENOMEM; 688 697 ··· 697 706 kproc->dev = dev; 698 707 kproc->data = data; 699 708 700 - kproc->ti_sci = ti_sci_get_by_phandle(np, "ti,sci"); 701 - if (IS_ERR(kproc->ti_sci)) { 702 - ret = dev_err_probe(dev, PTR_ERR(kproc->ti_sci), 703 - "failed to get ti-sci handle\n"); 704 - kproc->ti_sci = NULL; 705 - goto free_rproc; 706 - } 709 + kproc->ti_sci = devm_ti_sci_get_by_phandle(dev, "ti,sci"); 710 + if (IS_ERR(kproc->ti_sci)) 711 + return dev_err_probe(dev, PTR_ERR(kproc->ti_sci), 712 + "failed to get ti-sci handle\n"); 707 713 708 714 ret = of_property_read_u32(np, "ti,sci-dev-id", &kproc->ti_sci_id); 709 - if (ret) { 710 - dev_err_probe(dev, ret, "missing 'ti,sci-dev-id' property\n"); 711 - goto put_sci; 712 - } 715 + if (ret) 716 + return dev_err_probe(dev, ret, "missing 'ti,sci-dev-id' property\n"); 713 717 714 718 kproc->reset = devm_reset_control_get_exclusive(dev, NULL); 715 - if (IS_ERR(kproc->reset)) { 716 - ret = dev_err_probe(dev, PTR_ERR(kproc->reset), 717 - "failed to get reset\n"); 718 - goto put_sci; 719 - } 719 + if (IS_ERR(kproc->reset)) 720 + return dev_err_probe(dev, PTR_ERR(kproc->reset), 721 + "failed to get reset\n"); 720 722 721 723 kproc->tsp = k3_dsp_rproc_of_get_tsp(dev, kproc->ti_sci); 722 - if (IS_ERR(kproc->tsp)) { 723 - ret = dev_err_probe(dev, PTR_ERR(kproc->tsp), 724 - "failed to construct ti-sci proc control\n"); 725 - goto put_sci; 726 - } 724 + if (IS_ERR(kproc->tsp)) 725 + return dev_err_probe(dev, PTR_ERR(kproc->tsp), 726 + "failed to construct ti-sci proc control\n"); 727 727 728 728 ret = ti_sci_proc_request(kproc->tsp); 729 729 if (ret < 0) { 730 730 dev_err_probe(dev, ret, "ti_sci_proc_request failed\n"); 731 - goto free_tsp; 731 + return ret; 732 732 } 733 + ret = devm_add_action_or_reset(dev, k3_dsp_release_tsp, kproc->tsp); 734 + if (ret) 735 + return ret; 733 736 734 737 ret = k3_dsp_rproc_of_get_memories(pdev, kproc); 735 738 if (ret) 736 - goto release_tsp; 739 + return ret; 737 740 738 741 ret = k3_dsp_reserved_mem_init(kproc); 739 - if (ret) { 740 - dev_err_probe(dev, ret, "reserved memory init failed\n"); 741 - goto release_tsp; 742 - } 742 + if (ret) 743 + return dev_err_probe(dev, ret, "reserved memory init failed\n"); 743 744 744 745 ret = kproc->ti_sci->ops.dev_ops.is_on(kproc->ti_sci, kproc->ti_sci_id, 745 746 NULL, &p_state); 746 - if (ret) { 747 - dev_err_probe(dev, ret, "failed to get initial state, mode cannot be determined\n"); 748 - goto release_mem; 749 - } 747 + if (ret) 748 + return dev_err_probe(dev, ret, "failed to get initial state, mode cannot be determined\n"); 750 749 751 750 /* configure J721E devices for either remoteproc or IPC-only mode */ 752 751 if (p_state) { ··· 760 779 if (data->uses_lreset) { 761 780 ret = reset_control_status(kproc->reset); 762 781 if (ret < 0) { 763 - dev_err_probe(dev, ret, "failed to get reset status\n"); 764 - goto release_mem; 782 + return dev_err_probe(dev, ret, "failed to get reset status\n"); 765 783 } else if (ret == 0) { 766 784 dev_warn(dev, "local reset is deasserted for device\n"); 767 785 k3_dsp_rproc_reset(kproc); ··· 768 788 } 769 789 } 770 790 771 - ret = rproc_add(rproc); 772 - if (ret) { 773 - dev_err_probe(dev, ret, "failed to add register device with remoteproc core\n"); 774 - goto release_mem; 775 - } 791 + ret = devm_rproc_add(dev, rproc); 792 + if (ret) 793 + return dev_err_probe(dev, ret, "failed to add register device with remoteproc core\n"); 776 794 777 795 platform_set_drvdata(pdev, kproc); 778 796 779 797 return 0; 780 - 781 - release_mem: 782 - k3_dsp_reserved_mem_exit(kproc); 783 - release_tsp: 784 - ret1 = ti_sci_proc_release(kproc->tsp); 785 - if (ret1) 786 - dev_err(dev, "failed to release proc (%pe)\n", ERR_PTR(ret1)); 787 - free_tsp: 788 - kfree(kproc->tsp); 789 - put_sci: 790 - ret1 = ti_sci_put_handle(kproc->ti_sci); 791 - if (ret1) 792 - dev_err(dev, "failed to put ti_sci handle (%pe)\n", ERR_PTR(ret1)); 793 - free_rproc: 794 - rproc_free(rproc); 795 - return ret; 796 798 } 797 799 798 800 static void k3_dsp_rproc_remove(struct platform_device *pdev) ··· 786 824 787 825 if (rproc->state == RPROC_ATTACHED) { 788 826 ret = rproc_detach(rproc); 789 - if (ret) { 790 - /* Note this error path leaks resources */ 827 + if (ret) 791 828 dev_err(dev, "failed to detach proc (%pe)\n", ERR_PTR(ret)); 792 - return; 793 - } 794 829 } 795 - 796 - rproc_del(kproc->rproc); 797 - 798 - ret = ti_sci_proc_release(kproc->tsp); 799 - if (ret) 800 - dev_err(dev, "failed to release proc (%pe)\n", ERR_PTR(ret)); 801 - 802 - kfree(kproc->tsp); 803 - 804 - ret = ti_sci_put_handle(kproc->ti_sci); 805 - if (ret) 806 - dev_err(dev, "failed to put ti_sci handle (%pe)\n", ERR_PTR(ret)); 807 - 808 - k3_dsp_reserved_mem_exit(kproc); 809 - rproc_free(kproc->rproc); 810 830 } 811 831 812 832 static const struct k3_dsp_mem_data c66_mems[] = {