remoteproc: k3: Refactor .prepare rproc ops into common driver

The .prepare rproc ops implementations in TI K3 DSP and M4 remoteproc
drivers deasserts the local and module reset of the processor to allow
firmware loading into internal memory.

Refactor the implementations into the ti_k3_common.c driver as
k3_rproc_prepare() and register this common function as .prepare ops in
the DSP and M4 drivers.

Signed-off-by: Beleswar Padhi <b-padhi@ti.com>
Tested-by: Judith Mendez <jm@ti.com>
Reviewed-by: Andrew Davis <afd@ti.com>
Link: https://lore.kernel.org/r/20250513054510.3439842-26-b-padhi@ti.com
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>

diff --git a/drivers/remoteproc/ti_k3_common.c b/drivers/remoteproc/ti_k3_common.c
index 908bc22..66839c6 100644 (file)
--- a/drivers/remoteproc/ti_k3_common.c
+++ b/drivers/remoteproc/ti_k3_common.c
@@ -191,5 +191,51 @@ int k3_rproc_request_mbox(struct rproc *rproc)
 }
 EXPORT_SYMBOL_GPL(k3_rproc_request_mbox);
 
+/*
+ * The K3 DSP and M4 cores have a local reset that affects only the CPU, and a
+ * generic module reset that powers on the device and allows the internal
+ * memories to be accessed while the local reset is asserted. This function is
+ * used to release the global reset on remote cores to allow loading into the
+ * internal RAMs. The .prepare() ops is invoked by remoteproc core before any
+ * firmware loading, and is followed by the .start() ops after loading to
+ * actually let the remote cores to run.
+ */
+int k3_rproc_prepare(struct rproc *rproc)
+{
+       struct k3_rproc *kproc = rproc->priv;
+       struct device *dev = kproc->dev;
+       int ret;
+
+       /* If the core is running already no need to deassert the module reset */
+       if (rproc->state == RPROC_DETACHED)
+               return 0;
+
+       /*
+        * Ensure the local reset is asserted so the core doesn't
+        * execute bogus code when the module reset is released.
+        */
+       if (kproc->data->uses_lreset) {
+               ret = k3_rproc_reset(kproc);
+               if (ret)
+                       return ret;
+
+               ret = reset_control_status(kproc->reset);
+               if (ret <= 0) {
+                       dev_err(dev, "local reset still not asserted\n");
+                       return ret;
+               }
+       }
+
+       ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci,
+                                                   kproc->ti_sci_id);
+       if (ret) {
+               dev_err(dev, "could not deassert module-reset for internal RAM loading\n");
+               return ret;
+       }
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(k3_rproc_prepare);
+
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("TI K3 common Remoteproc code");

diff --git a/drivers/remoteproc/ti_k3_common.h b/drivers/remoteproc/ti_k3_common.h
index 0160651..f1fce91 100644 (file)
--- a/drivers/remoteproc/ti_k3_common.h
+++ b/drivers/remoteproc/ti_k3_common.h
@@ -98,4 +98,5 @@ void k3_rproc_kick(struct rproc *rproc, int vqid);
 int k3_rproc_reset(struct k3_rproc *kproc);
 int k3_rproc_release(struct k3_rproc *kproc);
 int k3_rproc_request_mbox(struct rproc *rproc);
+int k3_rproc_prepare(struct rproc *rproc);
 #endif /* REMOTEPROC_TI_K3_COMMON_H */

diff --git a/drivers/remoteproc/ti_k3_dsp_remoteproc.c b/drivers/remoteproc/ti_k3_dsp_remoteproc.c
index a437153..0f81e7c 100644 (file)
--- a/drivers/remoteproc/ti_k3_dsp_remoteproc.c
+++ b/drivers/remoteproc/ti_k3_dsp_remoteproc.c
@@ -24,51 +24,6 @@
 
 #define KEYSTONE_RPROC_LOCAL_ADDRESS_MASK      (SZ_16M - 1)
 
-/*
- * The C66x DSP cores have a local reset that affects only the CPU, and a
- * generic module reset that powers on the device and allows the DSP internal
- * memories to be accessed while the local reset is asserted. This function is
- * used to release the global reset on C66x DSPs to allow loading into the DSP
- * internal RAMs. The .prepare() ops is invoked by remoteproc core before any
- * firmware loading, and is followed by the .start() ops after loading to
- * actually let the C66x DSP cores run. This callback is invoked only in
- * remoteproc mode.
- */
-static int k3_dsp_rproc_prepare(struct rproc *rproc)
-{
-       struct k3_rproc *kproc = rproc->priv;
-       struct device *dev = kproc->dev;
-       int ret;
-
-       /* If the core is running already no need to deassert the module reset */
-       if (rproc->state == RPROC_DETACHED)
-               return 0;
-
-       /*
-        * Ensure the local reset is asserted so the core doesn't
-        * execute bogus code when the module reset is released.
-        */
-       if (kproc->data->uses_lreset) {
-               ret = k3_rproc_reset(kproc);
-               if (ret)
-                       return ret;
-
-               ret = reset_control_status(kproc->reset);
-               if (ret <= 0) {
-                       dev_err(dev, "local reset still not asserted\n");
-                       return ret;
-               }
-       }
-
-       ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci,
-                                                   kproc->ti_sci_id);
-       if (ret)
-               dev_err(dev, "module-reset deassert failed, cannot enable internal RAM loading (%pe)\n",
-                       ERR_PTR(ret));
-
-       return ret;
-}
-
 /*
  * This function implements the .unprepare() ops and performs the complimentary
  * operations to that of the .prepare() ops. The function is used to assert the
@@ -428,7 +383,7 @@ static int k3_dsp_rproc_probe(struct platform_device *pdev)
        rproc->has_iommu = false;
        rproc->recovery_disabled = true;
        if (data->uses_lreset) {
-               rproc->ops->prepare = k3_dsp_rproc_prepare;
+               rproc->ops->prepare = k3_rproc_prepare;
                rproc->ops->unprepare = k3_dsp_rproc_unprepare;
        }
        kproc = rproc->priv;

diff --git a/drivers/remoteproc/ti_k3_m4_remoteproc.c b/drivers/remoteproc/ti_k3_m4_remoteproc.c
index c114369..7faa979 100644 (file)
--- a/drivers/remoteproc/ti_k3_m4_remoteproc.c
+++ b/drivers/remoteproc/ti_k3_m4_remoteproc.c
@@ -21,49 +21,6 @@
 #include "ti_sci_proc.h"
 #include "ti_k3_common.h"
 
-/*
- * The M4 cores have a local reset that affects only the CPU, and a
- * generic module reset that powers on the device and allows the internal
- * memories to be accessed while the local reset is asserted. This function is
- * used to release the global reset on remote cores to allow loading into the
- * internal RAMs. The .prepare() ops is invoked by remoteproc core before any
- * firmware loading, and is followed by the .start() ops after loading to
- * actually let the remote cores to run.
- */
-static int k3_m4_rproc_prepare(struct rproc *rproc)
-{
-       struct k3_rproc *kproc = rproc->priv;
-       struct device *dev = kproc->dev;
-       int ret;
-
-       /* If the core is running already no need to deassert the module reset */
-       if (rproc->state == RPROC_DETACHED)
-               return 0;
-
-       /*
-        * Ensure the local reset is asserted so the core doesn't
-        * execute bogus code when the module reset is released.
-        */
-       ret = k3_rproc_reset(kproc);
-       if (ret)
-               return ret;
-
-       ret = reset_control_status(kproc->reset);
-       if (ret <= 0) {
-               dev_err(dev, "local reset still not asserted\n");
-               return ret;
-       }
-
-       ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci,
-                                                   kproc->ti_sci_id);
-       if (ret) {
-               dev_err(dev, "could not deassert module-reset for internal RAM loading\n");
-               return ret;
-       }
-
-       return 0;
-}
-
 /*
  * This function implements the .unprepare() ops and performs the complimentary
  * operations to that of the .prepare() ops. The function is used to assert the
@@ -368,7 +325,7 @@ static int k3_m4_rproc_detach(struct rproc *rproc)
 }
 
 static const struct rproc_ops k3_m4_rproc_ops = {
-       .prepare = k3_m4_rproc_prepare,
+       .prepare = k3_rproc_prepare,
        .unprepare = k3_m4_rproc_unprepare,
        .start = k3_m4_rproc_start,
        .stop = k3_m4_rproc_stop,