github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-26 16:12:59 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

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

Browse Source 
The .unprepare rproc ops implementations in TI K3 DSP and M4 remoteproc
drivers assert the module reset on the remote processor. Refactor the
implementations into ti_k3_common.c driver as k3_rproc_unprepare() and
register this common function as .unprepare ops in 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-27-b-padhi@ti.com
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
This commit is contained in:
Beleswar Padhi 2025-05-13 11:15:00 +05:30 committed by Mathieu Poirier
parent de277002ff
commit 3059abb7d3
4 changed files with 33 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
drivers/remoteproc/ti_k3_common.c
View File

@ -237,5 +237,35 @@ int k3_rproc_prepare(struct rproc *rproc)
}
EXPORT_SYMBOL_GPL(k3_rproc_prepare);
/*
* This function implements the .unprepare() ops and performs the complimentary
* operations to that of the .prepare() ops. The function is used to assert the
* global reset on applicable K3 DSP and M4 cores. This completes the second
* portion of powering down the remote core. The cores themselves are only
* halted in the .stop() callback through the local reset, and the .unprepare()
* ops is invoked by the remoteproc core after the remoteproc is stopped to
* balance the global reset.
*/
int k3_rproc_unprepare(struct rproc *rproc)
{
struct k3_rproc *kproc = rproc->priv;
struct device *dev = kproc->dev;
int ret;
/* If the core is going to be detached do not assert the module reset */
if (rproc->state == RPROC_DETACHED)
return 0;
ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
kproc->ti_sci_id);
if (ret) {
dev_err(dev, "module-reset assert failed\n");
return ret;
}
return 0;
}
EXPORT_SYMBOL_GPL(k3_rproc_unprepare);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("TI K3 common Remoteproc code");

1
drivers/remoteproc/ti_k3_common.h
View File

@ -99,4 +99,5 @@ 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);
int k3_rproc_unprepare(struct rproc *rproc);
#endif /* REMOTEPROC_TI_K3_COMMON_H */

29
drivers/remoteproc/ti_k3_dsp_remoteproc.c
View File

@ -24,33 +24,6 @@
#define KEYSTONE_RPROC_LOCAL_ADDRESS_MASK (SZ_16M - 1)
/*
* This function implements the .unprepare() ops and performs the complimentary
* operations to that of the .prepare() ops. The function is used to assert the
* global reset on applicable C66x cores. This completes the second portion of
* powering down the C66x DSP cores. The cores themselves are only halted in the
* .stop() callback through the local reset, and the .unprepare() ops is invoked
* by the remoteproc core after the remoteproc is stopped to balance the global
* reset. This callback is invoked only in remoteproc mode.
*/
static int k3_dsp_rproc_unprepare(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;
ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
kproc->ti_sci_id);
if (ret)
dev_err(dev, "module-reset assert failed (%pe)\n", ERR_PTR(ret));
return ret;
}
/*
* Power up the DSP remote processor.
*
@ -384,7 +357,7 @@ static int k3_dsp_rproc_probe(struct platform_device *pdev)
rproc->recovery_disabled = true;
if (data->uses_lreset) {
rproc->ops->prepare = k3_rproc_prepare;
rproc->ops->unprepare = k3_dsp_rproc_unprepare;
rproc->ops->unprepare = k3_rproc_unprepare;
}
kproc = rproc->priv;
kproc->rproc = rproc;

31
drivers/remoteproc/ti_k3_m4_remoteproc.c
View File

@ -21,35 +21,6 @@
#include "ti_sci_proc.h"
#include "ti_k3_common.h"
/*
* This function implements the .unprepare() ops and performs the complimentary
* operations to that of the .prepare() ops. The function is used to assert the
* global reset on applicable cores. This completes the second portion of
* powering down the remote core. The cores themselves are only halted in the
* .stop() callback through the local reset, and the .unprepare() ops is invoked
* by the remoteproc core after the remoteproc is stopped to balance the global
* reset.
*/
static int k3_m4_rproc_unprepare(struct rproc *rproc)
{
struct k3_rproc *kproc = rproc->priv;
struct device *dev = kproc->dev;
int ret;
/* If the core is going to be detached do not assert the module reset */
if (rproc->state == RPROC_DETACHED)
return 0;
ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
kproc->ti_sci_id);
if (ret) {
dev_err(dev, "module-reset assert failed\n");
return ret;
}
return 0;
}
/*
* This function implements the .get_loaded_rsc_table() callback and is used
* to provide the resource table for a booted remote processor in IPC-only
@ -326,7 +297,7 @@ static int k3_m4_rproc_detach(struct rproc *rproc)
static const struct rproc_ops k3_m4_rproc_ops = {
.prepare = k3_rproc_prepare,
.unprepare = k3_m4_rproc_unprepare,
.unprepare = k3_rproc_unprepare,
.start = k3_m4_rproc_start,
.stop = k3_m4_rproc_stop,
.attach = k3_m4_rproc_attach,