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

Pull remoteproc updates from Bjorn Andersson:
 "The bulk of these patches relates to the moving to a void-returning
  remove callback.

  The i.MX HiFi remoteproc driver gets its pm_ops helpers updated to
  resolve build warnings about 'defined but not used' variables in
  certain configurations.

  The ST STM32 remoteproc driver is extended to allow using a SCMI reset
  controller to hold boot, and has an error message corrected.

  The Qualcomm Q6V5 PAS driver gains a missing 'static' qualifier on
  adsp_segment_dump()"

* tag 'rproc-v6.5' of git://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux: (23 commits)
  remoteproc: qcom_q6v5_pas: staticize adsp_segment_dump()
  remoteproc: stm32: Fix error code in stm32_rproc_parse_dt()
  remoteproc: stm32: Allow hold boot management by the SCMI reset controller
  dt-bindings: remoteproc: st,stm32-rproc: Rework reset declarations
  remoteproc: imx_dsp_rproc: use modern pm_ops
  remoteproc: wkup_m3: Convert to platform remove callback returning void
  remoteproc: stm32: Convert to platform remove callback returning void
  remoteproc: st: Convert to platform remove callback returning void
  remoteproc: virtio: Convert to platform remove callback returning void
  remoteproc: rcar: Convert to platform remove callback returning void
  remoteproc: qcom_wcnss: Convert to platform remove callback returning void
  remoteproc: qcom_q6v5_wcss: Convert to platform remove callback returning void
  remoteproc: qcom_q6v5_pas: Convert to platform remove callback returning void
  remoteproc: qcom_q6v5_mss: Convert to platform remove callback returning void
  remoteproc: qcom_q6v5_adsp: Convert to platform remove callback returning void
  remoteproc: pru: Convert to platform remove callback returning void
  remoteproc: omap: Convert to platform remove callback returning void
  remoteproc: mtk_scp: Convert to platform remove callback returning void
  remoteproc: meson_mx_ao_arc: Convert to platform remove callback returning void
  remoteproc: keystone: Convert to platform remove callback returning void
  ...

diff --git a/Documentation/devicetree/bindings/remoteproc/st,stm32-rproc.yaml b/Documentation/devicetree/bindings/remoteproc/st,stm32-rproc.yaml
index 959a56f1b6c78e8e1d61cac5a29be450f27d140b..370af61d8f28033bfa25b690c786380ad8bfad97 100644 (file)
--- a/Documentation/devicetree/bindings/remoteproc/st,stm32-rproc.yaml
+++ b/Documentation/devicetree/bindings/remoteproc/st,stm32-rproc.yaml
@@ -25,7 +25,14 @@ properties:
     maxItems: 3
 
   resets:
-    maxItems: 1
+    minItems: 1
+    maxItems: 2
+
+  reset-names:
+    items:
+      - const: mcu_rst
+      - const: hold_boot
+    minItems: 1
 
   st,syscfg-holdboot:
     description: remote processor reset hold boot
@@ -37,6 +44,7 @@ properties:
           - description: The field mask of the hold boot
 
   st,syscfg-tz:
+    deprecated: true
     description:
       Reference to the system configuration which holds the RCC trust zone mode
     $ref: /schemas/types.yaml#/definitions/phandle-array
@@ -135,22 +143,48 @@ required:
   - compatible
   - reg
   - resets
-  - st,syscfg-holdboot
-  - st,syscfg-tz
+
+allOf:
+  - if:
+      properties:
+        reset-names:
+          not:
+            contains:
+              const: hold_boot
+    then:
+      required:
+        - st,syscfg-holdboot
+    else:
+      properties:
+        st,syscfg-holdboot: false
 
 additionalProperties: false
 
 examples:
   - |
     #include <dt-bindings/reset/stm32mp1-resets.h>
-    m4_rproc: m4@10000000 {
+    m4@10000000 {
       compatible = "st,stm32mp1-m4";
       reg = <0x10000000 0x40000>,
             <0x30000000 0x40000>,
             <0x38000000 0x10000>;
       resets = <&rcc MCU_R>;
+      reset-names = "mcu_rst";
+      /* Hold boot managed using system config*/
       st,syscfg-holdboot = <&rcc 0x10C 0x1>;
-      st,syscfg-tz = <&rcc 0x000 0x1>;
+      st,syscfg-rsc-tbl = <&tamp 0x144 0xFFFFFFFF>;
+      st,syscfg-m4-state = <&tamp 0x148 0xFFFFFFFF>;
+    };
+  - |
+    #include <dt-bindings/reset/stm32mp1-resets.h>
+    m4@10000000 {
+      compatible = "st,stm32mp1-m4";
+      reg = <0x10000000 0x40000>,
+            <0x30000000 0x40000>,
+            <0x38000000 0x10000>;
+      /* Hold boot managed using SCMI reset controller */
+      resets = <&scmi MCU_R>, <&scmi MCU_HOLD_BOOT_R>;
+      reset-names = "mcu_rst", "hold_boot";
       st,syscfg-rsc-tbl = <&tamp 0x144 0xFFFFFFFF>;
       st,syscfg-m4-state = <&tamp 0x148 0xFFFFFFFF>;
     };

diff --git a/drivers/remoteproc/da8xx_remoteproc.c b/drivers/remoteproc/da8xx_remoteproc.c
index 768217f0f5cd9f0ae90e727ba4c4ec4be7a0e3b1..9041a0e07fb257b7d4a3eafccf8febca8d5b8306 100644 (file)
--- a/drivers/remoteproc/da8xx_remoteproc.c
+++ b/drivers/remoteproc/da8xx_remoteproc.c
@@ -357,7 +357,7 @@ free_mem:
        return ret;
 }
 
-static int da8xx_rproc_remove(struct platform_device *pdev)
+static void da8xx_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct da8xx_rproc *drproc = rproc->priv;
@@ -374,8 +374,6 @@ static int da8xx_rproc_remove(struct platform_device *pdev)
        rproc_free(rproc);
        if (dev->of_node)
                of_reserved_mem_device_release(dev);
-
-       return 0;
 }
 
 static const struct of_device_id davinci_rproc_of_match[] __maybe_unused = {
@@ -386,7 +384,7 @@ MODULE_DEVICE_TABLE(of, davinci_rproc_of_match);
 
 static struct platform_driver da8xx_rproc_driver = {
        .probe = da8xx_rproc_probe,
-       .remove = da8xx_rproc_remove,
+       .remove_new = da8xx_rproc_remove,
        .driver = {
                .name = "davinci-rproc",
                .of_match_table = of_match_ptr(davinci_rproc_of_match),

diff --git a/drivers/remoteproc/imx_dsp_rproc.c b/drivers/remoteproc/imx_dsp_rproc.c
index cab06dbf37fb7d2b79eea151e5dc392746e3ac81..d95fa558618998b433b8c7467b6a1143cfa5131b 100644 (file)
--- a/drivers/remoteproc/imx_dsp_rproc.c
+++ b/drivers/remoteproc/imx_dsp_rproc.c
@@ -1161,7 +1161,7 @@ err_put_rproc:
        return ret;
 }
 
-static int imx_dsp_rproc_remove(struct platform_device *pdev)
+static void imx_dsp_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct imx_dsp_rproc *priv = rproc->priv;
@@ -1170,8 +1170,6 @@ static int imx_dsp_rproc_remove(struct platform_device *pdev)
        rproc_del(rproc);
        imx_dsp_detach_pm_domains(priv);
        rproc_free(rproc);
-
-       return 0;
 }
 
 /* pm runtime functions */
@@ -1243,7 +1241,7 @@ out:
        release_firmware(fw);
 }
 
-static __maybe_unused int imx_dsp_suspend(struct device *dev)
+static int imx_dsp_suspend(struct device *dev)
 {
        struct rproc *rproc = dev_get_drvdata(dev);
        struct imx_dsp_rproc *priv = rproc->priv;
@@ -1278,7 +1276,7 @@ out:
        return pm_runtime_force_suspend(dev);
 }
 
-static __maybe_unused int imx_dsp_resume(struct device *dev)
+static int imx_dsp_resume(struct device *dev)
 {
        struct rproc *rproc = dev_get_drvdata(dev);
        int ret = 0;
@@ -1312,9 +1310,8 @@ err:
 }
 
 static const struct dev_pm_ops imx_dsp_rproc_pm_ops = {
-       SET_SYSTEM_SLEEP_PM_OPS(imx_dsp_suspend, imx_dsp_resume)
-       SET_RUNTIME_PM_OPS(imx_dsp_runtime_suspend,
-                          imx_dsp_runtime_resume, NULL)
+       SYSTEM_SLEEP_PM_OPS(imx_dsp_suspend, imx_dsp_resume)
+       RUNTIME_PM_OPS(imx_dsp_runtime_suspend, imx_dsp_runtime_resume, NULL)
 };
 
 static const struct of_device_id imx_dsp_rproc_of_match[] = {
@@ -1328,11 +1325,11 @@ MODULE_DEVICE_TABLE(of, imx_dsp_rproc_of_match);
 
 static struct platform_driver imx_dsp_rproc_driver = {
        .probe = imx_dsp_rproc_probe,
-       .remove = imx_dsp_rproc_remove,
+       .remove_new = imx_dsp_rproc_remove,
        .driver = {
                .name = "imx-dsp-rproc",
                .of_match_table = imx_dsp_rproc_of_match,
-               .pm = &imx_dsp_rproc_pm_ops,
+               .pm = pm_ptr(&imx_dsp_rproc_pm_ops),
        },
 };
 module_platform_driver(imx_dsp_rproc_driver);

diff --git a/drivers/remoteproc/imx_rproc.c b/drivers/remoteproc/imx_rproc.c
index 0ab840dc7e97f7d4bac652f81f4af1fbf6f7d88e..f9874fc5a80ff56cd448156d20e69b2ccc74a84d 100644 (file)
--- a/drivers/remoteproc/imx_rproc.c
+++ b/drivers/remoteproc/imx_rproc.c
@@ -1112,7 +1112,7 @@ err_put_rproc:
        return ret;
 }
 
-static int imx_rproc_remove(struct platform_device *pdev)
+static void imx_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct imx_rproc *priv = rproc->priv;
@@ -1123,8 +1123,6 @@ static int imx_rproc_remove(struct platform_device *pdev)
        imx_rproc_free_mbox(rproc);
        destroy_workqueue(priv->workqueue);
        rproc_free(rproc);
-
-       return 0;
 }
 
 static const struct of_device_id imx_rproc_of_match[] = {
@@ -1145,7 +1143,7 @@ MODULE_DEVICE_TABLE(of, imx_rproc_of_match);
 
 static struct platform_driver imx_rproc_driver = {
        .probe = imx_rproc_probe,
-       .remove = imx_rproc_remove,
+       .remove_new = imx_rproc_remove,
        .driver = {
                .name = "imx-rproc",
                .of_match_table = imx_rproc_of_match,

diff --git a/drivers/remoteproc/keystone_remoteproc.c b/drivers/remoteproc/keystone_remoteproc.c
index 95b39741925dbf88a7f7534548ca86b71d2d3eed..7e57b90bcaf85cc249acb6bf478e77ef3c079efe 100644 (file)
--- a/drivers/remoteproc/keystone_remoteproc.c
+++ b/drivers/remoteproc/keystone_remoteproc.c
@@ -476,7 +476,7 @@ free_rproc:
        return ret;
 }
 
-static int keystone_rproc_remove(struct platform_device *pdev)
+static void keystone_rproc_remove(struct platform_device *pdev)
 {
        struct keystone_rproc *ksproc = platform_get_drvdata(pdev);
 
@@ -486,8 +486,6 @@ static int keystone_rproc_remove(struct platform_device *pdev)
        pm_runtime_disable(&pdev->dev);
        rproc_free(ksproc->rproc);
        of_reserved_mem_device_release(&pdev->dev);
-
-       return 0;
 }
 
 static const struct of_device_id keystone_rproc_of_match[] = {
@@ -501,7 +499,7 @@ MODULE_DEVICE_TABLE(of, keystone_rproc_of_match);
 
 static struct platform_driver keystone_rproc_driver = {
        .probe  = keystone_rproc_probe,
-       .remove = keystone_rproc_remove,
+       .remove_new = keystone_rproc_remove,
        .driver = {
                .name = "keystone-rproc",
                .of_match_table = keystone_rproc_of_match,

diff --git a/drivers/remoteproc/meson_mx_ao_arc.c b/drivers/remoteproc/meson_mx_ao_arc.c
index 462cddab6518d73790f7ff2322093fdc3c8b2ca3..f6744b53832308a2b2a45455ecab1535ffa20cd8 100644 (file)
--- a/drivers/remoteproc/meson_mx_ao_arc.c
+++ b/drivers/remoteproc/meson_mx_ao_arc.c
@@ -228,15 +228,13 @@ err_free_genpool:
        return ret;
 }
 
-static int meson_mx_ao_arc_rproc_remove(struct platform_device *pdev)
+static void meson_mx_ao_arc_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct meson_mx_ao_arc_rproc_priv *priv = rproc->priv;
 
        rproc_del(rproc);
        gen_pool_free(priv->sram_pool, priv->sram_va, priv->sram_size);
-
-       return 0;
 }
 
 static const struct of_device_id meson_mx_ao_arc_rproc_match[] = {
@@ -248,7 +246,7 @@ MODULE_DEVICE_TABLE(of, meson_mx_ao_arc_rproc_match);
 
 static struct platform_driver meson_mx_ao_arc_rproc_driver = {
        .probe = meson_mx_ao_arc_rproc_probe,
-       .remove = meson_mx_ao_arc_rproc_remove,
+       .remove_new = meson_mx_ao_arc_rproc_remove,
        .driver = {
                .name = "meson-mx-ao-arc-rproc",
                .of_match_table = meson_mx_ao_arc_rproc_match,

diff --git a/drivers/remoteproc/mtk_scp.c b/drivers/remoteproc/mtk_scp.c
index e1d93e63d7df6d1917bf57aadf5f60b3baa69c95..dcc94ee2458d8ef5f415c0ede6fdc144b7834168 100644 (file)
--- a/drivers/remoteproc/mtk_scp.c
+++ b/drivers/remoteproc/mtk_scp.c
@@ -913,7 +913,7 @@ release_dev_mem:
        return ret;
 }
 
-static int scp_remove(struct platform_device *pdev)
+static void scp_remove(struct platform_device *pdev)
 {
        struct mtk_scp *scp = platform_get_drvdata(pdev);
        int i;
@@ -925,8 +925,6 @@ static int scp_remove(struct platform_device *pdev)
        for (i = 0; i < SCP_IPI_MAX; i++)
                mutex_destroy(&scp->ipi_desc[i].lock);
        mutex_destroy(&scp->send_lock);
-
-       return 0;
 }
 
 static const struct mtk_scp_of_data mt8183_of_data = {
@@ -1003,7 +1001,7 @@ MODULE_DEVICE_TABLE(of, mtk_scp_of_match);
 
 static struct platform_driver mtk_scp_driver = {
        .probe = scp_probe,
-       .remove = scp_remove,
+       .remove_new = scp_remove,
        .driver = {
                .name = "mtk-scp",
                .of_match_table = mtk_scp_of_match,

diff --git a/drivers/remoteproc/omap_remoteproc.c b/drivers/remoteproc/omap_remoteproc.c
index 430fab0266eda7015825050d1b91228363c0dced..82ed90f03d91bf93f1fc45a6b49a3fddd60c64b0 100644 (file)
--- a/drivers/remoteproc/omap_remoteproc.c
+++ b/drivers/remoteproc/omap_remoteproc.c
@@ -1363,15 +1363,13 @@ free_rproc:
        return ret;
 }
 
-static int omap_rproc_remove(struct platform_device *pdev)
+static void omap_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
 
        rproc_del(rproc);
        rproc_free(rproc);
        of_reserved_mem_device_release(&pdev->dev);
-
-       return 0;
 }
 
 static const struct dev_pm_ops omap_rproc_pm_ops = {
@@ -1382,7 +1380,7 @@ static const struct dev_pm_ops omap_rproc_pm_ops = {
 
 static struct platform_driver omap_rproc_driver = {
        .probe = omap_rproc_probe,
-       .remove = omap_rproc_remove,
+       .remove_new = omap_rproc_remove,
        .driver = {
                .name = "omap-rproc",
                .pm = &omap_rproc_pm_ops,

diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c
index 54f5ce302e7a2bf3b442295b136797951de62f1f..2874c8d324f79cb238eb23d9d1216fb9f9c4b7ec 100644 (file)
--- a/drivers/remoteproc/pru_rproc.c
+++ b/drivers/remoteproc/pru_rproc.c
@@ -1056,14 +1056,12 @@ static int pru_rproc_probe(struct platform_device *pdev)
        return 0;
 }
 
-static int pru_rproc_remove(struct platform_device *pdev)
+static void pru_rproc_remove(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct rproc *rproc = platform_get_drvdata(pdev);
 
        dev_dbg(dev, "%s: removing rproc %s\n", __func__, rproc->name);
-
-       return 0;
 }
 
 static const struct pru_private_data pru_data = {
@@ -1111,7 +1109,7 @@ static struct platform_driver pru_rproc_driver = {
                .suppress_bind_attrs = true,
        },
        .probe  = pru_rproc_probe,
-       .remove = pru_rproc_remove,
+       .remove_new = pru_rproc_remove,
 };
 module_platform_driver(pru_rproc_driver);
 

diff --git a/drivers/remoteproc/qcom_q6v5_adsp.c b/drivers/remoteproc/qcom_q6v5_adsp.c
index d546ab9dc1413876a22aca6ac5cb251cd7f2422a..6777a3bd62264c2204bfb508385007cb10fbce9e 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_adsp.c
+++ b/drivers/remoteproc/qcom_q6v5_adsp.c
@@ -763,7 +763,7 @@ free_rproc:
        return ret;
 }
 
-static int adsp_remove(struct platform_device *pdev)
+static void adsp_remove(struct platform_device *pdev)
 {
        struct qcom_adsp *adsp = platform_get_drvdata(pdev);
 
@@ -775,8 +775,6 @@ static int adsp_remove(struct platform_device *pdev)
        qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev);
        qcom_rproc_pds_detach(adsp, adsp->proxy_pds, adsp->proxy_pd_count);
        rproc_free(adsp->rproc);
-
-       return 0;
 }
 
 static const struct adsp_pil_data adsp_resource_init = {
@@ -859,7 +857,7 @@ MODULE_DEVICE_TABLE(of, adsp_of_match);
 
 static struct platform_driver adsp_pil_driver = {
        .probe = adsp_probe,
-       .remove = adsp_remove,
+       .remove_new = adsp_remove,
        .driver = {
                .name = "qcom_q6v5_adsp",
                .of_match_table = adsp_of_match,

diff --git a/drivers/remoteproc/qcom_q6v5_mss.c b/drivers/remoteproc/qcom_q6v5_mss.c
index 8e15e4f85de13a781bf6672d9bc560c6460b3dce..70bffc9f33f6cc833f4add2ac3b5f2da629ee176 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_mss.c
+++ b/drivers/remoteproc/qcom_q6v5_mss.c
@@ -2110,7 +2110,7 @@ free_rproc:
        return ret;
 }
 
-static int q6v5_remove(struct platform_device *pdev)
+static void q6v5_remove(struct platform_device *pdev)
 {
        struct q6v5 *qproc = platform_get_drvdata(pdev);
        struct rproc *rproc = qproc->rproc;
@@ -2128,8 +2128,6 @@ static int q6v5_remove(struct platform_device *pdev)
        q6v5_pds_detach(qproc, qproc->proxy_pds, qproc->proxy_pd_count);
 
        rproc_free(rproc);
-
-       return 0;
 }
 
 static const struct rproc_hexagon_res sc7180_mss = {
@@ -2482,7 +2480,7 @@ MODULE_DEVICE_TABLE(of, q6v5_of_match);
 
 static struct platform_driver q6v5_driver = {
        .probe = q6v5_probe,
-       .remove = q6v5_remove,
+       .remove_new = q6v5_remove,
        .driver = {
                .name = "qcom-q6v5-mss",
                .of_match_table = q6v5_of_match,

diff --git a/drivers/remoteproc/qcom_q6v5_pas.c b/drivers/remoteproc/qcom_q6v5_pas.c
index e34d82b18a67b6a312c662d4423b2b3c68067be9..3153d82037e717a713dab0d7dd21fa967d583fb5 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_pas.c
+++ b/drivers/remoteproc/qcom_q6v5_pas.c
@@ -105,7 +105,7 @@ struct qcom_adsp {
        struct qcom_scm_pas_metadata dtb_pas_metadata;
 };
 
-void adsp_segment_dump(struct rproc *rproc, struct rproc_dump_segment *segment,
+static void adsp_segment_dump(struct rproc *rproc, struct rproc_dump_segment *segment,
                       void *dest, size_t offset, size_t size)
 {
        struct qcom_adsp *adsp = rproc->priv;
@@ -754,7 +754,7 @@ free_rproc:
        return ret;
 }
 
-static int adsp_remove(struct platform_device *pdev)
+static void adsp_remove(struct platform_device *pdev)
 {
        struct qcom_adsp *adsp = platform_get_drvdata(pdev);
 
@@ -769,8 +769,6 @@ static int adsp_remove(struct platform_device *pdev)
        adsp_pds_detach(adsp, adsp->proxy_pds, adsp->proxy_pd_count);
        device_init_wakeup(adsp->dev, false);
        rproc_free(adsp->rproc);
-
-       return 0;
 }
 
 static const struct adsp_data adsp_resource_init = {
@@ -1232,7 +1230,7 @@ MODULE_DEVICE_TABLE(of, adsp_of_match);
 
 static struct platform_driver adsp_driver = {
        .probe = adsp_probe,
-       .remove = adsp_remove,
+       .remove_new = adsp_remove,
        .driver = {
                .name = "qcom_q6v5_pas",
                .of_match_table = adsp_of_match,

diff --git a/drivers/remoteproc/qcom_q6v5_wcss.c b/drivers/remoteproc/qcom_q6v5_wcss.c
index ba24d745b2d65c692f4a611b5e65d72423831481..b437044aa12674b6169eed462b23c44d706877eb 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_wcss.c
+++ b/drivers/remoteproc/qcom_q6v5_wcss.c
@@ -1074,7 +1074,7 @@ free_rproc:
        return ret;
 }
 
-static int q6v5_wcss_remove(struct platform_device *pdev)
+static void q6v5_wcss_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct q6v5_wcss *wcss = rproc->priv;
@@ -1082,8 +1082,6 @@ static int q6v5_wcss_remove(struct platform_device *pdev)
        qcom_q6v5_deinit(&wcss->q6v5);
        rproc_del(rproc);
        rproc_free(rproc);
-
-       return 0;
 }
 
 static const struct wcss_data wcss_ipq8074_res_init = {
@@ -1117,7 +1115,7 @@ MODULE_DEVICE_TABLE(of, q6v5_wcss_of_match);
 
 static struct platform_driver q6v5_wcss_driver = {
        .probe = q6v5_wcss_probe,
-       .remove = q6v5_wcss_remove,
+       .remove_new = q6v5_wcss_remove,
        .driver = {
                .name = "qcom-q6v5-wcss-pil",
                .of_match_table = q6v5_wcss_of_match,

diff --git a/drivers/remoteproc/qcom_wcnss.c b/drivers/remoteproc/qcom_wcnss.c
index 0fc3172650644c862c341677f2d38790da926c3a..1ed0647bc962d90f7ccdbfcb37aad4c66e026f7d 100644 (file)
--- a/drivers/remoteproc/qcom_wcnss.c
+++ b/drivers/remoteproc/qcom_wcnss.c
@@ -666,7 +666,7 @@ free_rproc:
        return ret;
 }
 
-static int wcnss_remove(struct platform_device *pdev)
+static void wcnss_remove(struct platform_device *pdev)
 {
        struct qcom_wcnss *wcnss = platform_get_drvdata(pdev);
 
@@ -678,8 +678,6 @@ static int wcnss_remove(struct platform_device *pdev)
        qcom_remove_smd_subdev(wcnss->rproc, &wcnss->smd_subdev);
        wcnss_release_pds(wcnss);
        rproc_free(wcnss->rproc);
-
-       return 0;
 }
 
 static const struct of_device_id wcnss_of_match[] = {
@@ -693,7 +691,7 @@ MODULE_DEVICE_TABLE(of, wcnss_of_match);
 
 static struct platform_driver wcnss_driver = {
        .probe = wcnss_probe,
-       .remove = wcnss_remove,
+       .remove_new = wcnss_remove,
        .driver = {
                .name = "qcom-wcnss-pil",
                .of_match_table = wcnss_of_match,

diff --git a/drivers/remoteproc/rcar_rproc.c b/drivers/remoteproc/rcar_rproc.c
index 1ff2a73ade90734ae928cff967840f08206bbed3..90e8769d5624869dd53ef9171e9d80cd3873b879 100644 (file)
--- a/drivers/remoteproc/rcar_rproc.c
+++ b/drivers/remoteproc/rcar_rproc.c
@@ -197,13 +197,11 @@ pm_disable:
        return ret;
 }
 
-static int rcar_rproc_remove(struct platform_device *pdev)
+static void rcar_rproc_remove(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
 
        pm_runtime_disable(dev);
-
-       return 0;
 }
 
 static const struct of_device_id rcar_rproc_of_match[] = {
@@ -215,7 +213,7 @@ MODULE_DEVICE_TABLE(of, rcar_rproc_of_match);
 
 static struct platform_driver rcar_rproc_driver = {
        .probe = rcar_rproc_probe,
-       .remove = rcar_rproc_remove,
+       .remove_new = rcar_rproc_remove,
        .driver = {
                .name = "rcar-rproc",
                .of_match_table = rcar_rproc_of_match,

diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index 0e95525c1158156cf76b1cb71f78e582ddc74eeb..83d76915a6ad6f28f930b705c274dc82897b36de 100644 (file)
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -569,7 +569,7 @@ unwind_vring_allocations:
        return ret;
 }
 
-static int rproc_virtio_remove(struct platform_device *pdev)
+static void rproc_virtio_remove(struct platform_device *pdev)
 {
        struct rproc_vdev *rvdev = dev_get_drvdata(&pdev->dev);
        struct rproc *rproc = rvdev->rproc;
@@ -588,14 +588,12 @@ static int rproc_virtio_remove(struct platform_device *pdev)
        dma_release_coherent_memory(&pdev->dev);
 
        put_device(&rproc->dev);
-
-       return 0;
 }
 
 /* Platform driver */
 static struct platform_driver rproc_virtio_driver = {
        .probe          = rproc_virtio_probe,
-       .remove         = rproc_virtio_remove,
+       .remove_new     = rproc_virtio_remove,
        .driver         = {
                .name   = "rproc-virtio",
        },

diff --git a/drivers/remoteproc/st_remoteproc.c b/drivers/remoteproc/st_remoteproc.c
index 3f1b8963639f0fd00bd9d91827a60797b1810f89..e3ce01d98b4c7d0fd710bfab1e8ca62839a656a8 100644 (file)
--- a/drivers/remoteproc/st_remoteproc.c
+++ b/drivers/remoteproc/st_remoteproc.c
@@ -448,7 +448,7 @@ free_rproc:
        return ret;
 }
 
-static int st_rproc_remove(struct platform_device *pdev)
+static void st_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct st_rproc *ddata = rproc->priv;
@@ -462,13 +462,11 @@ static int st_rproc_remove(struct platform_device *pdev)
                mbox_free_channel(ddata->mbox_chan[i]);
 
        rproc_free(rproc);
-
-       return 0;
 }
 
 static struct platform_driver st_rproc_driver = {
        .probe = st_rproc_probe,
-       .remove = st_rproc_remove,
+       .remove_new = st_rproc_remove,
        .driver = {
                .name = "st-rproc",
                .of_match_table = of_match_ptr(st_rproc_match),

diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
index e432febf4337b4d1115f1c25acd356186ed648a3..cf073bac79f735b443226fa23e9044522198e1ee 100644 (file)
--- a/drivers/remoteproc/stm32_rproc.c
+++ b/drivers/remoteproc/stm32_rproc.c
@@ -79,6 +79,7 @@ struct stm32_mbox {
 
 struct stm32_rproc {
        struct reset_control *rst;
+       struct reset_control *hold_boot_rst;
        struct stm32_syscon hold_boot;
        struct stm32_syscon pdds;
        struct stm32_syscon m4_state;
@@ -88,7 +89,7 @@ struct stm32_rproc {
        struct stm32_rproc_mem *rmems;
        struct stm32_mbox mb[MBOX_NB_MBX];
        struct workqueue_struct *workqueue;
-       bool secured_soc;
+       bool hold_boot_smc;
        void __iomem *rsc_va;
 };
 
@@ -413,13 +414,28 @@ static int stm32_rproc_set_hold_boot(struct rproc *rproc, bool hold)
        struct arm_smccc_res smc_res;
        int val, err;
 
+       /*
+        * Three ways to manage the hold boot
+        * - using SCMI: the hold boot is managed as a reset,
+        * - using Linux(no SCMI): the hold boot is managed as a syscon register
+        * - using SMC call (deprecated): use SMC reset interface
+        */
+
        val = hold ? HOLD_BOOT : RELEASE_BOOT;
 
-       if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC) && ddata->secured_soc) {
+       if (ddata->hold_boot_rst) {
+               /* Use the SCMI reset controller */
+               if (!hold)
+                       err = reset_control_deassert(ddata->hold_boot_rst);
+               else
+                       err =  reset_control_assert(ddata->hold_boot_rst);
+       } else if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC) && ddata->hold_boot_smc) {
+               /* Use the SMC call */
                arm_smccc_smc(STM32_SMC_RCC, STM32_SMC_REG_WRITE,
                              hold_boot.reg, val, 0, 0, 0, 0, &smc_res);
                err = smc_res.a0;
        } else {
+               /* Use syscon */
                err = regmap_update_bits(hold_boot.map, hold_boot.reg,
                                         hold_boot.mask, val);
        }
@@ -717,34 +733,52 @@ static int stm32_rproc_parse_dt(struct platform_device *pdev,
                dev_info(dev, "wdg irq registered\n");
        }
 
-       ddata->rst = devm_reset_control_get_by_index(dev, 0);
+       ddata->rst = devm_reset_control_get_optional(dev, "mcu_rst");
+       if (!ddata->rst) {
+               /* Try legacy fallback method: get it by index */
+               ddata->rst = devm_reset_control_get_by_index(dev, 0);
+       }
        if (IS_ERR(ddata->rst))
                return dev_err_probe(dev, PTR_ERR(ddata->rst),
                                     "failed to get mcu_reset\n");
 
        /*
-        * if platform is secured the hold boot bit must be written by
-        * smc call and read normally.
-        * if not secure the hold boot bit could be read/write normally
+        * Three ways to manage the hold boot
+        * - using SCMI: the hold boot is managed as a reset
+        *    The DT "reset-mames" property should be defined with 2 items:
+        *        reset-names = "mcu_rst", "hold_boot";
+        * - using SMC call (deprecated): use SMC reset interface
+        *    The DT "reset-mames" property is optional, "st,syscfg-tz" is required
+        * - default(no SCMI, no SMC): the hold boot is managed as a syscon register
+        *    The DT "reset-mames" property is optional, "st,syscfg-holdboot" is required
         */
-       err = stm32_rproc_get_syscon(np, "st,syscfg-tz", &tz);
-       if (err) {
-               dev_err(dev, "failed to get tz syscfg\n");
-               return err;
-       }
 
-       err = regmap_read(tz.map, tz.reg, &tzen);
-       if (err) {
-               dev_err(dev, "failed to read tzen\n");
-               return err;
+       ddata->hold_boot_rst = devm_reset_control_get_optional(dev, "hold_boot");
+       if (IS_ERR(ddata->hold_boot_rst))
+               return dev_err_probe(dev, PTR_ERR(ddata->hold_boot_rst),
+                                    "failed to get hold_boot reset\n");
+
+       if (!ddata->hold_boot_rst && IS_ENABLED(CONFIG_HAVE_ARM_SMCCC)) {
+               /* Manage the MCU_BOOT using SMC call */
+               err = stm32_rproc_get_syscon(np, "st,syscfg-tz", &tz);
+               if (!err) {
+                       err = regmap_read(tz.map, tz.reg, &tzen);
+                       if (err) {
+                               dev_err(dev, "failed to read tzen\n");
+                               return err;
+                       }
+                       ddata->hold_boot_smc = tzen & tz.mask;
+               }
        }
-       ddata->secured_soc = tzen & tz.mask;
 
-       err = stm32_rproc_get_syscon(np, "st,syscfg-holdboot",
-                                    &ddata->hold_boot);
-       if (err) {
-               dev_err(dev, "failed to get hold boot\n");
-               return err;
+       if (!ddata->hold_boot_rst && !ddata->hold_boot_smc) {
+               /* Default: hold boot manage it through the syscon controller */
+               err = stm32_rproc_get_syscon(np, "st,syscfg-holdboot",
+                                            &ddata->hold_boot);
+               if (err) {
+                       dev_err(dev, "failed to get hold boot\n");
+                       return err;
+               }
        }
 
        err = stm32_rproc_get_syscon(np, "st,syscfg-pdds", &ddata->pdds);
@@ -867,7 +901,7 @@ free_rproc:
        return ret;
 }
 
-static int stm32_rproc_remove(struct platform_device *pdev)
+static void stm32_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
        struct stm32_rproc *ddata = rproc->priv;
@@ -885,8 +919,6 @@ static int stm32_rproc_remove(struct platform_device *pdev)
                device_init_wakeup(dev, false);
        }
        rproc_free(rproc);
-
-       return 0;
 }
 
 static int __maybe_unused stm32_rproc_suspend(struct device *dev)
@@ -916,7 +948,7 @@ static SIMPLE_DEV_PM_OPS(stm32_rproc_pm_ops,
 
 static struct platform_driver stm32_rproc_driver = {
        .probe = stm32_rproc_probe,
-       .remove = stm32_rproc_remove,
+       .remove_new = stm32_rproc_remove,
        .driver = {
                .name = "stm32-rproc",
                .pm = &stm32_rproc_pm_ops,

diff --git a/drivers/remoteproc/wkup_m3_rproc.c b/drivers/remoteproc/wkup_m3_rproc.c
index a0c204cb09798f822a6e9001d7ba1881ba92b7ea..120dc7d2dac19e5abed0ba3cba22b8d0f4b81eb4 100644 (file)
--- a/drivers/remoteproc/wkup_m3_rproc.c
+++ b/drivers/remoteproc/wkup_m3_rproc.c
@@ -223,7 +223,7 @@ err:
        return ret;
 }
 
-static int wkup_m3_rproc_remove(struct platform_device *pdev)
+static void wkup_m3_rproc_remove(struct platform_device *pdev)
 {
        struct rproc *rproc = platform_get_drvdata(pdev);
 
@@ -231,8 +231,6 @@ static int wkup_m3_rproc_remove(struct platform_device *pdev)
        rproc_free(rproc);
        pm_runtime_put_sync(&pdev->dev);
        pm_runtime_disable(&pdev->dev);
-
-       return 0;
 }
 
 #ifdef CONFIG_PM
@@ -253,7 +251,7 @@ static const struct dev_pm_ops wkup_m3_rproc_pm_ops = {
 
 static struct platform_driver wkup_m3_rproc_driver = {
        .probe = wkup_m3_rproc_probe,
-       .remove = wkup_m3_rproc_remove,
+       .remove_new = wkup_m3_rproc_remove,
        .driver = {
                .name = "wkup_m3_rproc",
                .of_match_table = wkup_m3_rproc_of_match,