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 908bc2209c2bbf1678d0dceed7530b45284be96e..66839c694b693b7a0b313a1a49e4ccb3ccc81d8b 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 01606513791f2457a49dbfee9267c0e0a3ca3476..f1fce91190128e380006c63465a0b2abebf56a0b 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 a43715309eed5de8abd422fd9ed7ac68eaf4b166..0f81e7c3e798e1c128499d163ef5f0b2279acf3c 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 c114369493bffcc5501beb1581eca58f8ec3cb75..7faa979f5caa9c072eb5ea8e789fc77bf49a36a0 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,