* [PATCH v6 00/16] remoteproc: Add support for detaching a remote processor
@ 2021-02-23 23:34 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:34 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Following the work done here [1], this set provides support for the
remoteproc core to release resources associated with a remote processor
without having to switch it off. That way a platform driver can be removed
or the application processor power cycled while the remote processor is
still operating.
Modifications for this revision are detailed in the changelog of each patch
but the main difference is that going from RPROC_RUNNING -> RPROC_DETACHED
is no longer supported to avoid dealing tricky resource table issues.
Applies cleanly on rproc-next (e8b4e9a21af7). I will rebase on 5.12-rc1 when it
comes out next week.
Thanks,
Mathieu
Arnaud POULIQUEN (1):
remoteproc: stm32: Move memory parsing to rproc_ops
Mathieu Poirier (15):
remoteproc: Remove useless check in rproc_del()
remoteproc: Rename function rproc_actuate()
remoteproc: Add new RPROC_ATTACHED state
remoteproc: Properly represent the attached state
remoteproc: Add new get_loaded_rsc_table() to rproc_ops
remoteproc: stm32: Move resource table setup to rproc_ops
remoteproc: Add new detach() remoteproc operation
remoteproc: Introduce function __rproc_detach()
remoteproc: Introduce function rproc_detach()
remoteproc: Properly deal with the resource table when attached
remoteproc: Properly deal with a kernel panic when attached
remoteproc: Properly deal with a start request when attached
remoteproc: Properly deal with a stop request when attached
remoteproc: Properly deal with a detach request when attached
remoteproc: Refactor rproc delete and cdev release path
drivers/remoteproc/remoteproc_cdev.c | 21 +-
drivers/remoteproc/remoteproc_core.c | 263 ++++++++++++++++++++---
drivers/remoteproc/remoteproc_internal.h | 10 +
drivers/remoteproc/remoteproc_sysfs.c | 17 +-
drivers/remoteproc/stm32_rproc.c | 168 +++++++--------
include/linux/remoteproc.h | 21 +-
6 files changed, 362 insertions(+), 138 deletions(-)
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 01/16] remoteproc: Remove useless check in rproc_del()
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Whether started at probe() time or thereafter from the command
line, a remote processor needs to be shut down before the final
cleanup phases can happen. Otherwise the system may be left in
an unpredictable state where the remote processor is expecting
the remoteproc core to be providing services when in fact it
no longer exist.
Invariably calling rproc_shutdown() is fine since it will return
immediately if the remote processor has already been switched
off.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index ab150765d124..d2704501b653 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2347,10 +2347,8 @@ int rproc_del(struct rproc *rproc)
if (!rproc)
return -EINVAL;
- /* if rproc is marked always-on, rproc_add() booted it */
/* TODO: make sure this works with rproc->power > 1 */
- if (rproc->auto_boot)
- rproc_shutdown(rproc);
+ rproc_shutdown(rproc);
mutex_lock(&rproc->lock);
rproc->state = RPROC_DELETED;
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 01/16] remoteproc: Remove useless check in rproc_del()
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Whether started at probe() time or thereafter from the command
line, a remote processor needs to be shut down before the final
cleanup phases can happen. Otherwise the system may be left in
an unpredictable state where the remote processor is expecting
the remoteproc core to be providing services when in fact it
no longer exist.
Invariably calling rproc_shutdown() is fine since it will return
immediately if the remote processor has already been switched
off.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index ab150765d124..d2704501b653 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2347,10 +2347,8 @@ int rproc_del(struct rproc *rproc)
if (!rproc)
return -EINVAL;
- /* if rproc is marked always-on, rproc_add() booted it */
/* TODO: make sure this works with rproc->power > 1 */
- if (rproc->auto_boot)
- rproc_shutdown(rproc);
+ rproc_shutdown(rproc);
mutex_lock(&rproc->lock);
rproc->state = RPROC_DELETED;
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 02/16] remoteproc: Rename function rproc_actuate()
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Rename function rproc_actuate() to rproc_attach(). That way it is
easy to understand that it does the opposite of rproc_detach().
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index d2704501b653..7b66e1e96e4a 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1416,7 +1416,7 @@ static int rproc_start(struct rproc *rproc, const struct firmware *fw)
return ret;
}
-static int rproc_attach(struct rproc *rproc)
+static int __rproc_attach(struct rproc *rproc)
{
struct device *dev = &rproc->dev;
int ret;
@@ -1541,7 +1541,7 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
*/
-static int rproc_actuate(struct rproc *rproc)
+static int rproc_attach(struct rproc *rproc)
{
struct device *dev = &rproc->dev;
int ret;
@@ -1581,7 +1581,7 @@ static int rproc_actuate(struct rproc *rproc)
goto clean_up_resources;
}
- ret = rproc_attach(rproc);
+ ret = __rproc_attach(rproc);
if (ret)
goto clean_up_resources;
@@ -1802,7 +1802,7 @@ int rproc_boot(struct rproc *rproc)
if (rproc->state == RPROC_DETACHED) {
dev_info(dev, "attaching to %s\n", rproc->name);
- ret = rproc_actuate(rproc);
+ ret = rproc_attach(rproc);
} else {
dev_info(dev, "powering up %s\n", rproc->name);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 02/16] remoteproc: Rename function rproc_actuate()
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Rename function rproc_actuate() to rproc_attach(). That way it is
easy to understand that it does the opposite of rproc_detach().
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index d2704501b653..7b66e1e96e4a 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1416,7 +1416,7 @@ static int rproc_start(struct rproc *rproc, const struct firmware *fw)
return ret;
}
-static int rproc_attach(struct rproc *rproc)
+static int __rproc_attach(struct rproc *rproc)
{
struct device *dev = &rproc->dev;
int ret;
@@ -1541,7 +1541,7 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
*/
-static int rproc_actuate(struct rproc *rproc)
+static int rproc_attach(struct rproc *rproc)
{
struct device *dev = &rproc->dev;
int ret;
@@ -1581,7 +1581,7 @@ static int rproc_actuate(struct rproc *rproc)
goto clean_up_resources;
}
- ret = rproc_attach(rproc);
+ ret = __rproc_attach(rproc);
if (ret)
goto clean_up_resources;
@@ -1802,7 +1802,7 @@ int rproc_boot(struct rproc *rproc)
if (rproc->state == RPROC_DETACHED) {
dev_info(dev, "attaching to %s\n", rproc->name);
- ret = rproc_actuate(rproc);
+ ret = rproc_attach(rproc);
} else {
dev_info(dev, "powering up %s\n", rproc->name);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 03/16] remoteproc: Add new RPROC_ATTACHED state
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Add a new RPROC_ATTACHED state to take into account scenarios
where the remoteproc core needs to attach to a remote processor
that is booted by another entity.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_sysfs.c | 1 +
include/linux/remoteproc.h | 7 +++++--
2 files changed, 6 insertions(+), 2 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 1dbef895e65e..4b4aab0d4c4b 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -172,6 +172,7 @@ static const char * const rproc_state_string[] = {
[RPROC_RUNNING] = "running",
[RPROC_CRASHED] = "crashed",
[RPROC_DELETED] = "deleted",
+ [RPROC_ATTACHED] = "attached",
[RPROC_DETACHED] = "detached",
[RPROC_LAST] = "invalid",
};
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index f28ee75d1005..b0a57ff73849 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -405,6 +405,8 @@ struct rproc_ops {
* @RPROC_RUNNING: device is up and running
* @RPROC_CRASHED: device has crashed; need to start recovery
* @RPROC_DELETED: device is deleted
+ * @RPROC_ATTACHED: device has been booted by another entity and the core
+ * has attached to it
* @RPROC_DETACHED: device has been booted by another entity and waiting
* for the core to attach to it
* @RPROC_LAST: just keep this one at the end
@@ -421,8 +423,9 @@ enum rproc_state {
RPROC_RUNNING = 2,
RPROC_CRASHED = 3,
RPROC_DELETED = 4,
- RPROC_DETACHED = 5,
- RPROC_LAST = 6,
+ RPROC_ATTACHED = 5,
+ RPROC_DETACHED = 6,
+ RPROC_LAST = 7,
};
/**
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 03/16] remoteproc: Add new RPROC_ATTACHED state
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Add a new RPROC_ATTACHED state to take into account scenarios
where the remoteproc core needs to attach to a remote processor
that is booted by another entity.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_sysfs.c | 1 +
include/linux/remoteproc.h | 7 +++++--
2 files changed, 6 insertions(+), 2 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 1dbef895e65e..4b4aab0d4c4b 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -172,6 +172,7 @@ static const char * const rproc_state_string[] = {
[RPROC_RUNNING] = "running",
[RPROC_CRASHED] = "crashed",
[RPROC_DELETED] = "deleted",
+ [RPROC_ATTACHED] = "attached",
[RPROC_DETACHED] = "detached",
[RPROC_LAST] = "invalid",
};
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index f28ee75d1005..b0a57ff73849 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -405,6 +405,8 @@ struct rproc_ops {
* @RPROC_RUNNING: device is up and running
* @RPROC_CRASHED: device has crashed; need to start recovery
* @RPROC_DELETED: device is deleted
+ * @RPROC_ATTACHED: device has been booted by another entity and the core
+ * has attached to it
* @RPROC_DETACHED: device has been booted by another entity and waiting
* for the core to attach to it
* @RPROC_LAST: just keep this one at the end
@@ -421,8 +423,9 @@ enum rproc_state {
RPROC_RUNNING = 2,
RPROC_CRASHED = 3,
RPROC_DELETED = 4,
- RPROC_DETACHED = 5,
- RPROC_LAST = 6,
+ RPROC_ATTACHED = 5,
+ RPROC_DETACHED = 6,
+ RPROC_LAST = 7,
};
/**
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 04/16] remoteproc: Properly represent the attached state
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
There is a need to know when a remote processor has been attached
to rather than booted by the remoteproc core. In order to avoid
manipulating two variables, i.e rproc::autonomous and
rproc::state, get rid of the former and simply use the newly
introduced RPROC_ATTACHED state.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 20 +-------------------
drivers/remoteproc/remoteproc_sysfs.c | 5 +----
include/linux/remoteproc.h | 2 --
3 files changed, 2 insertions(+), 25 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 7b66e1e96e4a..8c7e9f1d50d7 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1444,7 +1444,7 @@ static int __rproc_attach(struct rproc *rproc)
goto stop_rproc;
}
- rproc->state = RPROC_RUNNING;
+ rproc->state = RPROC_ATTACHED;
dev_info(dev, "remote processor %s is now attached\n", rproc->name);
@@ -1659,14 +1659,6 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc->state = RPROC_OFFLINE;
- /*
- * The remote processor has been stopped and is now offline, which means
- * that the next time it is brought back online the remoteproc core will
- * be responsible to load its firmware. As such it is no longer
- * autonomous.
- */
- rproc->autonomous = false;
-
dev_info(dev, "stopped remote processor %s\n", rproc->name);
return 0;
@@ -2077,16 +2069,6 @@ int rproc_add(struct rproc *rproc)
if (ret < 0)
return ret;
- /*
- * Remind ourselves the remote processor has been attached to rather
- * than booted by the remoteproc core. This is important because the
- * RPROC_DETACHED state will be lost as soon as the remote processor
- * has been attached to. Used in firmware_show() and reset in
- * rproc_stop().
- */
- if (rproc->state == RPROC_DETACHED)
- rproc->autonomous = true;
-
/* if rproc is marked always-on, request it to boot */
if (rproc->auto_boot) {
ret = rproc_trigger_auto_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 4b4aab0d4c4b..f9694def9b54 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -138,11 +138,8 @@ static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
* If the remote processor has been started by an external
* entity we have no idea of what image it is running. As such
* simply display a generic string rather then rproc->firmware.
- *
- * Here we rely on the autonomous flag because a remote processor
- * may have been attached to and currently in a running state.
*/
- if (rproc->autonomous)
+ if (rproc->state == RPROC_ATTACHED)
firmware = "unknown";
return sprintf(buf, "%s\n", firmware);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index b0a57ff73849..6b0a0ed30a03 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -512,7 +512,6 @@ struct rproc_dump_segment {
* @table_sz: size of @cached_table
* @has_iommu: flag to indicate if remote processor is behind an MMU
* @auto_boot: flag to indicate if remote processor should be auto-started
- * @autonomous: true if an external entity has booted the remote processor
* @dump_segments: list of segments in the firmware
* @nb_vdev: number of vdev currently handled by rproc
* @char_dev: character device of the rproc
@@ -549,7 +548,6 @@ struct rproc {
size_t table_sz;
bool has_iommu;
bool auto_boot;
- bool autonomous;
struct list_head dump_segments;
int nb_vdev;
u8 elf_class;
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 04/16] remoteproc: Properly represent the attached state
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
There is a need to know when a remote processor has been attached
to rather than booted by the remoteproc core. In order to avoid
manipulating two variables, i.e rproc::autonomous and
rproc::state, get rid of the former and simply use the newly
introduced RPROC_ATTACHED state.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 20 +-------------------
drivers/remoteproc/remoteproc_sysfs.c | 5 +----
include/linux/remoteproc.h | 2 --
3 files changed, 2 insertions(+), 25 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 7b66e1e96e4a..8c7e9f1d50d7 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1444,7 +1444,7 @@ static int __rproc_attach(struct rproc *rproc)
goto stop_rproc;
}
- rproc->state = RPROC_RUNNING;
+ rproc->state = RPROC_ATTACHED;
dev_info(dev, "remote processor %s is now attached\n", rproc->name);
@@ -1659,14 +1659,6 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc->state = RPROC_OFFLINE;
- /*
- * The remote processor has been stopped and is now offline, which means
- * that the next time it is brought back online the remoteproc core will
- * be responsible to load its firmware. As such it is no longer
- * autonomous.
- */
- rproc->autonomous = false;
-
dev_info(dev, "stopped remote processor %s\n", rproc->name);
return 0;
@@ -2077,16 +2069,6 @@ int rproc_add(struct rproc *rproc)
if (ret < 0)
return ret;
- /*
- * Remind ourselves the remote processor has been attached to rather
- * than booted by the remoteproc core. This is important because the
- * RPROC_DETACHED state will be lost as soon as the remote processor
- * has been attached to. Used in firmware_show() and reset in
- * rproc_stop().
- */
- if (rproc->state == RPROC_DETACHED)
- rproc->autonomous = true;
-
/* if rproc is marked always-on, request it to boot */
if (rproc->auto_boot) {
ret = rproc_trigger_auto_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 4b4aab0d4c4b..f9694def9b54 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -138,11 +138,8 @@ static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
* If the remote processor has been started by an external
* entity we have no idea of what image it is running. As such
* simply display a generic string rather then rproc->firmware.
- *
- * Here we rely on the autonomous flag because a remote processor
- * may have been attached to and currently in a running state.
*/
- if (rproc->autonomous)
+ if (rproc->state == RPROC_ATTACHED)
firmware = "unknown";
return sprintf(buf, "%s\n", firmware);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index b0a57ff73849..6b0a0ed30a03 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -512,7 +512,6 @@ struct rproc_dump_segment {
* @table_sz: size of @cached_table
* @has_iommu: flag to indicate if remote processor is behind an MMU
* @auto_boot: flag to indicate if remote processor should be auto-started
- * @autonomous: true if an external entity has booted the remote processor
* @dump_segments: list of segments in the firmware
* @nb_vdev: number of vdev currently handled by rproc
* @char_dev: character device of the rproc
@@ -549,7 +548,6 @@ struct rproc {
size_t table_sz;
bool has_iommu;
bool auto_boot;
- bool autonomous;
struct list_head dump_segments;
int nb_vdev;
u8 elf_class;
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 05/16] remoteproc: Add new get_loaded_rsc_table() to rproc_ops
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Add a new get_loaded_rsc_table() operation in order to support
scenarios where the remoteproc core has booted a remote processor
and detaches from it. When re-attaching to the remote processor,
the core needs to know where the resource table has been placed
in memory.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Don't return an error if a resource table doesn't exist.
---
drivers/remoteproc/remoteproc_core.c | 32 ++++++++++++++++++++++++
drivers/remoteproc/remoteproc_internal.h | 10 ++++++++
include/linux/remoteproc.h | 6 ++++-
3 files changed, 47 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 8c7e9f1d50d7..0012b7bdce24 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1537,6 +1537,32 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
return ret;
}
+static int rproc_set_loaded_rsc_table(struct rproc *rproc)
+{
+ struct resource_table *table_ptr;
+ struct device *dev = &rproc->dev;
+ size_t table_sz;
+ int ret;
+
+ table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
+ if (!table_ptr) {
+ /* Not having a resource table is acceptable */
+ return 0;
+ }
+
+ if (IS_ERR(table_ptr)) {
+ ret = PTR_ERR(table_ptr);
+ dev_err(dev, "can't load resource table: %d\n", ret);
+ return ret;
+ }
+
+ rproc->cached_table = NULL;
+ rproc->table_ptr = table_ptr;
+ rproc->table_sz = table_sz;
+
+ return 0;
+}
+
/*
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
@@ -1556,6 +1582,12 @@ static int rproc_attach(struct rproc *rproc)
return ret;
}
+ ret = rproc_set_loaded_rsc_table(rproc);
+ if (ret) {
+ dev_err(dev, "can't load resource table: %d\n", ret);
+ goto disable_iommu;
+ }
+
/* reset max_notifyid */
rproc->max_notifyid = -1;
diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h
index c34002888d2c..4f73aac7e60d 100644
--- a/drivers/remoteproc/remoteproc_internal.h
+++ b/drivers/remoteproc/remoteproc_internal.h
@@ -177,6 +177,16 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
return NULL;
}
+static inline
+struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
+ size_t *size)
+{
+ if (rproc->ops->get_loaded_rsc_table)
+ return rproc->ops->get_loaded_rsc_table(rproc, size);
+
+ return NULL;
+}
+
static inline
bool rproc_u64_fit_in_size_t(u64 val)
{
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 6b0a0ed30a03..51538a7d120d 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -368,7 +368,9 @@ enum rsc_handling_status {
* RSC_HANDLED if resource was handled, RSC_IGNORED if not handled and a
* negative value on error
* @load_rsc_table: load resource table from firmware image
- * @find_loaded_rsc_table: find the loaded resouce table
+ * @find_loaded_rsc_table: find the loaded resource table from firmware image
+ * @get_loaded_rsc_table: get resource table installed in memory
+ * by external entity
* @load: load firmware to memory, where the remote processor
* expects to find it
* @sanity_check: sanity check the fw image
@@ -390,6 +392,8 @@ struct rproc_ops {
int offset, int avail);
struct resource_table *(*find_loaded_rsc_table)(
struct rproc *rproc, const struct firmware *fw);
+ struct resource_table *(*get_loaded_rsc_table)(
+ struct rproc *rproc, size_t *size);
int (*load)(struct rproc *rproc, const struct firmware *fw);
int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 05/16] remoteproc: Add new get_loaded_rsc_table() to rproc_ops
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Add a new get_loaded_rsc_table() operation in order to support
scenarios where the remoteproc core has booted a remote processor
and detaches from it. When re-attaching to the remote processor,
the core needs to know where the resource table has been placed
in memory.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Don't return an error if a resource table doesn't exist.
---
drivers/remoteproc/remoteproc_core.c | 32 ++++++++++++++++++++++++
drivers/remoteproc/remoteproc_internal.h | 10 ++++++++
include/linux/remoteproc.h | 6 ++++-
3 files changed, 47 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 8c7e9f1d50d7..0012b7bdce24 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1537,6 +1537,32 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
return ret;
}
+static int rproc_set_loaded_rsc_table(struct rproc *rproc)
+{
+ struct resource_table *table_ptr;
+ struct device *dev = &rproc->dev;
+ size_t table_sz;
+ int ret;
+
+ table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
+ if (!table_ptr) {
+ /* Not having a resource table is acceptable */
+ return 0;
+ }
+
+ if (IS_ERR(table_ptr)) {
+ ret = PTR_ERR(table_ptr);
+ dev_err(dev, "can't load resource table: %d\n", ret);
+ return ret;
+ }
+
+ rproc->cached_table = NULL;
+ rproc->table_ptr = table_ptr;
+ rproc->table_sz = table_sz;
+
+ return 0;
+}
+
/*
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
@@ -1556,6 +1582,12 @@ static int rproc_attach(struct rproc *rproc)
return ret;
}
+ ret = rproc_set_loaded_rsc_table(rproc);
+ if (ret) {
+ dev_err(dev, "can't load resource table: %d\n", ret);
+ goto disable_iommu;
+ }
+
/* reset max_notifyid */
rproc->max_notifyid = -1;
diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h
index c34002888d2c..4f73aac7e60d 100644
--- a/drivers/remoteproc/remoteproc_internal.h
+++ b/drivers/remoteproc/remoteproc_internal.h
@@ -177,6 +177,16 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
return NULL;
}
+static inline
+struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
+ size_t *size)
+{
+ if (rproc->ops->get_loaded_rsc_table)
+ return rproc->ops->get_loaded_rsc_table(rproc, size);
+
+ return NULL;
+}
+
static inline
bool rproc_u64_fit_in_size_t(u64 val)
{
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 6b0a0ed30a03..51538a7d120d 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -368,7 +368,9 @@ enum rsc_handling_status {
* RSC_HANDLED if resource was handled, RSC_IGNORED if not handled and a
* negative value on error
* @load_rsc_table: load resource table from firmware image
- * @find_loaded_rsc_table: find the loaded resouce table
+ * @find_loaded_rsc_table: find the loaded resource table from firmware image
+ * @get_loaded_rsc_table: get resource table installed in memory
+ * by external entity
* @load: load firmware to memory, where the remote processor
* expects to find it
* @sanity_check: sanity check the fw image
@@ -390,6 +392,8 @@ struct rproc_ops {
int offset, int avail);
struct resource_table *(*find_loaded_rsc_table)(
struct rproc *rproc, const struct firmware *fw);
+ struct resource_table *(*get_loaded_rsc_table)(
+ struct rproc *rproc, size_t *size);
int (*load)(struct rproc *rproc, const struct firmware *fw);
int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 05/16] remoteproc: Add new get_loaded_rsc_table() to rproc_ops
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:14 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:14 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Hi Mathieu,
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Add a new get_loaded_rsc_table() operation in order to support
> scenarios where the remoteproc core has booted a remote processor
> and detaches from it. When re-attaching to the remote processor,
> the core needs to know where the resource table has been placed
> in memory.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> ---
> New for V6:
> - Don't return an error if a resource table doesn't exist.
> ---
>
> drivers/remoteproc/remoteproc_core.c | 32 ++++++++++++++++++++++++
> drivers/remoteproc/remoteproc_internal.h | 10 ++++++++
> include/linux/remoteproc.h | 6 ++++-
> 3 files changed, 47 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 8c7e9f1d50d7..0012b7bdce24 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1537,6 +1537,32 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
> return ret;
> }
>
> +static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> +{
> + struct resource_table *table_ptr;
> + struct device *dev = &rproc->dev;
> + size_t table_sz;
> + int ret;
> +
> + table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
> + if (!table_ptr) {
> + /* Not having a resource table is acceptable */
> + return 0;
Would it be an over protection to set rproc->table_ptr to NULL here?
else
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> + }
> +
> + if (IS_ERR(table_ptr)) {
> + ret = PTR_ERR(table_ptr);
> + dev_err(dev, "can't load resource table: %d\n", ret);
> + return ret;
> + }
> +
> + rproc->cached_table = NULL;
> + rproc->table_ptr = table_ptr;
> + rproc->table_sz = table_sz;
> +
> + return 0;
> +}
> +
> /*
> * Attach to remote processor - similar to rproc_fw_boot() but without
> * the steps that deal with the firmware image.
> @@ -1556,6 +1582,12 @@ static int rproc_attach(struct rproc *rproc)
> return ret;
> }
>
> + ret = rproc_set_loaded_rsc_table(rproc);
> + if (ret) {
> + dev_err(dev, "can't load resource table: %d\n", ret);
> + goto disable_iommu;
> + }
> +
> /* reset max_notifyid */
> rproc->max_notifyid = -1;
>
> diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h
> index c34002888d2c..4f73aac7e60d 100644
> --- a/drivers/remoteproc/remoteproc_internal.h
> +++ b/drivers/remoteproc/remoteproc_internal.h
> @@ -177,6 +177,16 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
> return NULL;
> }
>
> +static inline
> +struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
> + size_t *size)
> +{
> + if (rproc->ops->get_loaded_rsc_table)
> + return rproc->ops->get_loaded_rsc_table(rproc, size);
> +
> + return NULL;
> +}
> +
> static inline
> bool rproc_u64_fit_in_size_t(u64 val)
> {
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index 6b0a0ed30a03..51538a7d120d 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -368,7 +368,9 @@ enum rsc_handling_status {
> * RSC_HANDLED if resource was handled, RSC_IGNORED if not handled and a
> * negative value on error
> * @load_rsc_table: load resource table from firmware image
> - * @find_loaded_rsc_table: find the loaded resouce table
> + * @find_loaded_rsc_table: find the loaded resource table from firmware image
> + * @get_loaded_rsc_table: get resource table installed in memory
> + * by external entity
> * @load: load firmware to memory, where the remote processor
> * expects to find it
> * @sanity_check: sanity check the fw image
> @@ -390,6 +392,8 @@ struct rproc_ops {
> int offset, int avail);
> struct resource_table *(*find_loaded_rsc_table)(
> struct rproc *rproc, const struct firmware *fw);
> + struct resource_table *(*get_loaded_rsc_table)(
> + struct rproc *rproc, size_t *size);
> int (*load)(struct rproc *rproc, const struct firmware *fw);
> int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
> u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 05/16] remoteproc: Add new get_loaded_rsc_table() to rproc_ops
@ 2021-02-26 16:14 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:14 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Hi Mathieu,
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Add a new get_loaded_rsc_table() operation in order to support
> scenarios where the remoteproc core has booted a remote processor
> and detaches from it. When re-attaching to the remote processor,
> the core needs to know where the resource table has been placed
> in memory.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> ---
> New for V6:
> - Don't return an error if a resource table doesn't exist.
> ---
>
> drivers/remoteproc/remoteproc_core.c | 32 ++++++++++++++++++++++++
> drivers/remoteproc/remoteproc_internal.h | 10 ++++++++
> include/linux/remoteproc.h | 6 ++++-
> 3 files changed, 47 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 8c7e9f1d50d7..0012b7bdce24 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1537,6 +1537,32 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
> return ret;
> }
>
> +static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> +{
> + struct resource_table *table_ptr;
> + struct device *dev = &rproc->dev;
> + size_t table_sz;
> + int ret;
> +
> + table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
> + if (!table_ptr) {
> + /* Not having a resource table is acceptable */
> + return 0;
Would it be an over protection to set rproc->table_ptr to NULL here?
else
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> + }
> +
> + if (IS_ERR(table_ptr)) {
> + ret = PTR_ERR(table_ptr);
> + dev_err(dev, "can't load resource table: %d\n", ret);
> + return ret;
> + }
> +
> + rproc->cached_table = NULL;
> + rproc->table_ptr = table_ptr;
> + rproc->table_sz = table_sz;
> +
> + return 0;
> +}
> +
> /*
> * Attach to remote processor - similar to rproc_fw_boot() but without
> * the steps that deal with the firmware image.
> @@ -1556,6 +1582,12 @@ static int rproc_attach(struct rproc *rproc)
> return ret;
> }
>
> + ret = rproc_set_loaded_rsc_table(rproc);
> + if (ret) {
> + dev_err(dev, "can't load resource table: %d\n", ret);
> + goto disable_iommu;
> + }
> +
> /* reset max_notifyid */
> rproc->max_notifyid = -1;
>
> diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h
> index c34002888d2c..4f73aac7e60d 100644
> --- a/drivers/remoteproc/remoteproc_internal.h
> +++ b/drivers/remoteproc/remoteproc_internal.h
> @@ -177,6 +177,16 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
> return NULL;
> }
>
> +static inline
> +struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
> + size_t *size)
> +{
> + if (rproc->ops->get_loaded_rsc_table)
> + return rproc->ops->get_loaded_rsc_table(rproc, size);
> +
> + return NULL;
> +}
> +
> static inline
> bool rproc_u64_fit_in_size_t(u64 val)
> {
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index 6b0a0ed30a03..51538a7d120d 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -368,7 +368,9 @@ enum rsc_handling_status {
> * RSC_HANDLED if resource was handled, RSC_IGNORED if not handled and a
> * negative value on error
> * @load_rsc_table: load resource table from firmware image
> - * @find_loaded_rsc_table: find the loaded resouce table
> + * @find_loaded_rsc_table: find the loaded resource table from firmware image
> + * @get_loaded_rsc_table: get resource table installed in memory
> + * by external entity
> * @load: load firmware to memory, where the remote processor
> * expects to find it
> * @sanity_check: sanity check the fw image
> @@ -390,6 +392,8 @@ struct rproc_ops {
> int offset, int avail);
> struct resource_table *(*find_loaded_rsc_table)(
> struct rproc *rproc, const struct firmware *fw);
> + struct resource_table *(*get_loaded_rsc_table)(
> + struct rproc *rproc, size_t *size);
> int (*load)(struct rproc *rproc, const struct firmware *fw);
> int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
> u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 05/16] remoteproc: Add new get_loaded_rsc_table() to rproc_ops
2021-02-26 16:14 ` Arnaud POULIQUEN
@ 2021-03-01 18:03 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:03 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, bjorn.andersson, arnaud.pouliquen, mcoquelin.stm32,
alexandre.torgue, linux-remoteproc, linux-kernel,
linux-arm-kernel
On Fri, Feb 26, 2021 at 05:14:36PM +0100, Arnaud POULIQUEN wrote:
> Hi Mathieu,
>
Good morning,
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > Add a new get_loaded_rsc_table() operation in order to support
> > scenarios where the remoteproc core has booted a remote processor
> > and detaches from it. When re-attaching to the remote processor,
> > the core needs to know where the resource table has been placed
> > in memory.
> >
> > Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> > ---
> > New for V6:
> > - Don't return an error if a resource table doesn't exist.
> > ---
> >
> > drivers/remoteproc/remoteproc_core.c | 32 ++++++++++++++++++++++++
> > drivers/remoteproc/remoteproc_internal.h | 10 ++++++++
> > include/linux/remoteproc.h | 6 ++++-
> > 3 files changed, 47 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> > index 8c7e9f1d50d7..0012b7bdce24 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -1537,6 +1537,32 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
> > return ret;
> > }
> >
> > +static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> > +{
> > + struct resource_table *table_ptr;
> > + struct device *dev = &rproc->dev;
> > + size_t table_sz;
> > + int ret;
> > +
> > + table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
> > + if (!table_ptr) {
> > + /* Not having a resource table is acceptable */
> > + return 0;
>
> Would it be an over protection to set rproc->table_ptr to NULL here?
>
I thought about that too but since memory for @rproc is allocated with kzalloc()
it wouldn't provide anything more.
> else
>
> Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
>
> Thanks,
> Arnaud
>
> > + }
> > +
> > + if (IS_ERR(table_ptr)) {
> > + ret = PTR_ERR(table_ptr);
> > + dev_err(dev, "can't load resource table: %d\n", ret);
> > + return ret;
> > + }
> > +
> > + rproc->cached_table = NULL;
> > + rproc->table_ptr = table_ptr;
> > + rproc->table_sz = table_sz;
> > +
> > + return 0;
> > +}
> > +
> > /*
> > * Attach to remote processor - similar to rproc_fw_boot() but without
> > * the steps that deal with the firmware image.
> > @@ -1556,6 +1582,12 @@ static int rproc_attach(struct rproc *rproc)
> > return ret;
> > }
> >
> > + ret = rproc_set_loaded_rsc_table(rproc);
> > + if (ret) {
> > + dev_err(dev, "can't load resource table: %d\n", ret);
> > + goto disable_iommu;
> > + }
> > +
> > /* reset max_notifyid */
> > rproc->max_notifyid = -1;
> >
> > diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h
> > index c34002888d2c..4f73aac7e60d 100644
> > --- a/drivers/remoteproc/remoteproc_internal.h
> > +++ b/drivers/remoteproc/remoteproc_internal.h
> > @@ -177,6 +177,16 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
> > return NULL;
> > }
> >
> > +static inline
> > +struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
> > + size_t *size)
> > +{
> > + if (rproc->ops->get_loaded_rsc_table)
> > + return rproc->ops->get_loaded_rsc_table(rproc, size);
> > +
> > + return NULL;
> > +}
> > +
> > static inline
> > bool rproc_u64_fit_in_size_t(u64 val)
> > {
> > diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> > index 6b0a0ed30a03..51538a7d120d 100644
> > --- a/include/linux/remoteproc.h
> > +++ b/include/linux/remoteproc.h
> > @@ -368,7 +368,9 @@ enum rsc_handling_status {
> > * RSC_HANDLED if resource was handled, RSC_IGNORED if not handled and a
> > * negative value on error
> > * @load_rsc_table: load resource table from firmware image
> > - * @find_loaded_rsc_table: find the loaded resouce table
> > + * @find_loaded_rsc_table: find the loaded resource table from firmware image
> > + * @get_loaded_rsc_table: get resource table installed in memory
> > + * by external entity
> > * @load: load firmware to memory, where the remote processor
> > * expects to find it
> > * @sanity_check: sanity check the fw image
> > @@ -390,6 +392,8 @@ struct rproc_ops {
> > int offset, int avail);
> > struct resource_table *(*find_loaded_rsc_table)(
> > struct rproc *rproc, const struct firmware *fw);
> > + struct resource_table *(*get_loaded_rsc_table)(
> > + struct rproc *rproc, size_t *size);
> > int (*load)(struct rproc *rproc, const struct firmware *fw);
> > int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
> > u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
> >
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 05/16] remoteproc: Add new get_loaded_rsc_table() to rproc_ops
@ 2021-03-01 18:03 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:03 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, alexandre.torgue, arnaud.pouliquen, linux-remoteproc,
linux-kernel, bjorn.andersson, mcoquelin.stm32, linux-arm-kernel
On Fri, Feb 26, 2021 at 05:14:36PM +0100, Arnaud POULIQUEN wrote:
> Hi Mathieu,
>
Good morning,
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > Add a new get_loaded_rsc_table() operation in order to support
> > scenarios where the remoteproc core has booted a remote processor
> > and detaches from it. When re-attaching to the remote processor,
> > the core needs to know where the resource table has been placed
> > in memory.
> >
> > Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> > ---
> > New for V6:
> > - Don't return an error if a resource table doesn't exist.
> > ---
> >
> > drivers/remoteproc/remoteproc_core.c | 32 ++++++++++++++++++++++++
> > drivers/remoteproc/remoteproc_internal.h | 10 ++++++++
> > include/linux/remoteproc.h | 6 ++++-
> > 3 files changed, 47 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> > index 8c7e9f1d50d7..0012b7bdce24 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -1537,6 +1537,32 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
> > return ret;
> > }
> >
> > +static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> > +{
> > + struct resource_table *table_ptr;
> > + struct device *dev = &rproc->dev;
> > + size_t table_sz;
> > + int ret;
> > +
> > + table_ptr = rproc_get_loaded_rsc_table(rproc, &table_sz);
> > + if (!table_ptr) {
> > + /* Not having a resource table is acceptable */
> > + return 0;
>
> Would it be an over protection to set rproc->table_ptr to NULL here?
>
I thought about that too but since memory for @rproc is allocated with kzalloc()
it wouldn't provide anything more.
> else
>
> Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
>
> Thanks,
> Arnaud
>
> > + }
> > +
> > + if (IS_ERR(table_ptr)) {
> > + ret = PTR_ERR(table_ptr);
> > + dev_err(dev, "can't load resource table: %d\n", ret);
> > + return ret;
> > + }
> > +
> > + rproc->cached_table = NULL;
> > + rproc->table_ptr = table_ptr;
> > + rproc->table_sz = table_sz;
> > +
> > + return 0;
> > +}
> > +
> > /*
> > * Attach to remote processor - similar to rproc_fw_boot() but without
> > * the steps that deal with the firmware image.
> > @@ -1556,6 +1582,12 @@ static int rproc_attach(struct rproc *rproc)
> > return ret;
> > }
> >
> > + ret = rproc_set_loaded_rsc_table(rproc);
> > + if (ret) {
> > + dev_err(dev, "can't load resource table: %d\n", ret);
> > + goto disable_iommu;
> > + }
> > +
> > /* reset max_notifyid */
> > rproc->max_notifyid = -1;
> >
> > diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h
> > index c34002888d2c..4f73aac7e60d 100644
> > --- a/drivers/remoteproc/remoteproc_internal.h
> > +++ b/drivers/remoteproc/remoteproc_internal.h
> > @@ -177,6 +177,16 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
> > return NULL;
> > }
> >
> > +static inline
> > +struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
> > + size_t *size)
> > +{
> > + if (rproc->ops->get_loaded_rsc_table)
> > + return rproc->ops->get_loaded_rsc_table(rproc, size);
> > +
> > + return NULL;
> > +}
> > +
> > static inline
> > bool rproc_u64_fit_in_size_t(u64 val)
> > {
> > diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> > index 6b0a0ed30a03..51538a7d120d 100644
> > --- a/include/linux/remoteproc.h
> > +++ b/include/linux/remoteproc.h
> > @@ -368,7 +368,9 @@ enum rsc_handling_status {
> > * RSC_HANDLED if resource was handled, RSC_IGNORED if not handled and a
> > * negative value on error
> > * @load_rsc_table: load resource table from firmware image
> > - * @find_loaded_rsc_table: find the loaded resouce table
> > + * @find_loaded_rsc_table: find the loaded resource table from firmware image
> > + * @get_loaded_rsc_table: get resource table installed in memory
> > + * by external entity
> > * @load: load firmware to memory, where the remote processor
> > * expects to find it
> > * @sanity_check: sanity check the fw image
> > @@ -390,6 +392,8 @@ struct rproc_ops {
> > int offset, int avail);
> > struct resource_table *(*find_loaded_rsc_table)(
> > struct rproc *rproc, const struct firmware *fw);
> > + struct resource_table *(*get_loaded_rsc_table)(
> > + struct rproc *rproc, size_t *size);
> > int (*load)(struct rproc *rproc, const struct firmware *fw);
> > int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
> > u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
> >
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 06/16] remoteproc: stm32: Move resource table setup to rproc_ops
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Move the setting of the resource table installed by an external
entity to rproc_ops::get_loaded_rsc_table(). This is to support
scenarios where a remote processor has been started by the core
but is detached at a later stage. To re-attach the remote
processor, the address of the resource table needs to be available
at a later time than the platform driver's probe() function.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
drivers/remoteproc/stm32_rproc.c | 141 +++++++++++++++----------------
1 file changed, 68 insertions(+), 73 deletions(-)
diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
index ccb3c14a0023..f647e565014b 100644
--- a/drivers/remoteproc/stm32_rproc.c
+++ b/drivers/remoteproc/stm32_rproc.c
@@ -546,6 +546,73 @@ static void stm32_rproc_kick(struct rproc *rproc, int vqid)
}
}
+static int stm32_rproc_da_to_pa(struct rproc *rproc,
+ u64 da, phys_addr_t *pa)
+{
+ struct stm32_rproc *ddata = rproc->priv;
+ struct device *dev = rproc->dev.parent;
+ struct stm32_rproc_mem *p_mem;
+ unsigned int i;
+
+ for (i = 0; i < ddata->nb_rmems; i++) {
+ p_mem = &ddata->rmems[i];
+
+ if (da < p_mem->dev_addr ||
+ da >= p_mem->dev_addr + p_mem->size)
+ continue;
+
+ *pa = da - p_mem->dev_addr + p_mem->bus_addr;
+ dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
+
+ return 0;
+ }
+
+ dev_err(dev, "can't translate da %llx\n", da);
+
+ return -EINVAL;
+}
+
+static struct resource_table *
+stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
+{
+ struct stm32_rproc *ddata = rproc->priv;
+ struct device *dev = rproc->dev.parent;
+ phys_addr_t rsc_pa;
+ u32 rsc_da;
+ int err;
+
+ /* The resource table has already been mapped, nothing to do */
+ if (ddata->rsc_va)
+ goto done;
+
+ err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
+ if (err) {
+ dev_err(dev, "failed to read rsc tbl addr\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (!rsc_da)
+ /* no rsc table */
+ return ERR_PTR(-ENOENT);
+
+ err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa);
+ if (err)
+ return ERR_PTR(err);
+
+ ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
+ if (IS_ERR_OR_NULL(ddata->rsc_va)) {
+ dev_err(dev, "Unable to map memory region: %pa+%zx\n",
+ &rsc_pa, RSC_TBL_SIZE);
+ ddata->rsc_va = NULL;
+ return ERR_PTR(-ENOMEM);
+ }
+
+done:
+ /* Assuming the resource table fits in 1kB is fair */
+ *table_sz = RSC_TBL_SIZE;
+ return (struct resource_table *)ddata->rsc_va;
+}
+
static const struct rproc_ops st_rproc_ops = {
.start = stm32_rproc_start,
.stop = stm32_rproc_stop,
@@ -554,6 +621,7 @@ static const struct rproc_ops st_rproc_ops = {
.load = rproc_elf_load_segments,
.parse_fw = stm32_rproc_parse_fw,
.find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
+ .get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table,
.sanity_check = rproc_elf_sanity_check,
.get_boot_addr = rproc_elf_get_boot_addr,
};
@@ -695,75 +763,6 @@ static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
}
-static int stm32_rproc_da_to_pa(struct platform_device *pdev,
- struct stm32_rproc *ddata,
- u64 da, phys_addr_t *pa)
-{
- struct device *dev = &pdev->dev;
- struct stm32_rproc_mem *p_mem;
- unsigned int i;
-
- for (i = 0; i < ddata->nb_rmems; i++) {
- p_mem = &ddata->rmems[i];
-
- if (da < p_mem->dev_addr ||
- da >= p_mem->dev_addr + p_mem->size)
- continue;
-
- *pa = da - p_mem->dev_addr + p_mem->bus_addr;
- dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
-
- return 0;
- }
-
- dev_err(dev, "can't translate da %llx\n", da);
-
- return -EINVAL;
-}
-
-static int stm32_rproc_get_loaded_rsc_table(struct platform_device *pdev,
- struct rproc *rproc,
- struct stm32_rproc *ddata)
-{
- struct device *dev = &pdev->dev;
- phys_addr_t rsc_pa;
- u32 rsc_da;
- int err;
-
- err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
- if (err) {
- dev_err(dev, "failed to read rsc tbl addr\n");
- return err;
- }
-
- if (!rsc_da)
- /* no rsc table */
- return 0;
-
- err = stm32_rproc_da_to_pa(pdev, ddata, rsc_da, &rsc_pa);
- if (err)
- return err;
-
- ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
- if (IS_ERR_OR_NULL(ddata->rsc_va)) {
- dev_err(dev, "Unable to map memory region: %pa+%zx\n",
- &rsc_pa, RSC_TBL_SIZE);
- ddata->rsc_va = NULL;
- return -ENOMEM;
- }
-
- /*
- * The resource table is already loaded in device memory, no need
- * to work with a cached table.
- */
- rproc->cached_table = NULL;
- /* Assuming the resource table fits in 1kB is fair */
- rproc->table_sz = RSC_TBL_SIZE;
- rproc->table_ptr = (struct resource_table *)ddata->rsc_va;
-
- return 0;
-}
-
static int stm32_rproc_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@@ -803,10 +802,6 @@ static int stm32_rproc_probe(struct platform_device *pdev)
ret = stm32_rproc_parse_memory_regions(rproc);
if (ret)
goto free_resources;
-
- ret = stm32_rproc_get_loaded_rsc_table(pdev, rproc, ddata);
- if (ret)
- goto free_resources;
}
rproc->has_iommu = false;
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 06/16] remoteproc: stm32: Move resource table setup to rproc_ops
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Move the setting of the resource table installed by an external
entity to rproc_ops::get_loaded_rsc_table(). This is to support
scenarios where a remote processor has been started by the core
but is detached at a later stage. To re-attach the remote
processor, the address of the resource table needs to be available
at a later time than the platform driver's probe() function.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
drivers/remoteproc/stm32_rproc.c | 141 +++++++++++++++----------------
1 file changed, 68 insertions(+), 73 deletions(-)
diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
index ccb3c14a0023..f647e565014b 100644
--- a/drivers/remoteproc/stm32_rproc.c
+++ b/drivers/remoteproc/stm32_rproc.c
@@ -546,6 +546,73 @@ static void stm32_rproc_kick(struct rproc *rproc, int vqid)
}
}
+static int stm32_rproc_da_to_pa(struct rproc *rproc,
+ u64 da, phys_addr_t *pa)
+{
+ struct stm32_rproc *ddata = rproc->priv;
+ struct device *dev = rproc->dev.parent;
+ struct stm32_rproc_mem *p_mem;
+ unsigned int i;
+
+ for (i = 0; i < ddata->nb_rmems; i++) {
+ p_mem = &ddata->rmems[i];
+
+ if (da < p_mem->dev_addr ||
+ da >= p_mem->dev_addr + p_mem->size)
+ continue;
+
+ *pa = da - p_mem->dev_addr + p_mem->bus_addr;
+ dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
+
+ return 0;
+ }
+
+ dev_err(dev, "can't translate da %llx\n", da);
+
+ return -EINVAL;
+}
+
+static struct resource_table *
+stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
+{
+ struct stm32_rproc *ddata = rproc->priv;
+ struct device *dev = rproc->dev.parent;
+ phys_addr_t rsc_pa;
+ u32 rsc_da;
+ int err;
+
+ /* The resource table has already been mapped, nothing to do */
+ if (ddata->rsc_va)
+ goto done;
+
+ err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
+ if (err) {
+ dev_err(dev, "failed to read rsc tbl addr\n");
+ return ERR_PTR(-EINVAL);
+ }
+
+ if (!rsc_da)
+ /* no rsc table */
+ return ERR_PTR(-ENOENT);
+
+ err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa);
+ if (err)
+ return ERR_PTR(err);
+
+ ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
+ if (IS_ERR_OR_NULL(ddata->rsc_va)) {
+ dev_err(dev, "Unable to map memory region: %pa+%zx\n",
+ &rsc_pa, RSC_TBL_SIZE);
+ ddata->rsc_va = NULL;
+ return ERR_PTR(-ENOMEM);
+ }
+
+done:
+ /* Assuming the resource table fits in 1kB is fair */
+ *table_sz = RSC_TBL_SIZE;
+ return (struct resource_table *)ddata->rsc_va;
+}
+
static const struct rproc_ops st_rproc_ops = {
.start = stm32_rproc_start,
.stop = stm32_rproc_stop,
@@ -554,6 +621,7 @@ static const struct rproc_ops st_rproc_ops = {
.load = rproc_elf_load_segments,
.parse_fw = stm32_rproc_parse_fw,
.find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
+ .get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table,
.sanity_check = rproc_elf_sanity_check,
.get_boot_addr = rproc_elf_get_boot_addr,
};
@@ -695,75 +763,6 @@ static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
}
-static int stm32_rproc_da_to_pa(struct platform_device *pdev,
- struct stm32_rproc *ddata,
- u64 da, phys_addr_t *pa)
-{
- struct device *dev = &pdev->dev;
- struct stm32_rproc_mem *p_mem;
- unsigned int i;
-
- for (i = 0; i < ddata->nb_rmems; i++) {
- p_mem = &ddata->rmems[i];
-
- if (da < p_mem->dev_addr ||
- da >= p_mem->dev_addr + p_mem->size)
- continue;
-
- *pa = da - p_mem->dev_addr + p_mem->bus_addr;
- dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
-
- return 0;
- }
-
- dev_err(dev, "can't translate da %llx\n", da);
-
- return -EINVAL;
-}
-
-static int stm32_rproc_get_loaded_rsc_table(struct platform_device *pdev,
- struct rproc *rproc,
- struct stm32_rproc *ddata)
-{
- struct device *dev = &pdev->dev;
- phys_addr_t rsc_pa;
- u32 rsc_da;
- int err;
-
- err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
- if (err) {
- dev_err(dev, "failed to read rsc tbl addr\n");
- return err;
- }
-
- if (!rsc_da)
- /* no rsc table */
- return 0;
-
- err = stm32_rproc_da_to_pa(pdev, ddata, rsc_da, &rsc_pa);
- if (err)
- return err;
-
- ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
- if (IS_ERR_OR_NULL(ddata->rsc_va)) {
- dev_err(dev, "Unable to map memory region: %pa+%zx\n",
- &rsc_pa, RSC_TBL_SIZE);
- ddata->rsc_va = NULL;
- return -ENOMEM;
- }
-
- /*
- * The resource table is already loaded in device memory, no need
- * to work with a cached table.
- */
- rproc->cached_table = NULL;
- /* Assuming the resource table fits in 1kB is fair */
- rproc->table_sz = RSC_TBL_SIZE;
- rproc->table_ptr = (struct resource_table *)ddata->rsc_va;
-
- return 0;
-}
-
static int stm32_rproc_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@@ -803,10 +802,6 @@ static int stm32_rproc_probe(struct platform_device *pdev)
ret = stm32_rproc_parse_memory_regions(rproc);
if (ret)
goto free_resources;
-
- ret = stm32_rproc_get_loaded_rsc_table(pdev, rproc, ddata);
- if (ret)
- goto free_resources;
}
rproc->has_iommu = false;
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 06/16] remoteproc: stm32: Move resource table setup to rproc_ops
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:14 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:14 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Move the setting of the resource table installed by an external
> entity to rproc_ops::get_loaded_rsc_table(). This is to support
> scenarios where a remote processor has been started by the core
> but is detached at a later stage. To re-attach the remote
> processor, the address of the resource table needs to be available
> at a later time than the platform driver's probe() function.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> drivers/remoteproc/stm32_rproc.c | 141 +++++++++++++++----------------
> 1 file changed, 68 insertions(+), 73 deletions(-)
>
> diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
> index ccb3c14a0023..f647e565014b 100644
> --- a/drivers/remoteproc/stm32_rproc.c
> +++ b/drivers/remoteproc/stm32_rproc.c
> @@ -546,6 +546,73 @@ static void stm32_rproc_kick(struct rproc *rproc, int vqid)
> }
> }
>
> +static int stm32_rproc_da_to_pa(struct rproc *rproc,
> + u64 da, phys_addr_t *pa)
> +{
> + struct stm32_rproc *ddata = rproc->priv;
> + struct device *dev = rproc->dev.parent;
> + struct stm32_rproc_mem *p_mem;
> + unsigned int i;
> +
> + for (i = 0; i < ddata->nb_rmems; i++) {
> + p_mem = &ddata->rmems[i];
> +
> + if (da < p_mem->dev_addr ||
> + da >= p_mem->dev_addr + p_mem->size)
> + continue;
> +
> + *pa = da - p_mem->dev_addr + p_mem->bus_addr;
> + dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
> +
> + return 0;
> + }
> +
> + dev_err(dev, "can't translate da %llx\n", da);
> +
> + return -EINVAL;
> +}
> +
> +static struct resource_table *
> +stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
> +{
> + struct stm32_rproc *ddata = rproc->priv;
> + struct device *dev = rproc->dev.parent;
> + phys_addr_t rsc_pa;
> + u32 rsc_da;
> + int err;
> +
> + /* The resource table has already been mapped, nothing to do */
> + if (ddata->rsc_va)
> + goto done;
> +
> + err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
> + if (err) {
> + dev_err(dev, "failed to read rsc tbl addr\n");
> + return ERR_PTR(-EINVAL);
> + }
> +
> + if (!rsc_da)
> + /* no rsc table */
> + return ERR_PTR(-ENOENT);
> +
> + err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa);
> + if (err)
> + return ERR_PTR(err);
> +
> + ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
> + if (IS_ERR_OR_NULL(ddata->rsc_va)) {
> + dev_err(dev, "Unable to map memory region: %pa+%zx\n",
> + &rsc_pa, RSC_TBL_SIZE);
> + ddata->rsc_va = NULL;
> + return ERR_PTR(-ENOMEM);
> + }
> +
> +done:
> + /* Assuming the resource table fits in 1kB is fair */
> + *table_sz = RSC_TBL_SIZE;
> + return (struct resource_table *)ddata->rsc_va;
> +}
> +
> static const struct rproc_ops st_rproc_ops = {
> .start = stm32_rproc_start,
> .stop = stm32_rproc_stop,
> @@ -554,6 +621,7 @@ static const struct rproc_ops st_rproc_ops = {
> .load = rproc_elf_load_segments,
> .parse_fw = stm32_rproc_parse_fw,
> .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
> + .get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table,
> .sanity_check = rproc_elf_sanity_check,
> .get_boot_addr = rproc_elf_get_boot_addr,
> };
> @@ -695,75 +763,6 @@ static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
> return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
> }
>
> -static int stm32_rproc_da_to_pa(struct platform_device *pdev,
> - struct stm32_rproc *ddata,
> - u64 da, phys_addr_t *pa)
> -{
> - struct device *dev = &pdev->dev;
> - struct stm32_rproc_mem *p_mem;
> - unsigned int i;
> -
> - for (i = 0; i < ddata->nb_rmems; i++) {
> - p_mem = &ddata->rmems[i];
> -
> - if (da < p_mem->dev_addr ||
> - da >= p_mem->dev_addr + p_mem->size)
> - continue;
> -
> - *pa = da - p_mem->dev_addr + p_mem->bus_addr;
> - dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
> -
> - return 0;
> - }
> -
> - dev_err(dev, "can't translate da %llx\n", da);
> -
> - return -EINVAL;
> -}
> -
> -static int stm32_rproc_get_loaded_rsc_table(struct platform_device *pdev,
> - struct rproc *rproc,
> - struct stm32_rproc *ddata)
> -{
> - struct device *dev = &pdev->dev;
> - phys_addr_t rsc_pa;
> - u32 rsc_da;
> - int err;
> -
> - err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
> - if (err) {
> - dev_err(dev, "failed to read rsc tbl addr\n");
> - return err;
> - }
> -
> - if (!rsc_da)
> - /* no rsc table */
> - return 0;
> -
> - err = stm32_rproc_da_to_pa(pdev, ddata, rsc_da, &rsc_pa);
> - if (err)
> - return err;
> -
> - ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
> - if (IS_ERR_OR_NULL(ddata->rsc_va)) {
> - dev_err(dev, "Unable to map memory region: %pa+%zx\n",
> - &rsc_pa, RSC_TBL_SIZE);
> - ddata->rsc_va = NULL;
> - return -ENOMEM;
> - }
> -
> - /*
> - * The resource table is already loaded in device memory, no need
> - * to work with a cached table.
> - */
> - rproc->cached_table = NULL;
> - /* Assuming the resource table fits in 1kB is fair */
> - rproc->table_sz = RSC_TBL_SIZE;
> - rproc->table_ptr = (struct resource_table *)ddata->rsc_va;
> -
> - return 0;
> -}
> -
> static int stm32_rproc_probe(struct platform_device *pdev)
> {
> struct device *dev = &pdev->dev;
> @@ -803,10 +802,6 @@ static int stm32_rproc_probe(struct platform_device *pdev)
> ret = stm32_rproc_parse_memory_regions(rproc);
> if (ret)
> goto free_resources;
> -
> - ret = stm32_rproc_get_loaded_rsc_table(pdev, rproc, ddata);
> - if (ret)
> - goto free_resources;
> }
>
> rproc->has_iommu = false;
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 06/16] remoteproc: stm32: Move resource table setup to rproc_ops
@ 2021-02-26 16:14 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:14 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Move the setting of the resource table installed by an external
> entity to rproc_ops::get_loaded_rsc_table(). This is to support
> scenarios where a remote processor has been started by the core
> but is detached at a later stage. To re-attach the remote
> processor, the address of the resource table needs to be available
> at a later time than the platform driver's probe() function.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> drivers/remoteproc/stm32_rproc.c | 141 +++++++++++++++----------------
> 1 file changed, 68 insertions(+), 73 deletions(-)
>
> diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
> index ccb3c14a0023..f647e565014b 100644
> --- a/drivers/remoteproc/stm32_rproc.c
> +++ b/drivers/remoteproc/stm32_rproc.c
> @@ -546,6 +546,73 @@ static void stm32_rproc_kick(struct rproc *rproc, int vqid)
> }
> }
>
> +static int stm32_rproc_da_to_pa(struct rproc *rproc,
> + u64 da, phys_addr_t *pa)
> +{
> + struct stm32_rproc *ddata = rproc->priv;
> + struct device *dev = rproc->dev.parent;
> + struct stm32_rproc_mem *p_mem;
> + unsigned int i;
> +
> + for (i = 0; i < ddata->nb_rmems; i++) {
> + p_mem = &ddata->rmems[i];
> +
> + if (da < p_mem->dev_addr ||
> + da >= p_mem->dev_addr + p_mem->size)
> + continue;
> +
> + *pa = da - p_mem->dev_addr + p_mem->bus_addr;
> + dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
> +
> + return 0;
> + }
> +
> + dev_err(dev, "can't translate da %llx\n", da);
> +
> + return -EINVAL;
> +}
> +
> +static struct resource_table *
> +stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
> +{
> + struct stm32_rproc *ddata = rproc->priv;
> + struct device *dev = rproc->dev.parent;
> + phys_addr_t rsc_pa;
> + u32 rsc_da;
> + int err;
> +
> + /* The resource table has already been mapped, nothing to do */
> + if (ddata->rsc_va)
> + goto done;
> +
> + err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
> + if (err) {
> + dev_err(dev, "failed to read rsc tbl addr\n");
> + return ERR_PTR(-EINVAL);
> + }
> +
> + if (!rsc_da)
> + /* no rsc table */
> + return ERR_PTR(-ENOENT);
> +
> + err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa);
> + if (err)
> + return ERR_PTR(err);
> +
> + ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
> + if (IS_ERR_OR_NULL(ddata->rsc_va)) {
> + dev_err(dev, "Unable to map memory region: %pa+%zx\n",
> + &rsc_pa, RSC_TBL_SIZE);
> + ddata->rsc_va = NULL;
> + return ERR_PTR(-ENOMEM);
> + }
> +
> +done:
> + /* Assuming the resource table fits in 1kB is fair */
> + *table_sz = RSC_TBL_SIZE;
> + return (struct resource_table *)ddata->rsc_va;
> +}
> +
> static const struct rproc_ops st_rproc_ops = {
> .start = stm32_rproc_start,
> .stop = stm32_rproc_stop,
> @@ -554,6 +621,7 @@ static const struct rproc_ops st_rproc_ops = {
> .load = rproc_elf_load_segments,
> .parse_fw = stm32_rproc_parse_fw,
> .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
> + .get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table,
> .sanity_check = rproc_elf_sanity_check,
> .get_boot_addr = rproc_elf_get_boot_addr,
> };
> @@ -695,75 +763,6 @@ static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
> return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
> }
>
> -static int stm32_rproc_da_to_pa(struct platform_device *pdev,
> - struct stm32_rproc *ddata,
> - u64 da, phys_addr_t *pa)
> -{
> - struct device *dev = &pdev->dev;
> - struct stm32_rproc_mem *p_mem;
> - unsigned int i;
> -
> - for (i = 0; i < ddata->nb_rmems; i++) {
> - p_mem = &ddata->rmems[i];
> -
> - if (da < p_mem->dev_addr ||
> - da >= p_mem->dev_addr + p_mem->size)
> - continue;
> -
> - *pa = da - p_mem->dev_addr + p_mem->bus_addr;
> - dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
> -
> - return 0;
> - }
> -
> - dev_err(dev, "can't translate da %llx\n", da);
> -
> - return -EINVAL;
> -}
> -
> -static int stm32_rproc_get_loaded_rsc_table(struct platform_device *pdev,
> - struct rproc *rproc,
> - struct stm32_rproc *ddata)
> -{
> - struct device *dev = &pdev->dev;
> - phys_addr_t rsc_pa;
> - u32 rsc_da;
> - int err;
> -
> - err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
> - if (err) {
> - dev_err(dev, "failed to read rsc tbl addr\n");
> - return err;
> - }
> -
> - if (!rsc_da)
> - /* no rsc table */
> - return 0;
> -
> - err = stm32_rproc_da_to_pa(pdev, ddata, rsc_da, &rsc_pa);
> - if (err)
> - return err;
> -
> - ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
> - if (IS_ERR_OR_NULL(ddata->rsc_va)) {
> - dev_err(dev, "Unable to map memory region: %pa+%zx\n",
> - &rsc_pa, RSC_TBL_SIZE);
> - ddata->rsc_va = NULL;
> - return -ENOMEM;
> - }
> -
> - /*
> - * The resource table is already loaded in device memory, no need
> - * to work with a cached table.
> - */
> - rproc->cached_table = NULL;
> - /* Assuming the resource table fits in 1kB is fair */
> - rproc->table_sz = RSC_TBL_SIZE;
> - rproc->table_ptr = (struct resource_table *)ddata->rsc_va;
> -
> - return 0;
> -}
> -
> static int stm32_rproc_probe(struct platform_device *pdev)
> {
> struct device *dev = &pdev->dev;
> @@ -803,10 +802,6 @@ static int stm32_rproc_probe(struct platform_device *pdev)
> ret = stm32_rproc_parse_memory_regions(rproc);
> if (ret)
> goto free_resources;
> -
> - ret = stm32_rproc_get_loaded_rsc_table(pdev, rproc, ddata);
> - if (ret)
> - goto free_resources;
> }
>
> rproc->has_iommu = false;
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 07/16] remoteproc: stm32: Move memory parsing to rproc_ops
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
From: Arnaud POULIQUEN <arnaud.pouliquen@foss.st.com>
Some actions such as memory resources reallocation are needed when
trying to reattach a co-processor. Use the prepare() operation for
these actions.
Co-developed-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: Arnaud POULIQUEN <arnaud.pouliquen@foss.st.com>
---
drivers/remoteproc/remoteproc_core.c | 14 ++++++++++++--
drivers/remoteproc/stm32_rproc.c | 27 ++++++---------------------
2 files changed, 18 insertions(+), 23 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 0012b7bdce24..86572880c726 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1582,10 +1582,17 @@ static int rproc_attach(struct rproc *rproc)
return ret;
}
+ /* Do anything that is needed to boot the remote processor */
+ ret = rproc_prepare_device(rproc);
+ if (ret) {
+ dev_err(dev, "can't prepare rproc %s: %d\n", rproc->name, ret);
+ goto disable_iommu;
+ }
+
ret = rproc_set_loaded_rsc_table(rproc);
if (ret) {
dev_err(dev, "can't load resource table: %d\n", ret);
- goto disable_iommu;
+ goto unprepare_device;
}
/* reset max_notifyid */
@@ -1602,7 +1609,7 @@ static int rproc_attach(struct rproc *rproc)
ret = rproc_handle_resources(rproc, rproc_loading_handlers);
if (ret) {
dev_err(dev, "Failed to process resources: %d\n", ret);
- goto disable_iommu;
+ goto unprepare_device;
}
/* Allocate carveout resources associated to rproc */
@@ -1621,6 +1628,9 @@ static int rproc_attach(struct rproc *rproc)
clean_up_resources:
rproc_resource_cleanup(rproc);
+unprepare_device:
+ /* release HW resources if needed */
+ rproc_unprepare_device(rproc);
disable_iommu:
rproc_disable_iommu(rproc);
return ret;
diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
index f647e565014b..3d45f51de4d0 100644
--- a/drivers/remoteproc/stm32_rproc.c
+++ b/drivers/remoteproc/stm32_rproc.c
@@ -207,16 +207,7 @@ static int stm32_rproc_mbox_idx(struct rproc *rproc, const unsigned char *name)
return -EINVAL;
}
-static int stm32_rproc_elf_load_rsc_table(struct rproc *rproc,
- const struct firmware *fw)
-{
- if (rproc_elf_load_rsc_table(rproc, fw))
- dev_warn(&rproc->dev, "no resource table found for this firmware\n");
-
- return 0;
-}
-
-static int stm32_rproc_parse_memory_regions(struct rproc *rproc)
+static int stm32_rproc_prepare(struct rproc *rproc)
{
struct device *dev = rproc->dev.parent;
struct device_node *np = dev->of_node;
@@ -274,12 +265,10 @@ static int stm32_rproc_parse_memory_regions(struct rproc *rproc)
static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
{
- int ret = stm32_rproc_parse_memory_regions(rproc);
-
- if (ret)
- return ret;
+ if (rproc_elf_load_rsc_table(rproc, fw))
+ dev_warn(&rproc->dev, "no resource table found for this firmware\n");
- return stm32_rproc_elf_load_rsc_table(rproc, fw);
+ return 0;
}
static irqreturn_t stm32_rproc_wdg(int irq, void *data)
@@ -614,6 +603,7 @@ stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
}
static const struct rproc_ops st_rproc_ops = {
+ .prepare = stm32_rproc_prepare,
.start = stm32_rproc_start,
.stop = stm32_rproc_stop,
.attach = stm32_rproc_attach,
@@ -796,14 +786,9 @@ static int stm32_rproc_probe(struct platform_device *pdev)
if (ret)
goto free_rproc;
- if (state == M4_STATE_CRUN) {
+ if (state == M4_STATE_CRUN)
rproc->state = RPROC_DETACHED;
- ret = stm32_rproc_parse_memory_regions(rproc);
- if (ret)
- goto free_resources;
- }
-
rproc->has_iommu = false;
ddata->workqueue = create_workqueue(dev_name(dev));
if (!ddata->workqueue) {
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 07/16] remoteproc: stm32: Move memory parsing to rproc_ops
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
From: Arnaud POULIQUEN <arnaud.pouliquen@foss.st.com>
Some actions such as memory resources reallocation are needed when
trying to reattach a co-processor. Use the prepare() operation for
these actions.
Co-developed-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: Arnaud POULIQUEN <arnaud.pouliquen@foss.st.com>
---
drivers/remoteproc/remoteproc_core.c | 14 ++++++++++++--
drivers/remoteproc/stm32_rproc.c | 27 ++++++---------------------
2 files changed, 18 insertions(+), 23 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 0012b7bdce24..86572880c726 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1582,10 +1582,17 @@ static int rproc_attach(struct rproc *rproc)
return ret;
}
+ /* Do anything that is needed to boot the remote processor */
+ ret = rproc_prepare_device(rproc);
+ if (ret) {
+ dev_err(dev, "can't prepare rproc %s: %d\n", rproc->name, ret);
+ goto disable_iommu;
+ }
+
ret = rproc_set_loaded_rsc_table(rproc);
if (ret) {
dev_err(dev, "can't load resource table: %d\n", ret);
- goto disable_iommu;
+ goto unprepare_device;
}
/* reset max_notifyid */
@@ -1602,7 +1609,7 @@ static int rproc_attach(struct rproc *rproc)
ret = rproc_handle_resources(rproc, rproc_loading_handlers);
if (ret) {
dev_err(dev, "Failed to process resources: %d\n", ret);
- goto disable_iommu;
+ goto unprepare_device;
}
/* Allocate carveout resources associated to rproc */
@@ -1621,6 +1628,9 @@ static int rproc_attach(struct rproc *rproc)
clean_up_resources:
rproc_resource_cleanup(rproc);
+unprepare_device:
+ /* release HW resources if needed */
+ rproc_unprepare_device(rproc);
disable_iommu:
rproc_disable_iommu(rproc);
return ret;
diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
index f647e565014b..3d45f51de4d0 100644
--- a/drivers/remoteproc/stm32_rproc.c
+++ b/drivers/remoteproc/stm32_rproc.c
@@ -207,16 +207,7 @@ static int stm32_rproc_mbox_idx(struct rproc *rproc, const unsigned char *name)
return -EINVAL;
}
-static int stm32_rproc_elf_load_rsc_table(struct rproc *rproc,
- const struct firmware *fw)
-{
- if (rproc_elf_load_rsc_table(rproc, fw))
- dev_warn(&rproc->dev, "no resource table found for this firmware\n");
-
- return 0;
-}
-
-static int stm32_rproc_parse_memory_regions(struct rproc *rproc)
+static int stm32_rproc_prepare(struct rproc *rproc)
{
struct device *dev = rproc->dev.parent;
struct device_node *np = dev->of_node;
@@ -274,12 +265,10 @@ static int stm32_rproc_parse_memory_regions(struct rproc *rproc)
static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
{
- int ret = stm32_rproc_parse_memory_regions(rproc);
-
- if (ret)
- return ret;
+ if (rproc_elf_load_rsc_table(rproc, fw))
+ dev_warn(&rproc->dev, "no resource table found for this firmware\n");
- return stm32_rproc_elf_load_rsc_table(rproc, fw);
+ return 0;
}
static irqreturn_t stm32_rproc_wdg(int irq, void *data)
@@ -614,6 +603,7 @@ stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
}
static const struct rproc_ops st_rproc_ops = {
+ .prepare = stm32_rproc_prepare,
.start = stm32_rproc_start,
.stop = stm32_rproc_stop,
.attach = stm32_rproc_attach,
@@ -796,14 +786,9 @@ static int stm32_rproc_probe(struct platform_device *pdev)
if (ret)
goto free_rproc;
- if (state == M4_STATE_CRUN) {
+ if (state == M4_STATE_CRUN)
rproc->state = RPROC_DETACHED;
- ret = stm32_rproc_parse_memory_regions(rproc);
- if (ret)
- goto free_resources;
- }
-
rproc->has_iommu = false;
ddata->workqueue = create_workqueue(dev_name(dev));
if (!ddata->workqueue) {
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 08/16] remoteproc: Add new detach() remoteproc operation
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Add an new detach() operation in order to support scenarios where
the remoteproc core is going away but the remote processor is
kept operating. This could be the case when the system is
rebooted or when the platform driver is removed.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
include/linux/remoteproc.h | 2 ++
1 file changed, 2 insertions(+)
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 51538a7d120d..eff55ec72e80 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -361,6 +361,7 @@ enum rsc_handling_status {
* @start: power on the device and boot it
* @stop: power off the device
* @attach: attach to a device that his already powered up
+ * @detach: detach from a device, leaving it powered up
* @kick: kick a virtqueue (virtqueue id given as a parameter)
* @da_to_va: optional platform hook to perform address translations
* @parse_fw: parse firmware to extract information (e.g. resource table)
@@ -385,6 +386,7 @@ struct rproc_ops {
int (*start)(struct rproc *rproc);
int (*stop)(struct rproc *rproc);
int (*attach)(struct rproc *rproc);
+ int (*detach)(struct rproc *rproc);
void (*kick)(struct rproc *rproc, int vqid);
void * (*da_to_va)(struct rproc *rproc, u64 da, size_t len);
int (*parse_fw)(struct rproc *rproc, const struct firmware *fw);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 08/16] remoteproc: Add new detach() remoteproc operation
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Add an new detach() operation in order to support scenarios where
the remoteproc core is going away but the remote processor is
kept operating. This could be the case when the system is
rebooted or when the platform driver is removed.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
include/linux/remoteproc.h | 2 ++
1 file changed, 2 insertions(+)
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 51538a7d120d..eff55ec72e80 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -361,6 +361,7 @@ enum rsc_handling_status {
* @start: power on the device and boot it
* @stop: power off the device
* @attach: attach to a device that his already powered up
+ * @detach: detach from a device, leaving it powered up
* @kick: kick a virtqueue (virtqueue id given as a parameter)
* @da_to_va: optional platform hook to perform address translations
* @parse_fw: parse firmware to extract information (e.g. resource table)
@@ -385,6 +386,7 @@ struct rproc_ops {
int (*start)(struct rproc *rproc);
int (*stop)(struct rproc *rproc);
int (*attach)(struct rproc *rproc);
+ int (*detach)(struct rproc *rproc);
void (*kick)(struct rproc *rproc, int vqid);
void * (*da_to_va)(struct rproc *rproc, u64 da, size_t len);
int (*parse_fw)(struct rproc *rproc, const struct firmware *fw);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 09/16] remoteproc: Introduce function __rproc_detach()
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Introduce function __rproc_detach() to perform the same kind of
operation as rproc_stop(), but instead of switching off the
remote processor using rproc->ops->stop(), it uses
rproc->ops->detach(). That way it is possible for the core
to release the resources associated with a remote processor while
the latter is kept operating.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
---
drivers/remoteproc/remoteproc_core.c | 30 ++++++++++++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 86572880c726..0f680b7ff8f1 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1706,6 +1706,36 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
return 0;
}
+/*
+ * __rproc_detach(): Does the opposite of __rproc_attach()
+ */
+static int __maybe_unused __rproc_detach(struct rproc *rproc)
+{
+ struct device *dev = &rproc->dev;
+ int ret;
+
+ /* No need to continue if a detach() operation has not been provided */
+ if (!rproc->ops->detach)
+ return -EINVAL;
+
+ /* Stop any subdevices for the remote processor */
+ rproc_stop_subdevices(rproc, false);
+
+ /* Tell the remote processor the core isn't available anymore */
+ ret = rproc->ops->detach(rproc);
+ if (ret) {
+ dev_err(dev, "can't detach from rproc: %d\n", ret);
+ return ret;
+ }
+
+ rproc_unprepare_subdevices(rproc);
+
+ rproc->state = RPROC_DETACHED;
+
+ dev_info(dev, "detached remote processor %s\n", rproc->name);
+
+ return 0;
+}
/**
* rproc_trigger_recovery() - recover a remoteproc
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 09/16] remoteproc: Introduce function __rproc_detach()
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Introduce function __rproc_detach() to perform the same kind of
operation as rproc_stop(), but instead of switching off the
remote processor using rproc->ops->stop(), it uses
rproc->ops->detach(). That way it is possible for the core
to release the resources associated with a remote processor while
the latter is kept operating.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
---
drivers/remoteproc/remoteproc_core.c | 30 ++++++++++++++++++++++++++++
1 file changed, 30 insertions(+)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 86572880c726..0f680b7ff8f1 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1706,6 +1706,36 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
return 0;
}
+/*
+ * __rproc_detach(): Does the opposite of __rproc_attach()
+ */
+static int __maybe_unused __rproc_detach(struct rproc *rproc)
+{
+ struct device *dev = &rproc->dev;
+ int ret;
+
+ /* No need to continue if a detach() operation has not been provided */
+ if (!rproc->ops->detach)
+ return -EINVAL;
+
+ /* Stop any subdevices for the remote processor */
+ rproc_stop_subdevices(rproc, false);
+
+ /* Tell the remote processor the core isn't available anymore */
+ ret = rproc->ops->detach(rproc);
+ if (ret) {
+ dev_err(dev, "can't detach from rproc: %d\n", ret);
+ return ret;
+ }
+
+ rproc_unprepare_subdevices(rproc);
+
+ rproc->state = RPROC_DETACHED;
+
+ dev_info(dev, "detached remote processor %s\n", rproc->name);
+
+ return 0;
+}
/**
* rproc_trigger_recovery() - recover a remoteproc
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 09/16] remoteproc: Introduce function __rproc_detach()
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:15 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:15 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Introduce function __rproc_detach() to perform the same kind of
> operation as rproc_stop(), but instead of switching off the
> remote processor using rproc->ops->stop(), it uses
> rproc->ops->detach(). That way it is possible for the core
> to release the resources associated with a remote processor while
> the latter is kept operating.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> drivers/remoteproc/remoteproc_core.c | 30 ++++++++++++++++++++++++++++
> 1 file changed, 30 insertions(+)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 86572880c726..0f680b7ff8f1 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1706,6 +1706,36 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> return 0;
> }
>
> +/*
> + * __rproc_detach(): Does the opposite of __rproc_attach()
> + */
> +static int __maybe_unused __rproc_detach(struct rproc *rproc)
> +{
> + struct device *dev = &rproc->dev;
> + int ret;
> +
> + /* No need to continue if a detach() operation has not been provided */
> + if (!rproc->ops->detach)
> + return -EINVAL;
> +
> + /* Stop any subdevices for the remote processor */
> + rproc_stop_subdevices(rproc, false);
> +
> + /* Tell the remote processor the core isn't available anymore */
> + ret = rproc->ops->detach(rproc);
> + if (ret) {
> + dev_err(dev, "can't detach from rproc: %d\n", ret);
> + return ret;
> + }
> +
> + rproc_unprepare_subdevices(rproc);
> +
> + rproc->state = RPROC_DETACHED;
> +
> + dev_info(dev, "detached remote processor %s\n", rproc->name);
> +
> + return 0;
> +}
>
> /**
> * rproc_trigger_recovery() - recover a remoteproc
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 09/16] remoteproc: Introduce function __rproc_detach()
@ 2021-02-26 16:15 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:15 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Introduce function __rproc_detach() to perform the same kind of
> operation as rproc_stop(), but instead of switching off the
> remote processor using rproc->ops->stop(), it uses
> rproc->ops->detach(). That way it is possible for the core
> to release the resources associated with a remote processor while
> the latter is kept operating.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> drivers/remoteproc/remoteproc_core.c | 30 ++++++++++++++++++++++++++++
> 1 file changed, 30 insertions(+)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 86572880c726..0f680b7ff8f1 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1706,6 +1706,36 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> return 0;
> }
>
> +/*
> + * __rproc_detach(): Does the opposite of __rproc_attach()
> + */
> +static int __maybe_unused __rproc_detach(struct rproc *rproc)
> +{
> + struct device *dev = &rproc->dev;
> + int ret;
> +
> + /* No need to continue if a detach() operation has not been provided */
> + if (!rproc->ops->detach)
> + return -EINVAL;
> +
> + /* Stop any subdevices for the remote processor */
> + rproc_stop_subdevices(rproc, false);
> +
> + /* Tell the remote processor the core isn't available anymore */
> + ret = rproc->ops->detach(rproc);
> + if (ret) {
> + dev_err(dev, "can't detach from rproc: %d\n", ret);
> + return ret;
> + }
> +
> + rproc_unprepare_subdevices(rproc);
> +
> + rproc->state = RPROC_DETACHED;
> +
> + dev_info(dev, "detached remote processor %s\n", rproc->name);
> +
> + return 0;
> +}
>
> /**
> * rproc_trigger_recovery() - recover a remoteproc
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 10/16] remoteproc: Introduce function rproc_detach()
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Introduce function rproc_detach() to enable the remoteproc
core to release the resources associated with a remote processor
without stopping its operation.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Checking for rproc->state has been removed. They have been moved to
calling functions.
- Freeing the cache table has been moved to the next patch, i.e 11/16.
---
drivers/remoteproc/remoteproc_core.c | 58 +++++++++++++++++++++++++++-
include/linux/remoteproc.h | 1 +
2 files changed, 58 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 0f680b7ff8f1..fc01b29290a6 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1709,7 +1709,7 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
/*
* __rproc_detach(): Does the opposite of __rproc_attach()
*/
-static int __maybe_unused __rproc_detach(struct rproc *rproc)
+static int __rproc_detach(struct rproc *rproc)
{
struct device *dev = &rproc->dev;
int ret;
@@ -1948,6 +1948,62 @@ void rproc_shutdown(struct rproc *rproc)
}
EXPORT_SYMBOL(rproc_shutdown);
+/**
+ * rproc_detach() - Detach the remote processor from the
+ * remoteproc core
+ *
+ * @rproc: the remote processor
+ *
+ * Detach a remote processor (previously attached to with rproc_attach()).
+ *
+ * In case @rproc is still being used by an additional user(s), then
+ * this function will just decrement the power refcount and exit,
+ * without disconnecting the device.
+ *
+ * Function rproc_detach() calls __rproc_detach() in order to let a remote
+ * processor know that services provided by the application processor are
+ * no longer available. From there it should be possible to remove the
+ * platform driver and even power cycle the application processor (if the HW
+ * supports it) without needing to switch off the remote processor.
+ */
+int rproc_detach(struct rproc *rproc)
+{
+ struct device *dev = &rproc->dev;
+ int ret;
+
+ ret = mutex_lock_interruptible(&rproc->lock);
+ if (ret) {
+ dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
+ return ret;
+ }
+
+ /* if the remote proc is still needed, bail out */
+ if (!atomic_dec_and_test(&rproc->power)) {
+ ret = 0;
+ goto out;
+ }
+
+ ret = __rproc_detach(rproc);
+ if (ret) {
+ atomic_inc(&rproc->power);
+ goto out;
+ }
+
+ /* clean up all acquired resources */
+ rproc_resource_cleanup(rproc);
+
+ /* release HW resources if needed */
+ rproc_unprepare_device(rproc);
+
+ rproc_disable_iommu(rproc);
+
+ rproc->table_ptr = NULL;
+out:
+ mutex_unlock(&rproc->lock);
+ return ret;
+}
+EXPORT_SYMBOL(rproc_detach);
+
/**
* rproc_get_by_phandle() - find a remote processor by phandle
* @phandle: phandle to the rproc
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index eff55ec72e80..e1c843c19cc6 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -662,6 +662,7 @@ rproc_of_resm_mem_entry_init(struct device *dev, u32 of_resm_idx, size_t len,
int rproc_boot(struct rproc *rproc);
void rproc_shutdown(struct rproc *rproc);
+int rproc_detach(struct rproc *rproc);
int rproc_set_firmware(struct rproc *rproc, const char *fw_name);
void rproc_report_crash(struct rproc *rproc, enum rproc_crash_type type);
void rproc_coredump_using_sections(struct rproc *rproc);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 10/16] remoteproc: Introduce function rproc_detach()
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Introduce function rproc_detach() to enable the remoteproc
core to release the resources associated with a remote processor
without stopping its operation.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Checking for rproc->state has been removed. They have been moved to
calling functions.
- Freeing the cache table has been moved to the next patch, i.e 11/16.
---
drivers/remoteproc/remoteproc_core.c | 58 +++++++++++++++++++++++++++-
include/linux/remoteproc.h | 1 +
2 files changed, 58 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 0f680b7ff8f1..fc01b29290a6 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1709,7 +1709,7 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
/*
* __rproc_detach(): Does the opposite of __rproc_attach()
*/
-static int __maybe_unused __rproc_detach(struct rproc *rproc)
+static int __rproc_detach(struct rproc *rproc)
{
struct device *dev = &rproc->dev;
int ret;
@@ -1948,6 +1948,62 @@ void rproc_shutdown(struct rproc *rproc)
}
EXPORT_SYMBOL(rproc_shutdown);
+/**
+ * rproc_detach() - Detach the remote processor from the
+ * remoteproc core
+ *
+ * @rproc: the remote processor
+ *
+ * Detach a remote processor (previously attached to with rproc_attach()).
+ *
+ * In case @rproc is still being used by an additional user(s), then
+ * this function will just decrement the power refcount and exit,
+ * without disconnecting the device.
+ *
+ * Function rproc_detach() calls __rproc_detach() in order to let a remote
+ * processor know that services provided by the application processor are
+ * no longer available. From there it should be possible to remove the
+ * platform driver and even power cycle the application processor (if the HW
+ * supports it) without needing to switch off the remote processor.
+ */
+int rproc_detach(struct rproc *rproc)
+{
+ struct device *dev = &rproc->dev;
+ int ret;
+
+ ret = mutex_lock_interruptible(&rproc->lock);
+ if (ret) {
+ dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
+ return ret;
+ }
+
+ /* if the remote proc is still needed, bail out */
+ if (!atomic_dec_and_test(&rproc->power)) {
+ ret = 0;
+ goto out;
+ }
+
+ ret = __rproc_detach(rproc);
+ if (ret) {
+ atomic_inc(&rproc->power);
+ goto out;
+ }
+
+ /* clean up all acquired resources */
+ rproc_resource_cleanup(rproc);
+
+ /* release HW resources if needed */
+ rproc_unprepare_device(rproc);
+
+ rproc_disable_iommu(rproc);
+
+ rproc->table_ptr = NULL;
+out:
+ mutex_unlock(&rproc->lock);
+ return ret;
+}
+EXPORT_SYMBOL(rproc_detach);
+
/**
* rproc_get_by_phandle() - find a remote processor by phandle
* @phandle: phandle to the rproc
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index eff55ec72e80..e1c843c19cc6 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -662,6 +662,7 @@ rproc_of_resm_mem_entry_init(struct device *dev, u32 of_resm_idx, size_t len,
int rproc_boot(struct rproc *rproc);
void rproc_shutdown(struct rproc *rproc);
+int rproc_detach(struct rproc *rproc);
int rproc_set_firmware(struct rproc *rproc, const char *fw_name);
void rproc_report_crash(struct rproc *rproc, enum rproc_crash_type type);
void rproc_coredump_using_sections(struct rproc *rproc);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 10/16] remoteproc: Introduce function rproc_detach()
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:15 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:15 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Introduce function rproc_detach() to enable the remoteproc
> core to release the resources associated with a remote processor
> without stopping its operation.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
> ---
> New for V6:
> - Checking for rproc->state has been removed. They have been moved to
> calling functions.
> - Freeing the cache table has been moved to the next patch, i.e 11/16.
> ---
>
> drivers/remoteproc/remoteproc_core.c | 58 +++++++++++++++++++++++++++-
> include/linux/remoteproc.h | 1 +
> 2 files changed, 58 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 0f680b7ff8f1..fc01b29290a6 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1709,7 +1709,7 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> /*
> * __rproc_detach(): Does the opposite of __rproc_attach()
> */
> -static int __maybe_unused __rproc_detach(struct rproc *rproc)
> +static int __rproc_detach(struct rproc *rproc)
> {
> struct device *dev = &rproc->dev;
> int ret;
> @@ -1948,6 +1948,62 @@ void rproc_shutdown(struct rproc *rproc)
> }
> EXPORT_SYMBOL(rproc_shutdown);
>
> +/**
> + * rproc_detach() - Detach the remote processor from the
> + * remoteproc core
> + *
> + * @rproc: the remote processor
> + *
> + * Detach a remote processor (previously attached to with rproc_attach()).
> + *
> + * In case @rproc is still being used by an additional user(s), then
> + * this function will just decrement the power refcount and exit,
> + * without disconnecting the device.
> + *
> + * Function rproc_detach() calls __rproc_detach() in order to let a remote
> + * processor know that services provided by the application processor are
> + * no longer available. From there it should be possible to remove the
> + * platform driver and even power cycle the application processor (if the HW
> + * supports it) without needing to switch off the remote processor.
> + */
> +int rproc_detach(struct rproc *rproc)
> +{
> + struct device *dev = &rproc->dev;
> + int ret;
> +
> + ret = mutex_lock_interruptible(&rproc->lock);
> + if (ret) {
> + dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
> + return ret;
> + }
> +
> + /* if the remote proc is still needed, bail out */
> + if (!atomic_dec_and_test(&rproc->power)) {
> + ret = 0;
> + goto out;
> + }
> +
> + ret = __rproc_detach(rproc);
> + if (ret) {
> + atomic_inc(&rproc->power);
> + goto out;
> + }
> +
> + /* clean up all acquired resources */
> + rproc_resource_cleanup(rproc);
> +
> + /* release HW resources if needed */
> + rproc_unprepare_device(rproc);
> +
> + rproc_disable_iommu(rproc);
> +
> + rproc->table_ptr = NULL;
> +out:
> + mutex_unlock(&rproc->lock);
> + return ret;
> +}
> +EXPORT_SYMBOL(rproc_detach);
> +
> /**
> * rproc_get_by_phandle() - find a remote processor by phandle
> * @phandle: phandle to the rproc
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index eff55ec72e80..e1c843c19cc6 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -662,6 +662,7 @@ rproc_of_resm_mem_entry_init(struct device *dev, u32 of_resm_idx, size_t len,
>
> int rproc_boot(struct rproc *rproc);
> void rproc_shutdown(struct rproc *rproc);
> +int rproc_detach(struct rproc *rproc);
> int rproc_set_firmware(struct rproc *rproc, const char *fw_name);
> void rproc_report_crash(struct rproc *rproc, enum rproc_crash_type type);
> void rproc_coredump_using_sections(struct rproc *rproc);
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 10/16] remoteproc: Introduce function rproc_detach()
@ 2021-02-26 16:15 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:15 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Introduce function rproc_detach() to enable the remoteproc
> core to release the resources associated with a remote processor
> without stopping its operation.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
> ---
> New for V6:
> - Checking for rproc->state has been removed. They have been moved to
> calling functions.
> - Freeing the cache table has been moved to the next patch, i.e 11/16.
> ---
>
> drivers/remoteproc/remoteproc_core.c | 58 +++++++++++++++++++++++++++-
> include/linux/remoteproc.h | 1 +
> 2 files changed, 58 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 0f680b7ff8f1..fc01b29290a6 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1709,7 +1709,7 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> /*
> * __rproc_detach(): Does the opposite of __rproc_attach()
> */
> -static int __maybe_unused __rproc_detach(struct rproc *rproc)
> +static int __rproc_detach(struct rproc *rproc)
> {
> struct device *dev = &rproc->dev;
> int ret;
> @@ -1948,6 +1948,62 @@ void rproc_shutdown(struct rproc *rproc)
> }
> EXPORT_SYMBOL(rproc_shutdown);
>
> +/**
> + * rproc_detach() - Detach the remote processor from the
> + * remoteproc core
> + *
> + * @rproc: the remote processor
> + *
> + * Detach a remote processor (previously attached to with rproc_attach()).
> + *
> + * In case @rproc is still being used by an additional user(s), then
> + * this function will just decrement the power refcount and exit,
> + * without disconnecting the device.
> + *
> + * Function rproc_detach() calls __rproc_detach() in order to let a remote
> + * processor know that services provided by the application processor are
> + * no longer available. From there it should be possible to remove the
> + * platform driver and even power cycle the application processor (if the HW
> + * supports it) without needing to switch off the remote processor.
> + */
> +int rproc_detach(struct rproc *rproc)
> +{
> + struct device *dev = &rproc->dev;
> + int ret;
> +
> + ret = mutex_lock_interruptible(&rproc->lock);
> + if (ret) {
> + dev_err(dev, "can't lock rproc %s: %d\n", rproc->name, ret);
> + return ret;
> + }
> +
> + /* if the remote proc is still needed, bail out */
> + if (!atomic_dec_and_test(&rproc->power)) {
> + ret = 0;
> + goto out;
> + }
> +
> + ret = __rproc_detach(rproc);
> + if (ret) {
> + atomic_inc(&rproc->power);
> + goto out;
> + }
> +
> + /* clean up all acquired resources */
> + rproc_resource_cleanup(rproc);
> +
> + /* release HW resources if needed */
> + rproc_unprepare_device(rproc);
> +
> + rproc_disable_iommu(rproc);
> +
> + rproc->table_ptr = NULL;
> +out:
> + mutex_unlock(&rproc->lock);
> + return ret;
> +}
> +EXPORT_SYMBOL(rproc_detach);
> +
> /**
> * rproc_get_by_phandle() - find a remote processor by phandle
> * @phandle: phandle to the rproc
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index eff55ec72e80..e1c843c19cc6 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -662,6 +662,7 @@ rproc_of_resm_mem_entry_init(struct device *dev, u32 of_resm_idx, size_t len,
>
> int rproc_boot(struct rproc *rproc);
> void rproc_shutdown(struct rproc *rproc);
> +int rproc_detach(struct rproc *rproc);
> int rproc_set_firmware(struct rproc *rproc, const char *fw_name);
> void rproc_report_crash(struct rproc *rproc, enum rproc_crash_type type);
> void rproc_coredump_using_sections(struct rproc *rproc);
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
If it is possible to detach the remote processor, keep an untouched
copy of the resource table. That way we can start from the same
resource table without having to worry about original values or what
elements the startup code has changed when re-attaching to the remote
processor.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Double free of the cached table has been fixed.
- rproc_reset_loaded_rsc_table() has seen a complete re-write.
- rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
dealing with the cached. This allows to properly shutdown a
remote processor that was attached to.
---
drivers/remoteproc/remoteproc_core.c | 86 +++++++++++++++++++++++++++-
include/linux/remoteproc.h | 3 +
2 files changed, 88 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index fc01b29290a6..3a4692cc5220 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return ret;
}
+ /*
+ * If it is possible to detach the remote processor, keep an untouched
+ * copy of the resource table. That way we can start fresh again when
+ * the remote processor is re-attached, that is:
+ *
+ * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+ *
+ * Free'd in rproc_reset_loaded_rsc_table().
+ */
+ if (rproc->ops->detach) {
+ rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+ if (!rproc->clean_table)
+ return -ENOMEM;
+ }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return 0;
}
+static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
+{
+ struct resource_table *table_ptr;
+
+ /*
+ * The cached table is already set if the remote processor was started
+ * by the remoteproc core.
+ */
+ if (rproc->state == RPROC_RUNNING) {
+ rproc->table_ptr = rproc->cached_table;
+ return 0;
+ }
+
+ /* A resource table was never retrieved, nothing to do here */
+ if (!rproc->table_ptr)
+ return 0;
+
+ /*
+ * If we made it to this point a cached_table _must_ have been
+ * allocated in rproc_set_loaded_rsc_table(). If one isn't present
+ * something went really wrong and we must complain.
+ */
+ if (WARN_ON(!rproc->clean_table))
+ return -EINVAL;
+
+ /* Remember where the external entity installed the resource table */
+ table_ptr = rproc->table_ptr;
+
+ /*
+ * Make a copy of the resource table currently used by the remote
+ * processor. Free'd in rproc_detach() or rproc_shutdown().
+ */
+ rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+ if (!rproc->cached_table)
+ return -ENOMEM;
+
+ /*
+ * Use a copy of the resource table for the remainder of the
+ * shutdown process.
+ */
+ rproc->table_ptr = rproc->cached_table;
+
+ /*
+ * Reset the memory area where the firmware loaded the resource table
+ * to its original value. That way when we re-attach the remote
+ * processor the resource table is clean and ready to be used again.
+ */
+ memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+ /*
+ * The clean resource table is no longer needed. Allocated in
+ * rproc_set_loaded_rsc_table().
+ */
+ kfree(rproc->clean_table);
+
+ return 0;
+}
+
/*
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
@@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
/* the installed resource table is no longer accessible */
- rproc->table_ptr = rproc->cached_table;
+ ret = rproc_reset_loaded_rsc_table(rproc);
+ if (ret) {
+ dev_err(dev, "can't reset resource table: %d\n", ret);
+ return ret;
+ }
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
@@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
+ /* the installed resource table is no longer accessible */
+ ret = rproc_reset_loaded_rsc_table(rproc);
+
/* Tell the remote processor the core isn't available anymore */
ret = rproc->ops->detach(rproc);
if (ret) {
@@ -1997,6 +2078,9 @@ int rproc_detach(struct rproc *rproc)
rproc_disable_iommu(rproc);
+ /* Free the copy of the resource table */
+ kfree(rproc->cached_table);
+ rproc->cached_table = NULL;
rproc->table_ptr = NULL;
out:
mutex_unlock(&rproc->lock);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index e1c843c19cc6..e5f52a12a650 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -514,6 +514,8 @@ struct rproc_dump_segment {
* @recovery_disabled: flag that state if recovery was disabled
* @max_notifyid: largest allocated notify id.
* @table_ptr: pointer to the resource table in effect
+ * @clean_table: copy of the resource table without modifications. Used
+ * when a remote processor is attached or detached from the core
* @cached_table: copy of the resource table
* @table_sz: size of @cached_table
* @has_iommu: flag to indicate if remote processor is behind an MMU
@@ -550,6 +552,7 @@ struct rproc {
bool recovery_disabled;
int max_notifyid;
struct resource_table *table_ptr;
+ struct resource_table *clean_table;
struct resource_table *cached_table;
size_t table_sz;
bool has_iommu;
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
If it is possible to detach the remote processor, keep an untouched
copy of the resource table. That way we can start from the same
resource table without having to worry about original values or what
elements the startup code has changed when re-attaching to the remote
processor.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Double free of the cached table has been fixed.
- rproc_reset_loaded_rsc_table() has seen a complete re-write.
- rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
dealing with the cached. This allows to properly shutdown a
remote processor that was attached to.
---
drivers/remoteproc/remoteproc_core.c | 86 +++++++++++++++++++++++++++-
include/linux/remoteproc.h | 3 +
2 files changed, 88 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index fc01b29290a6..3a4692cc5220 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return ret;
}
+ /*
+ * If it is possible to detach the remote processor, keep an untouched
+ * copy of the resource table. That way we can start fresh again when
+ * the remote processor is re-attached, that is:
+ *
+ * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+ *
+ * Free'd in rproc_reset_loaded_rsc_table().
+ */
+ if (rproc->ops->detach) {
+ rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+ if (!rproc->clean_table)
+ return -ENOMEM;
+ }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return 0;
}
+static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
+{
+ struct resource_table *table_ptr;
+
+ /*
+ * The cached table is already set if the remote processor was started
+ * by the remoteproc core.
+ */
+ if (rproc->state == RPROC_RUNNING) {
+ rproc->table_ptr = rproc->cached_table;
+ return 0;
+ }
+
+ /* A resource table was never retrieved, nothing to do here */
+ if (!rproc->table_ptr)
+ return 0;
+
+ /*
+ * If we made it to this point a cached_table _must_ have been
+ * allocated in rproc_set_loaded_rsc_table(). If one isn't present
+ * something went really wrong and we must complain.
+ */
+ if (WARN_ON(!rproc->clean_table))
+ return -EINVAL;
+
+ /* Remember where the external entity installed the resource table */
+ table_ptr = rproc->table_ptr;
+
+ /*
+ * Make a copy of the resource table currently used by the remote
+ * processor. Free'd in rproc_detach() or rproc_shutdown().
+ */
+ rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+ if (!rproc->cached_table)
+ return -ENOMEM;
+
+ /*
+ * Use a copy of the resource table for the remainder of the
+ * shutdown process.
+ */
+ rproc->table_ptr = rproc->cached_table;
+
+ /*
+ * Reset the memory area where the firmware loaded the resource table
+ * to its original value. That way when we re-attach the remote
+ * processor the resource table is clean and ready to be used again.
+ */
+ memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+ /*
+ * The clean resource table is no longer needed. Allocated in
+ * rproc_set_loaded_rsc_table().
+ */
+ kfree(rproc->clean_table);
+
+ return 0;
+}
+
/*
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
@@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
/* the installed resource table is no longer accessible */
- rproc->table_ptr = rproc->cached_table;
+ ret = rproc_reset_loaded_rsc_table(rproc);
+ if (ret) {
+ dev_err(dev, "can't reset resource table: %d\n", ret);
+ return ret;
+ }
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
@@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
+ /* the installed resource table is no longer accessible */
+ ret = rproc_reset_loaded_rsc_table(rproc);
+
/* Tell the remote processor the core isn't available anymore */
ret = rproc->ops->detach(rproc);
if (ret) {
@@ -1997,6 +2078,9 @@ int rproc_detach(struct rproc *rproc)
rproc_disable_iommu(rproc);
+ /* Free the copy of the resource table */
+ kfree(rproc->cached_table);
+ rproc->cached_table = NULL;
rproc->table_ptr = NULL;
out:
mutex_unlock(&rproc->lock);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index e1c843c19cc6..e5f52a12a650 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -514,6 +514,8 @@ struct rproc_dump_segment {
* @recovery_disabled: flag that state if recovery was disabled
* @max_notifyid: largest allocated notify id.
* @table_ptr: pointer to the resource table in effect
+ * @clean_table: copy of the resource table without modifications. Used
+ * when a remote processor is attached or detached from the core
* @cached_table: copy of the resource table
* @table_sz: size of @cached_table
* @has_iommu: flag to indicate if remote processor is behind an MMU
@@ -550,6 +552,7 @@ struct rproc {
bool recovery_disabled;
int max_notifyid;
struct resource_table *table_ptr;
+ struct resource_table *clean_table;
struct resource_table *cached_table;
size_t table_sz;
bool has_iommu;
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:21 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:21 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> If it is possible to detach the remote processor, keep an untouched
> copy of the resource table. That way we can start from the same
> resource table without having to worry about original values or what
> elements the startup code has changed when re-attaching to the remote
> processor.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> ---
> New for V6:
> - Double free of the cached table has been fixed.
> - rproc_reset_loaded_rsc_table() has seen a complete re-write.
> - rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
> dealing with the cached. This allows to properly shutdown a
> remote processor that was attached to.
> ---
>
> drivers/remoteproc/remoteproc_core.c | 86 +++++++++++++++++++++++++++-
> include/linux/remoteproc.h | 3 +
> 2 files changed, 88 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index fc01b29290a6..3a4692cc5220 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return ret;
> }
>
> + /*
> + * If it is possible to detach the remote processor, keep an untouched
> + * copy of the resource table. That way we can start fresh again when
> + * the remote processor is re-attached, that is:
> + *
> + * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> + *
> + * Free'd in rproc_reset_loaded_rsc_table().
> + */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + }
> +
> rproc->cached_table = NULL;
> rproc->table_ptr = table_ptr;
> rproc->table_sz = table_sz;
> @@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return 0;
> }
>
> +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
I spent some time to review this function that handles both the resource table
for both the stop and detach. To make it easier to read, I would divide it into
two functions.
I added a proposal at the end of this mail.
Regards,
Arnaud
> +{
> + struct resource_table *table_ptr;
> +
> + /*
> + * The cached table is already set if the remote processor was started
> + * by the remoteproc core.
> + */
> + if (rproc->state == RPROC_RUNNING) {
> + rproc->table_ptr = rproc->cached_table;
> + return 0;
> + }
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> + * If we made it to this point a cached_table _must_ have been
> + * allocated in rproc_set_loaded_rsc_table(). If one isn't present
> + * something went really wrong and we must complain.
> + */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +
> + /*
> + * Make a copy of the resource table currently used by the remote
> + * processor. Free'd in rproc_detach() or rproc_shutdown().
> + */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> + rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> + * Use a copy of the resource table for the remainder of the
> + * shutdown process.
> + */
> + rproc->table_ptr = rproc->cached_table;
> +
> + /*
> + * Reset the memory area where the firmware loaded the resource table
> + * to its original value. That way when we re-attach the remote
> + * processor the resource table is clean and ready to be used again.
> + */
> + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> + * The clean resource table is no longer needed. Allocated in
> + * rproc_set_loaded_rsc_table().
> + */
> + kfree(rproc->clean_table);
> +
> + return 0;
> +}
> +
> /*
> * Attach to remote processor - similar to rproc_fw_boot() but without
> * the steps that deal with the firmware image.
> @@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> rproc_stop_subdevices(rproc, crashed);
>
> /* the installed resource table is no longer accessible */
> - rproc->table_ptr = rproc->cached_table;
> + ret = rproc_reset_loaded_rsc_table(rproc);
> + if (ret) {
> + dev_err(dev, "can't reset resource table: %d\n", ret);
> + return ret;
> + }
>
> /* power off the remote processor */
> ret = rproc->ops->stop(rproc);
> @@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
> /* Stop any subdevices for the remote processor */
> rproc_stop_subdevices(rproc, false);
>
> + /* the installed resource table is no longer accessible */
> + ret = rproc_reset_loaded_rsc_table(rproc);
> +
> /* Tell the remote processor the core isn't available anymore */
> ret = rproc->ops->detach(rproc);
> if (ret) {
> @@ -1997,6 +2078,9 @@ int rproc_detach(struct rproc *rproc)
>
> rproc_disable_iommu(rproc);
>
> + /* Free the copy of the resource table */
> + kfree(rproc->cached_table);
> + rproc->cached_table = NULL;
> rproc->table_ptr = NULL;
> out:
> mutex_unlock(&rproc->lock);
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index e1c843c19cc6..e5f52a12a650 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -514,6 +514,8 @@ struct rproc_dump_segment {
> * @recovery_disabled: flag that state if recovery was disabled
> * @max_notifyid: largest allocated notify id.
> * @table_ptr: pointer to the resource table in effect
> + * @clean_table: copy of the resource table without modifications. Used
> + * when a remote processor is attached or detached from the core
> * @cached_table: copy of the resource table
> * @table_sz: size of @cached_table
> * @has_iommu: flag to indicate if remote processor is behind an MMU
> @@ -550,6 +552,7 @@ struct rproc {
> bool recovery_disabled;
> int max_notifyid;
> struct resource_table *table_ptr;
> + struct resource_table *clean_table;
> struct resource_table *cached_table;
> size_t table_sz;
> bool has_iommu;
>
---
drivers/remoteproc/remoteproc_core.c | 101 ++++++++++++++++++++++++++-
include/linux/remoteproc.h | 3 +
2 files changed, 103 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c
b/drivers/remoteproc/remoteproc_core.c
index fc01b29290a6..cc24c360eb8b 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return ret;
}
+ /*
+ * If it is possible to detach the remote processor, keep an untouched
+ * copy of the resource table. That way we can start fresh again when
+ * the remote processor is re-attached, that is:
+ *
+ * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+ *
+ * Free'd in rproc_reset_loaded_rsc_table().
+ */
+ if (rproc->ops->detach) {
+ rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+ if (!rproc->clean_table)
+ return -ENOMEM;
+ }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1578,79 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return 0;
}
+static int rproc_set_to_cached_rsc_table(struct rproc *rproc)
+{
+ /* A resource table was never retrieved, nothing to do here */
+ if (!rproc->table_ptr)
+ return 0;
+
+ /*
+ * The cached table is already set if the remote processor was started
+ * by the remoteproc core.
+ */
+ if (!rproc->cached_table) {
+ rproc->table_ptr = rproc->cached_table;
+ return 0;
+ }
+
+ /*
+ * Make a copy of the resource table currently used by the remote
+ * processor. Free'd in rproc_detach() or rproc_shutdown().
+ */
+ rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+ if (!rproc->cached_table)
+ return -ENOMEM;
+
+ /*
+ * Use a copy of the resource table for the remainder of the
+ * shutdown process.
+ */
+ rproc->table_ptr = rproc->cached_table;
+
+ return 0;
+}
+
+static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
+{
+ struct resource_table *table_ptr;
+ int ret;
+
+ /* A resource table was never retrieved, nothing to do here */
+ if (!rproc->table_ptr)
+ return 0;
+
+ /*
+ * If we made it to this point a cached_table _mst_ have been
+ * allocated in rproc_set_loaded_rsc_table(). If one isn't present
+ * something went really wrong and we must complain.
+ */
+ if (WARN_ON(!rproc->clean_table))
+ return -EINVAL;
+
+ /* Remember where the external entity installed the resource table */
+ table_ptr = rproc->table_ptr;
+
+ ret = rproc_set_to_cached_rsc_table(rproc);
+ if (ret)
+ return ret;
+
+ /*
+ * Reset the memory area where the firmware loaded the resource table
+ * to its original value. That way when we re-attach the remote
+ * processor the resource table is clean and ready to be used again.
+ */
+ memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+ /*
+ * The clean resource table is no longer needed. Allocated in
+ * rproc_set_loaded_rsc_table().
+ */
+ kfree(rproc->clean_table);
+
+ return 0;
+}
+
/*
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
@@ -1688,7 +1776,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
/* the installed resource table is no longer accessible */
- rproc->table_ptr = rproc->cached_table;
+ ret = rproc_set_to_cached_rsc_table(rproc);
+ if (ret) {
+ dev_err(dev, "can't reset resource table: %d\n", ret);
+ return ret;
+ }
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
@@ -1721,6 +1813,9 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
+ /* The installed resource table need to be reset and no longer accessible */
+ ret = rproc_reset_loaded_rsc_table(rproc);
+
/* Tell the remote processor the core isn't available anymore */
ret = rproc->ops->detach(rproc);
if (ret) {
@@ -1941,6 +2036,7 @@ void rproc_shutdown(struct rproc *rproc)
/* Free the copy of the resource table */
kfree(rproc->cached_table);
+ kfree(rproc->clean_table);
rproc->cached_table = NULL;
rproc->table_ptr = NULL;
out:
@@ -1997,6 +2093,9 @@ int rproc_detach(struct rproc *rproc)
rproc_disable_iommu(rproc);
+ /* Free the copy of the resource table */
+ kfree(rproc->cached_table);
+ rproc->cached_table = NULL;
rproc->table_ptr = NULL;
out:
mutex_unlock(&rproc->lock);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index e1c843c19cc6..e5f52a12a650 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -514,6 +514,8 @@ struct rproc_dump_segment {
* @recovery_disabled: flag that state if recovery was disabled
* @max_notifyid: largest allocated notify id.
* @table_ptr: pointer to the resource table in effect
+ * @clean_table: copy of the resource table without modifications. Used
+ * when a remote processor is attached or detached from the core
* @cached_table: copy of the resource table
* @table_sz: size of @cached_table
* @has_iommu: flag to indicate if remote processor is behind an MMU
@@ -550,6 +552,7 @@ struct rproc {
bool recovery_disabled;
int max_notifyid;
struct resource_table *table_ptr;
+ struct resource_table *clean_table;
struct resource_table *cached_table;
size_t table_sz;
bool has_iommu;
--
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached
@ 2021-02-26 16:21 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:21 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> If it is possible to detach the remote processor, keep an untouched
> copy of the resource table. That way we can start from the same
> resource table without having to worry about original values or what
> elements the startup code has changed when re-attaching to the remote
> processor.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> ---
> New for V6:
> - Double free of the cached table has been fixed.
> - rproc_reset_loaded_rsc_table() has seen a complete re-write.
> - rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
> dealing with the cached. This allows to properly shutdown a
> remote processor that was attached to.
> ---
>
> drivers/remoteproc/remoteproc_core.c | 86 +++++++++++++++++++++++++++-
> include/linux/remoteproc.h | 3 +
> 2 files changed, 88 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index fc01b29290a6..3a4692cc5220 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return ret;
> }
>
> + /*
> + * If it is possible to detach the remote processor, keep an untouched
> + * copy of the resource table. That way we can start fresh again when
> + * the remote processor is re-attached, that is:
> + *
> + * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> + *
> + * Free'd in rproc_reset_loaded_rsc_table().
> + */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + }
> +
> rproc->cached_table = NULL;
> rproc->table_ptr = table_ptr;
> rproc->table_sz = table_sz;
> @@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return 0;
> }
>
> +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
I spent some time to review this function that handles both the resource table
for both the stop and detach. To make it easier to read, I would divide it into
two functions.
I added a proposal at the end of this mail.
Regards,
Arnaud
> +{
> + struct resource_table *table_ptr;
> +
> + /*
> + * The cached table is already set if the remote processor was started
> + * by the remoteproc core.
> + */
> + if (rproc->state == RPROC_RUNNING) {
> + rproc->table_ptr = rproc->cached_table;
> + return 0;
> + }
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> + * If we made it to this point a cached_table _must_ have been
> + * allocated in rproc_set_loaded_rsc_table(). If one isn't present
> + * something went really wrong and we must complain.
> + */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +
> + /*
> + * Make a copy of the resource table currently used by the remote
> + * processor. Free'd in rproc_detach() or rproc_shutdown().
> + */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> + rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> + * Use a copy of the resource table for the remainder of the
> + * shutdown process.
> + */
> + rproc->table_ptr = rproc->cached_table;
> +
> + /*
> + * Reset the memory area where the firmware loaded the resource table
> + * to its original value. That way when we re-attach the remote
> + * processor the resource table is clean and ready to be used again.
> + */
> + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> + * The clean resource table is no longer needed. Allocated in
> + * rproc_set_loaded_rsc_table().
> + */
> + kfree(rproc->clean_table);
> +
> + return 0;
> +}
> +
> /*
> * Attach to remote processor - similar to rproc_fw_boot() but without
> * the steps that deal with the firmware image.
> @@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> rproc_stop_subdevices(rproc, crashed);
>
> /* the installed resource table is no longer accessible */
> - rproc->table_ptr = rproc->cached_table;
> + ret = rproc_reset_loaded_rsc_table(rproc);
> + if (ret) {
> + dev_err(dev, "can't reset resource table: %d\n", ret);
> + return ret;
> + }
>
> /* power off the remote processor */
> ret = rproc->ops->stop(rproc);
> @@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
> /* Stop any subdevices for the remote processor */
> rproc_stop_subdevices(rproc, false);
>
> + /* the installed resource table is no longer accessible */
> + ret = rproc_reset_loaded_rsc_table(rproc);
> +
> /* Tell the remote processor the core isn't available anymore */
> ret = rproc->ops->detach(rproc);
> if (ret) {
> @@ -1997,6 +2078,9 @@ int rproc_detach(struct rproc *rproc)
>
> rproc_disable_iommu(rproc);
>
> + /* Free the copy of the resource table */
> + kfree(rproc->cached_table);
> + rproc->cached_table = NULL;
> rproc->table_ptr = NULL;
> out:
> mutex_unlock(&rproc->lock);
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index e1c843c19cc6..e5f52a12a650 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -514,6 +514,8 @@ struct rproc_dump_segment {
> * @recovery_disabled: flag that state if recovery was disabled
> * @max_notifyid: largest allocated notify id.
> * @table_ptr: pointer to the resource table in effect
> + * @clean_table: copy of the resource table without modifications. Used
> + * when a remote processor is attached or detached from the core
> * @cached_table: copy of the resource table
> * @table_sz: size of @cached_table
> * @has_iommu: flag to indicate if remote processor is behind an MMU
> @@ -550,6 +552,7 @@ struct rproc {
> bool recovery_disabled;
> int max_notifyid;
> struct resource_table *table_ptr;
> + struct resource_table *clean_table;
> struct resource_table *cached_table;
> size_t table_sz;
> bool has_iommu;
>
---
drivers/remoteproc/remoteproc_core.c | 101 ++++++++++++++++++++++++++-
include/linux/remoteproc.h | 3 +
2 files changed, 103 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c
b/drivers/remoteproc/remoteproc_core.c
index fc01b29290a6..cc24c360eb8b 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return ret;
}
+ /*
+ * If it is possible to detach the remote processor, keep an untouched
+ * copy of the resource table. That way we can start fresh again when
+ * the remote processor is re-attached, that is:
+ *
+ * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+ *
+ * Free'd in rproc_reset_loaded_rsc_table().
+ */
+ if (rproc->ops->detach) {
+ rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+ if (!rproc->clean_table)
+ return -ENOMEM;
+ }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1578,79 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
return 0;
}
+static int rproc_set_to_cached_rsc_table(struct rproc *rproc)
+{
+ /* A resource table was never retrieved, nothing to do here */
+ if (!rproc->table_ptr)
+ return 0;
+
+ /*
+ * The cached table is already set if the remote processor was started
+ * by the remoteproc core.
+ */
+ if (!rproc->cached_table) {
+ rproc->table_ptr = rproc->cached_table;
+ return 0;
+ }
+
+ /*
+ * Make a copy of the resource table currently used by the remote
+ * processor. Free'd in rproc_detach() or rproc_shutdown().
+ */
+ rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+ if (!rproc->cached_table)
+ return -ENOMEM;
+
+ /*
+ * Use a copy of the resource table for the remainder of the
+ * shutdown process.
+ */
+ rproc->table_ptr = rproc->cached_table;
+
+ return 0;
+}
+
+static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
+{
+ struct resource_table *table_ptr;
+ int ret;
+
+ /* A resource table was never retrieved, nothing to do here */
+ if (!rproc->table_ptr)
+ return 0;
+
+ /*
+ * If we made it to this point a cached_table _mst_ have been
+ * allocated in rproc_set_loaded_rsc_table(). If one isn't present
+ * something went really wrong and we must complain.
+ */
+ if (WARN_ON(!rproc->clean_table))
+ return -EINVAL;
+
+ /* Remember where the external entity installed the resource table */
+ table_ptr = rproc->table_ptr;
+
+ ret = rproc_set_to_cached_rsc_table(rproc);
+ if (ret)
+ return ret;
+
+ /*
+ * Reset the memory area where the firmware loaded the resource table
+ * to its original value. That way when we re-attach the remote
+ * processor the resource table is clean and ready to be used again.
+ */
+ memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+ /*
+ * The clean resource table is no longer needed. Allocated in
+ * rproc_set_loaded_rsc_table().
+ */
+ kfree(rproc->clean_table);
+
+ return 0;
+}
+
/*
* Attach to remote processor - similar to rproc_fw_boot() but without
* the steps that deal with the firmware image.
@@ -1688,7 +1776,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
/* the installed resource table is no longer accessible */
- rproc->table_ptr = rproc->cached_table;
+ ret = rproc_set_to_cached_rsc_table(rproc);
+ if (ret) {
+ dev_err(dev, "can't reset resource table: %d\n", ret);
+ return ret;
+ }
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
@@ -1721,6 +1813,9 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
+ /* The installed resource table need to be reset and no longer accessible */
+ ret = rproc_reset_loaded_rsc_table(rproc);
+
/* Tell the remote processor the core isn't available anymore */
ret = rproc->ops->detach(rproc);
if (ret) {
@@ -1941,6 +2036,7 @@ void rproc_shutdown(struct rproc *rproc)
/* Free the copy of the resource table */
kfree(rproc->cached_table);
+ kfree(rproc->clean_table);
rproc->cached_table = NULL;
rproc->table_ptr = NULL;
out:
@@ -1997,6 +2093,9 @@ int rproc_detach(struct rproc *rproc)
rproc_disable_iommu(rproc);
+ /* Free the copy of the resource table */
+ kfree(rproc->cached_table);
+ rproc->cached_table = NULL;
rproc->table_ptr = NULL;
out:
mutex_unlock(&rproc->lock);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index e1c843c19cc6..e5f52a12a650 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -514,6 +514,8 @@ struct rproc_dump_segment {
* @recovery_disabled: flag that state if recovery was disabled
* @max_notifyid: largest allocated notify id.
* @table_ptr: pointer to the resource table in effect
+ * @clean_table: copy of the resource table without modifications. Used
+ * when a remote processor is attached or detached from the core
* @cached_table: copy of the resource table
* @table_sz: size of @cached_table
* @has_iommu: flag to indicate if remote processor is behind an MMU
@@ -550,6 +552,7 @@ struct rproc {
bool recovery_disabled;
int max_notifyid;
struct resource_table *table_ptr;
+ struct resource_table *clean_table;
struct resource_table *cached_table;
size_t table_sz;
bool has_iommu;
--
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached
2021-02-26 16:21 ` Arnaud POULIQUEN
@ 2021-03-01 18:41 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:41 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, bjorn.andersson, arnaud.pouliquen, mcoquelin.stm32,
alexandre.torgue, linux-remoteproc, linux-kernel,
linux-arm-kernel
On Fri, Feb 26, 2021 at 05:21:15PM +0100, Arnaud POULIQUEN wrote:
>
>
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > If it is possible to detach the remote processor, keep an untouched
> > copy of the resource table. That way we can start from the same
> > resource table without having to worry about original values or what
> > elements the startup code has changed when re-attaching to the remote
> > processor.
> >
> > Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> > ---
> > New for V6:
> > - Double free of the cached table has been fixed.
> > - rproc_reset_loaded_rsc_table() has seen a complete re-write.
> > - rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
> > dealing with the cached. This allows to properly shutdown a
> > remote processor that was attached to.
> > ---
> >
> > drivers/remoteproc/remoteproc_core.c | 86 +++++++++++++++++++++++++++-
> > include/linux/remoteproc.h | 3 +
> > 2 files changed, 88 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> > index fc01b29290a6..3a4692cc5220 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> > return ret;
> > }
> >
> > + /*
> > + * If it is possible to detach the remote processor, keep an untouched
> > + * copy of the resource table. That way we can start fresh again when
> > + * the remote processor is re-attached, that is:
> > + *
> > + * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> > + *
> > + * Free'd in rproc_reset_loaded_rsc_table().
> > + */
> > + if (rproc->ops->detach) {
> > + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> > + if (!rproc->clean_table)
> > + return -ENOMEM;
> > + }
> > +
> > rproc->cached_table = NULL;
> > rproc->table_ptr = table_ptr;
> > rproc->table_sz = table_sz;
> > @@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> > return 0;
> > }
> >
> > +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
>
> I spent some time to review this function that handles both the resource table
> for both the stop and detach. To make it easier to read, I would divide it into
> two functions.
I suspected rproc_reset_loaded_rsc_table() was trying to do too many things for
its own good and you just confirmed that.
> I added a proposal at the end of this mail.
>
> Regards,
> Arnaud
>
> > +{
> > + struct resource_table *table_ptr;
> > +
> > + /*
> > + * The cached table is already set if the remote processor was started
> > + * by the remoteproc core.
> > + */
> > + if (rproc->state == RPROC_RUNNING) {
> > + rproc->table_ptr = rproc->cached_table;
> > + return 0;
> > + }
> > +
> > + /* A resource table was never retrieved, nothing to do here */
> > + if (!rproc->table_ptr)
> > + return 0;
> > +
> > + /*
> > + * If we made it to this point a cached_table _must_ have been
> > + * allocated in rproc_set_loaded_rsc_table(). If one isn't present
> > + * something went really wrong and we must complain.
> > + */
> > + if (WARN_ON(!rproc->clean_table))
> > + return -EINVAL;
> > +
> > + /* Remember where the external entity installed the resource table */
> > + table_ptr = rproc->table_ptr;
> > +
> > + /*
> > + * Make a copy of the resource table currently used by the remote
> > + * processor. Free'd in rproc_detach() or rproc_shutdown().
> > + */
> > + rproc->cached_table = kmemdup(rproc->table_ptr,
> > + rproc->table_sz, GFP_KERNEL);
> > + if (!rproc->cached_table)
> > + return -ENOMEM;
> > +
> > + /*
> > + * Use a copy of the resource table for the remainder of the
> > + * shutdown process.
> > + */
> > + rproc->table_ptr = rproc->cached_table;
> > +
> > + /*
> > + * Reset the memory area where the firmware loaded the resource table
> > + * to its original value. That way when we re-attach the remote
> > + * processor the resource table is clean and ready to be used again.
> > + */
> > + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> > +
> > + /*
> > + * The clean resource table is no longer needed. Allocated in
> > + * rproc_set_loaded_rsc_table().
> > + */
> > + kfree(rproc->clean_table);
> > +
> > + return 0;
> > +}
> > +
> > /*
> > * Attach to remote processor - similar to rproc_fw_boot() but without
> > * the steps that deal with the firmware image.
> > @@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> > rproc_stop_subdevices(rproc, crashed);
> >
> > /* the installed resource table is no longer accessible */
> > - rproc->table_ptr = rproc->cached_table;
> > + ret = rproc_reset_loaded_rsc_table(rproc);
> > + if (ret) {
> > + dev_err(dev, "can't reset resource table: %d\n", ret);
> > + return ret;
> > + }
> >
> > /* power off the remote processor */
> > ret = rproc->ops->stop(rproc);
> > @@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
> > /* Stop any subdevices for the remote processor */
> > rproc_stop_subdevices(rproc, false);
> >
> > + /* the installed resource table is no longer accessible */
> > + ret = rproc_reset_loaded_rsc_table(rproc);
> > +
> > /* Tell the remote processor the core isn't available anymore */
> > ret = rproc->ops->detach(rproc);
> > if (ret) {
> > @@ -1997,6 +2078,9 @@ int rproc_detach(struct rproc *rproc)
> >
> > rproc_disable_iommu(rproc);
> >
> > + /* Free the copy of the resource table */
> > + kfree(rproc->cached_table);
> > + rproc->cached_table = NULL;
> > rproc->table_ptr = NULL;
> > out:
> > mutex_unlock(&rproc->lock);
> > diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> > index e1c843c19cc6..e5f52a12a650 100644
> > --- a/include/linux/remoteproc.h
> > +++ b/include/linux/remoteproc.h
> > @@ -514,6 +514,8 @@ struct rproc_dump_segment {
> > * @recovery_disabled: flag that state if recovery was disabled
> > * @max_notifyid: largest allocated notify id.
> > * @table_ptr: pointer to the resource table in effect
> > + * @clean_table: copy of the resource table without modifications. Used
> > + * when a remote processor is attached or detached from the core
> > * @cached_table: copy of the resource table
> > * @table_sz: size of @cached_table
> > * @has_iommu: flag to indicate if remote processor is behind an MMU
> > @@ -550,6 +552,7 @@ struct rproc {
> > bool recovery_disabled;
> > int max_notifyid;
> > struct resource_table *table_ptr;
> > + struct resource_table *clean_table;
> > struct resource_table *cached_table;
> > size_t table_sz;
> > bool has_iommu;
> >
>
>
> ---
> drivers/remoteproc/remoteproc_core.c | 101 ++++++++++++++++++++++++++-
> include/linux/remoteproc.h | 3 +
> 2 files changed, 103 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c
> b/drivers/remoteproc/remoteproc_core.c
> index fc01b29290a6..cc24c360eb8b 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return ret;
> }
>
> + /*
> + * If it is possible to detach the remote processor, keep an untouched
> + * copy of the resource table. That way we can start fresh again when
> + * the remote processor is re-attached, that is:
> + *
> + * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> + *
> + * Free'd in rproc_reset_loaded_rsc_table().
> + */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + }
> +
> rproc->cached_table = NULL;
> rproc->table_ptr = table_ptr;
> rproc->table_sz = table_sz;
> @@ -1563,6 +1578,79 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return 0;
> }
>
> +static int rproc_set_to_cached_rsc_table(struct rproc *rproc)
> +{
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> + * The cached table is already set if the remote processor was started
> + * by the remoteproc core.
> + */
> + if (!rproc->cached_table) {
> + rproc->table_ptr = rproc->cached_table;
> + return 0;
> + }
> +
> + /*
> + * Make a copy of the resource table currently used by the remote
> + * processor. Free'd in rproc_detach() or rproc_shutdown().
> + */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> + rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> + * Use a copy of the resource table for the remainder of the
> + * shutdown process.
> + */
> + rproc->table_ptr = rproc->cached_table;
> +
> + return 0;
> +}
> +
> +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
> +{
> + struct resource_table *table_ptr;
> + int ret;
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> + * If we made it to this point a cached_table _mst_ have been
> + * allocated in rproc_set_loaded_rsc_table(). If one isn't present
> + * something went really wrong and we must complain.
> + */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +
> + ret = rproc_set_to_cached_rsc_table(rproc);
> + if (ret)
> + return ret;
Ok, let's split them. On the flip side I don't think calling
rproc_set_to_cached_rsc_table() from rproc_reset_loaded_rsc_table() helps with
clarity.
I will simply spin off two distinct functions that do exactly what they are
supposed to do. There will be code duplication but I'm good with that if it
helps with readability and maintenance.
I will rename rproc_set_loaded_rsc_table() to rproc_set_rsc_table() and spinoff
two new functions: rproc_reset_rsc_table_stop() and
rproc_reset_rsc_table_detach().
Hopefully that will work better.
> +
> + /*
> + * Reset the memory area where the firmware loaded the resource table
> + * to its original value. That way when we re-attach the remote
> + * processor the resource table is clean and ready to be used again.
> + */
> + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> + * The clean resource table is no longer needed. Allocated in
> + * rproc_set_loaded_rsc_table().
> + */
> + kfree(rproc->clean_table);
> +
> + return 0;
> +}
> +
> /*
> * Attach to remote processor - similar to rproc_fw_boot() but without
> * the steps that deal with the firmware image.
> @@ -1688,7 +1776,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> rproc_stop_subdevices(rproc, crashed);
>
> /* the installed resource table is no longer accessible */
> - rproc->table_ptr = rproc->cached_table;
> + ret = rproc_set_to_cached_rsc_table(rproc);
> + if (ret) {
> + dev_err(dev, "can't reset resource table: %d\n", ret);
> + return ret;
> + }
>
> /* power off the remote processor */
> ret = rproc->ops->stop(rproc);
> @@ -1721,6 +1813,9 @@ static int __rproc_detach(struct rproc *rproc)
> /* Stop any subdevices for the remote processor */
> rproc_stop_subdevices(rproc, false);
>
> + /* The installed resource table need to be reset and no longer accessible */
> + ret = rproc_reset_loaded_rsc_table(rproc);
> +
> /* Tell the remote processor the core isn't available anymore */
> ret = rproc->ops->detach(rproc);
> if (ret) {
> @@ -1941,6 +2036,7 @@ void rproc_shutdown(struct rproc *rproc)
>
> /* Free the copy of the resource table */
> kfree(rproc->cached_table);
> + kfree(rproc->clean_table);
> rproc->cached_table = NULL;
> rproc->table_ptr = NULL;
> out:
> @@ -1997,6 +2093,9 @@ int rproc_detach(struct rproc *rproc)
>
> rproc_disable_iommu(rproc);
>
> + /* Free the copy of the resource table */
> + kfree(rproc->cached_table);
> + rproc->cached_table = NULL;
> rproc->table_ptr = NULL;
> out:
> mutex_unlock(&rproc->lock);
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index e1c843c19cc6..e5f52a12a650 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -514,6 +514,8 @@ struct rproc_dump_segment {
> * @recovery_disabled: flag that state if recovery was disabled
> * @max_notifyid: largest allocated notify id.
> * @table_ptr: pointer to the resource table in effect
> + * @clean_table: copy of the resource table without modifications. Used
> + * when a remote processor is attached or detached from the core
> * @cached_table: copy of the resource table
> * @table_sz: size of @cached_table
> * @has_iommu: flag to indicate if remote processor is behind an MMU
> @@ -550,6 +552,7 @@ struct rproc {
> bool recovery_disabled;
> int max_notifyid;
> struct resource_table *table_ptr;
> + struct resource_table *clean_table;
> struct resource_table *cached_table;
> size_t table_sz;
> bool has_iommu;
> --
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached
@ 2021-03-01 18:41 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:41 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, alexandre.torgue, arnaud.pouliquen, linux-remoteproc,
linux-kernel, bjorn.andersson, mcoquelin.stm32, linux-arm-kernel
On Fri, Feb 26, 2021 at 05:21:15PM +0100, Arnaud POULIQUEN wrote:
>
>
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > If it is possible to detach the remote processor, keep an untouched
> > copy of the resource table. That way we can start from the same
> > resource table without having to worry about original values or what
> > elements the startup code has changed when re-attaching to the remote
> > processor.
> >
> > Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> > ---
> > New for V6:
> > - Double free of the cached table has been fixed.
> > - rproc_reset_loaded_rsc_table() has seen a complete re-write.
> > - rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
> > dealing with the cached. This allows to properly shutdown a
> > remote processor that was attached to.
> > ---
> >
> > drivers/remoteproc/remoteproc_core.c | 86 +++++++++++++++++++++++++++-
> > include/linux/remoteproc.h | 3 +
> > 2 files changed, 88 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> > index fc01b29290a6..3a4692cc5220 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> > return ret;
> > }
> >
> > + /*
> > + * If it is possible to detach the remote processor, keep an untouched
> > + * copy of the resource table. That way we can start fresh again when
> > + * the remote processor is re-attached, that is:
> > + *
> > + * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> > + *
> > + * Free'd in rproc_reset_loaded_rsc_table().
> > + */
> > + if (rproc->ops->detach) {
> > + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> > + if (!rproc->clean_table)
> > + return -ENOMEM;
> > + }
> > +
> > rproc->cached_table = NULL;
> > rproc->table_ptr = table_ptr;
> > rproc->table_sz = table_sz;
> > @@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> > return 0;
> > }
> >
> > +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
>
> I spent some time to review this function that handles both the resource table
> for both the stop and detach. To make it easier to read, I would divide it into
> two functions.
I suspected rproc_reset_loaded_rsc_table() was trying to do too many things for
its own good and you just confirmed that.
> I added a proposal at the end of this mail.
>
> Regards,
> Arnaud
>
> > +{
> > + struct resource_table *table_ptr;
> > +
> > + /*
> > + * The cached table is already set if the remote processor was started
> > + * by the remoteproc core.
> > + */
> > + if (rproc->state == RPROC_RUNNING) {
> > + rproc->table_ptr = rproc->cached_table;
> > + return 0;
> > + }
> > +
> > + /* A resource table was never retrieved, nothing to do here */
> > + if (!rproc->table_ptr)
> > + return 0;
> > +
> > + /*
> > + * If we made it to this point a cached_table _must_ have been
> > + * allocated in rproc_set_loaded_rsc_table(). If one isn't present
> > + * something went really wrong and we must complain.
> > + */
> > + if (WARN_ON(!rproc->clean_table))
> > + return -EINVAL;
> > +
> > + /* Remember where the external entity installed the resource table */
> > + table_ptr = rproc->table_ptr;
> > +
> > + /*
> > + * Make a copy of the resource table currently used by the remote
> > + * processor. Free'd in rproc_detach() or rproc_shutdown().
> > + */
> > + rproc->cached_table = kmemdup(rproc->table_ptr,
> > + rproc->table_sz, GFP_KERNEL);
> > + if (!rproc->cached_table)
> > + return -ENOMEM;
> > +
> > + /*
> > + * Use a copy of the resource table for the remainder of the
> > + * shutdown process.
> > + */
> > + rproc->table_ptr = rproc->cached_table;
> > +
> > + /*
> > + * Reset the memory area where the firmware loaded the resource table
> > + * to its original value. That way when we re-attach the remote
> > + * processor the resource table is clean and ready to be used again.
> > + */
> > + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> > +
> > + /*
> > + * The clean resource table is no longer needed. Allocated in
> > + * rproc_set_loaded_rsc_table().
> > + */
> > + kfree(rproc->clean_table);
> > +
> > + return 0;
> > +}
> > +
> > /*
> > * Attach to remote processor - similar to rproc_fw_boot() but without
> > * the steps that deal with the firmware image.
> > @@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> > rproc_stop_subdevices(rproc, crashed);
> >
> > /* the installed resource table is no longer accessible */
> > - rproc->table_ptr = rproc->cached_table;
> > + ret = rproc_reset_loaded_rsc_table(rproc);
> > + if (ret) {
> > + dev_err(dev, "can't reset resource table: %d\n", ret);
> > + return ret;
> > + }
> >
> > /* power off the remote processor */
> > ret = rproc->ops->stop(rproc);
> > @@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
> > /* Stop any subdevices for the remote processor */
> > rproc_stop_subdevices(rproc, false);
> >
> > + /* the installed resource table is no longer accessible */
> > + ret = rproc_reset_loaded_rsc_table(rproc);
> > +
> > /* Tell the remote processor the core isn't available anymore */
> > ret = rproc->ops->detach(rproc);
> > if (ret) {
> > @@ -1997,6 +2078,9 @@ int rproc_detach(struct rproc *rproc)
> >
> > rproc_disable_iommu(rproc);
> >
> > + /* Free the copy of the resource table */
> > + kfree(rproc->cached_table);
> > + rproc->cached_table = NULL;
> > rproc->table_ptr = NULL;
> > out:
> > mutex_unlock(&rproc->lock);
> > diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> > index e1c843c19cc6..e5f52a12a650 100644
> > --- a/include/linux/remoteproc.h
> > +++ b/include/linux/remoteproc.h
> > @@ -514,6 +514,8 @@ struct rproc_dump_segment {
> > * @recovery_disabled: flag that state if recovery was disabled
> > * @max_notifyid: largest allocated notify id.
> > * @table_ptr: pointer to the resource table in effect
> > + * @clean_table: copy of the resource table without modifications. Used
> > + * when a remote processor is attached or detached from the core
> > * @cached_table: copy of the resource table
> > * @table_sz: size of @cached_table
> > * @has_iommu: flag to indicate if remote processor is behind an MMU
> > @@ -550,6 +552,7 @@ struct rproc {
> > bool recovery_disabled;
> > int max_notifyid;
> > struct resource_table *table_ptr;
> > + struct resource_table *clean_table;
> > struct resource_table *cached_table;
> > size_t table_sz;
> > bool has_iommu;
> >
>
>
> ---
> drivers/remoteproc/remoteproc_core.c | 101 ++++++++++++++++++++++++++-
> include/linux/remoteproc.h | 3 +
> 2 files changed, 103 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/remoteproc/remoteproc_core.c
> b/drivers/remoteproc/remoteproc_core.c
> index fc01b29290a6..cc24c360eb8b 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return ret;
> }
>
> + /*
> + * If it is possible to detach the remote processor, keep an untouched
> + * copy of the resource table. That way we can start fresh again when
> + * the remote processor is re-attached, that is:
> + *
> + * DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> + *
> + * Free'd in rproc_reset_loaded_rsc_table().
> + */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + }
> +
> rproc->cached_table = NULL;
> rproc->table_ptr = table_ptr;
> rproc->table_sz = table_sz;
> @@ -1563,6 +1578,79 @@ static int rproc_set_loaded_rsc_table(struct rproc *rproc)
> return 0;
> }
>
> +static int rproc_set_to_cached_rsc_table(struct rproc *rproc)
> +{
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> + * The cached table is already set if the remote processor was started
> + * by the remoteproc core.
> + */
> + if (!rproc->cached_table) {
> + rproc->table_ptr = rproc->cached_table;
> + return 0;
> + }
> +
> + /*
> + * Make a copy of the resource table currently used by the remote
> + * processor. Free'd in rproc_detach() or rproc_shutdown().
> + */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> + rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> + * Use a copy of the resource table for the remainder of the
> + * shutdown process.
> + */
> + rproc->table_ptr = rproc->cached_table;
> +
> + return 0;
> +}
> +
> +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
> +{
> + struct resource_table *table_ptr;
> + int ret;
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> + * If we made it to this point a cached_table _mst_ have been
> + * allocated in rproc_set_loaded_rsc_table(). If one isn't present
> + * something went really wrong and we must complain.
> + */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +
> + ret = rproc_set_to_cached_rsc_table(rproc);
> + if (ret)
> + return ret;
Ok, let's split them. On the flip side I don't think calling
rproc_set_to_cached_rsc_table() from rproc_reset_loaded_rsc_table() helps with
clarity.
I will simply spin off two distinct functions that do exactly what they are
supposed to do. There will be code duplication but I'm good with that if it
helps with readability and maintenance.
I will rename rproc_set_loaded_rsc_table() to rproc_set_rsc_table() and spinoff
two new functions: rproc_reset_rsc_table_stop() and
rproc_reset_rsc_table_detach().
Hopefully that will work better.
> +
> + /*
> + * Reset the memory area where the firmware loaded the resource table
> + * to its original value. That way when we re-attach the remote
> + * processor the resource table is clean and ready to be used again.
> + */
> + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> + * The clean resource table is no longer needed. Allocated in
> + * rproc_set_loaded_rsc_table().
> + */
> + kfree(rproc->clean_table);
> +
> + return 0;
> +}
> +
> /*
> * Attach to remote processor - similar to rproc_fw_boot() but without
> * the steps that deal with the firmware image.
> @@ -1688,7 +1776,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> rproc_stop_subdevices(rproc, crashed);
>
> /* the installed resource table is no longer accessible */
> - rproc->table_ptr = rproc->cached_table;
> + ret = rproc_set_to_cached_rsc_table(rproc);
> + if (ret) {
> + dev_err(dev, "can't reset resource table: %d\n", ret);
> + return ret;
> + }
>
> /* power off the remote processor */
> ret = rproc->ops->stop(rproc);
> @@ -1721,6 +1813,9 @@ static int __rproc_detach(struct rproc *rproc)
> /* Stop any subdevices for the remote processor */
> rproc_stop_subdevices(rproc, false);
>
> + /* The installed resource table need to be reset and no longer accessible */
> + ret = rproc_reset_loaded_rsc_table(rproc);
> +
> /* Tell the remote processor the core isn't available anymore */
> ret = rproc->ops->detach(rproc);
> if (ret) {
> @@ -1941,6 +2036,7 @@ void rproc_shutdown(struct rproc *rproc)
>
> /* Free the copy of the resource table */
> kfree(rproc->cached_table);
> + kfree(rproc->clean_table);
> rproc->cached_table = NULL;
> rproc->table_ptr = NULL;
> out:
> @@ -1997,6 +2093,9 @@ int rproc_detach(struct rproc *rproc)
>
> rproc_disable_iommu(rproc);
>
> + /* Free the copy of the resource table */
> + kfree(rproc->cached_table);
> + rproc->cached_table = NULL;
> rproc->table_ptr = NULL;
> out:
> mutex_unlock(&rproc->lock);
> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
> index e1c843c19cc6..e5f52a12a650 100644
> --- a/include/linux/remoteproc.h
> +++ b/include/linux/remoteproc.h
> @@ -514,6 +514,8 @@ struct rproc_dump_segment {
> * @recovery_disabled: flag that state if recovery was disabled
> * @max_notifyid: largest allocated notify id.
> * @table_ptr: pointer to the resource table in effect
> + * @clean_table: copy of the resource table without modifications. Used
> + * when a remote processor is attached or detached from the core
> * @cached_table: copy of the resource table
> * @table_sz: size of @cached_table
> * @has_iommu: flag to indicate if remote processor is behind an MMU
> @@ -550,6 +552,7 @@ struct rproc {
> bool recovery_disabled;
> int max_notifyid;
> struct resource_table *table_ptr;
> + struct resource_table *clean_table;
> struct resource_table *cached_table;
> size_t table_sz;
> bool has_iommu;
> --
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 12/16] remoteproc: Properly deal with a kernel panic when attached
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 3a4692cc5220..0dc518a24104 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2684,7 +2684,11 @@ static int rproc_panic_handler(struct notifier_block *nb, unsigned long event,
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
- if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+ if (!rproc->ops->panic)
+ continue;
+
+ if (rproc->state != RPROC_RUNNING &&
+ rproc->state != RPROC_ATTACHED)
continue;
d = rproc->ops->panic(rproc);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 12/16] remoteproc: Properly deal with a kernel panic when attached
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_core.c | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 3a4692cc5220..0dc518a24104 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2684,7 +2684,11 @@ static int rproc_panic_handler(struct notifier_block *nb, unsigned long event,
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
- if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+ if (!rproc->ops->panic)
+ continue;
+
+ if (rproc->state != RPROC_RUNNING &&
+ rproc->state != RPROC_ATTACHED)
continue;
d = rproc->ops->panic(rproc);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 13/16] remoteproc: Properly deal with a start request when attached
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.
As with the case with the running state, the command can't be
carried out if the remote processor is already in operation.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_cdev.c | 3 ++-
drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
2 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..b2cee9afb41b 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
return -EFAULT;
if (!strncmp(cmd, "start", len)) {
- if (rproc->state == RPROC_RUNNING)
+ if (rproc->state == RPROC_RUNNING ||
+ rproc->state == RPROC_ATTACHED)
return -EBUSY;
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index f9694def9b54..66801e6fe5cd 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
if (sysfs_streq(buf, "start")) {
- if (rproc->state == RPROC_RUNNING)
+ if (rproc->state == RPROC_RUNNING ||
+ rproc->state == RPROC_ATTACHED)
return -EBUSY;
ret = rproc_boot(rproc);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 13/16] remoteproc: Properly deal with a start request when attached
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.
As with the case with the running state, the command can't be
carried out if the remote processor is already in operation.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
---
drivers/remoteproc/remoteproc_cdev.c | 3 ++-
drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
2 files changed, 4 insertions(+), 2 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..b2cee9afb41b 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
return -EFAULT;
if (!strncmp(cmd, "start", len)) {
- if (rproc->state == RPROC_RUNNING)
+ if (rproc->state == RPROC_RUNNING ||
+ rproc->state == RPROC_ATTACHED)
return -EBUSY;
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index f9694def9b54..66801e6fe5cd 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
if (sysfs_streq(buf, "start")) {
- if (rproc->state == RPROC_RUNNING)
+ if (rproc->state == RPROC_RUNNING ||
+ rproc->state == RPROC_ATTACHED)
return -EBUSY;
ret = rproc_boot(rproc);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread
* [PATCH v6 14/16] remoteproc: Properly deal with a stop request when attached
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Allow a remote processor that was started by another entity to be
switched off by the remoteproc core. For that to happen a
rproc::ops::stop() operation needs to be available.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Removed state check in rproc_shutdown() as it is already done in
in calling functions.
- rproc_shutdown() doesn't return an error code to keep legacy behevior.
- Removed Peng and Arnaud's RB tags because of the above.
---
drivers/remoteproc/remoteproc_cdev.c | 3 ++-
drivers/remoteproc/remoteproc_core.c | 4 ++++
drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
3 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index b2cee9afb41b..0249d8f6c3f8 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
- if (rproc->state != RPROC_RUNNING)
+ if (rproc->state != RPROC_RUNNING &&
+ rproc->state != RPROC_ATTACHED)
return -EINVAL;
rproc_shutdown(rproc);
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 0dc518a24104..00452da25fba 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1758,6 +1758,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
+ /* No need to continue if a stop() operation has not been provided */
+ if (!rproc->ops->stop)
+ return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 66801e6fe5cd..09eb700c5e7e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
- if (rproc->state != RPROC_RUNNING)
+ if (rproc->state != RPROC_RUNNING &&
+ rproc->state != RPROC_ATTACHED)
return -EINVAL;
rproc_shutdown(rproc);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 14/16] remoteproc: Properly deal with a stop request when attached
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Allow a remote processor that was started by another entity to be
switched off by the remoteproc core. For that to happen a
rproc::ops::stop() operation needs to be available.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- Removed state check in rproc_shutdown() as it is already done in
in calling functions.
- rproc_shutdown() doesn't return an error code to keep legacy behevior.
- Removed Peng and Arnaud's RB tags because of the above.
---
drivers/remoteproc/remoteproc_cdev.c | 3 ++-
drivers/remoteproc/remoteproc_core.c | 4 ++++
drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
3 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index b2cee9afb41b..0249d8f6c3f8 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
- if (rproc->state != RPROC_RUNNING)
+ if (rproc->state != RPROC_RUNNING &&
+ rproc->state != RPROC_ATTACHED)
return -EINVAL;
rproc_shutdown(rproc);
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 0dc518a24104..00452da25fba 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1758,6 +1758,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
+ /* No need to continue if a stop() operation has not been provided */
+ if (!rproc->ops->stop)
+ return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 66801e6fe5cd..09eb700c5e7e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
- if (rproc->state != RPROC_RUNNING)
+ if (rproc->state != RPROC_RUNNING &&
+ rproc->state != RPROC_ATTACHED)
return -EINVAL;
rproc_shutdown(rproc);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 14/16] remoteproc: Properly deal with a stop request when attached
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:21 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:21 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Allow a remote processor that was started by another entity to be
> switched off by the remoteproc core. For that to happen a
> rproc::ops::stop() operation needs to be available.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> New for V6:
> - Removed state check in rproc_shutdown() as it is already done in
> in calling functions.
> - rproc_shutdown() doesn't return an error code to keep legacy behevior.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
>
> drivers/remoteproc/remoteproc_cdev.c | 3 ++-
> drivers/remoteproc/remoteproc_core.c | 4 ++++
> drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
> 3 files changed, 8 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> index b2cee9afb41b..0249d8f6c3f8 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
>
> ret = rproc_boot(rproc);
> } else if (!strncmp(cmd, "stop", len)) {
> - if (rproc->state != RPROC_RUNNING)
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
> return -EINVAL;
>
> rproc_shutdown(rproc);
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 0dc518a24104..00452da25fba 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1758,6 +1758,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> struct device *dev = &rproc->dev;
> int ret;
>
> + /* No need to continue if a stop() operation has not been provided */
> + if (!rproc->ops->stop)
> + return -EINVAL;
> +
> /* Stop any subdevices for the remote processor */
> rproc_stop_subdevices(rproc, crashed);
>
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
> index 66801e6fe5cd..09eb700c5e7e 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
> if (ret)
> dev_err(&rproc->dev, "Boot failed: %d\n", ret);
> } else if (sysfs_streq(buf, "stop")) {
> - if (rproc->state != RPROC_RUNNING)
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
> return -EINVAL;
>
> rproc_shutdown(rproc);
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 14/16] remoteproc: Properly deal with a stop request when attached
@ 2021-02-26 16:21 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:21 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Allow a remote processor that was started by another entity to be
> switched off by the remoteproc core. For that to happen a
> rproc::ops::stop() operation needs to be available.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> New for V6:
> - Removed state check in rproc_shutdown() as it is already done in
> in calling functions.
> - rproc_shutdown() doesn't return an error code to keep legacy behevior.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
>
> drivers/remoteproc/remoteproc_cdev.c | 3 ++-
> drivers/remoteproc/remoteproc_core.c | 4 ++++
> drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
> 3 files changed, 8 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> index b2cee9afb41b..0249d8f6c3f8 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
>
> ret = rproc_boot(rproc);
> } else if (!strncmp(cmd, "stop", len)) {
> - if (rproc->state != RPROC_RUNNING)
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
> return -EINVAL;
>
> rproc_shutdown(rproc);
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 0dc518a24104..00452da25fba 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1758,6 +1758,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
> struct device *dev = &rproc->dev;
> int ret;
>
> + /* No need to continue if a stop() operation has not been provided */
> + if (!rproc->ops->stop)
> + return -EINVAL;
> +
> /* Stop any subdevices for the remote processor */
> rproc_stop_subdevices(rproc, crashed);
>
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
> index 66801e6fe5cd..09eb700c5e7e 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
> if (ret)
> dev_err(&rproc->dev, "Boot failed: %d\n", ret);
> } else if (sysfs_streq(buf, "stop")) {
> - if (rproc->state != RPROC_RUNNING)
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
> return -EINVAL;
>
> rproc_shutdown(rproc);
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 15/16] remoteproc: Properly deal with a detach request when attached
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
This patch introduces the capability to detach a remote processor
that has been attached by the remoteproc core. For that to happen
a rproc::ops::detach() operation needs to be available.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted
to avoid dealing with complex resource table management problems.
- Removed Peng and Arnaud's RB tags because of the above.
---
drivers/remoteproc/remoteproc_cdev.c | 5 +++++
drivers/remoteproc/remoteproc_sysfs.c | 5 +++++
2 files changed, 10 insertions(+)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index 0249d8f6c3f8..2db494816d5f 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
return -EINVAL;
rproc_shutdown(rproc);
+ } else if (!strncmp(cmd, "detach", len)) {
+ if (rproc->state != RPROC_ATTACHED)
+ return -EINVAL;
+
+ ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 09eb700c5e7e..ad3dd208024c 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
rproc_shutdown(rproc);
+ } else if (sysfs_streq(buf, "detach")) {
+ if (rproc->state != RPROC_ATTACHED)
+ return -EINVAL;
+
+ ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 15/16] remoteproc: Properly deal with a detach request when attached
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
This patch introduces the capability to detach a remote processor
that has been attached by the remoteproc core. For that to happen
a rproc::ops::detach() operation needs to be available.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted
to avoid dealing with complex resource table management problems.
- Removed Peng and Arnaud's RB tags because of the above.
---
drivers/remoteproc/remoteproc_cdev.c | 5 +++++
drivers/remoteproc/remoteproc_sysfs.c | 5 +++++
2 files changed, 10 insertions(+)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index 0249d8f6c3f8..2db494816d5f 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
return -EINVAL;
rproc_shutdown(rproc);
+ } else if (!strncmp(cmd, "detach", len)) {
+ if (rproc->state != RPROC_ATTACHED)
+ return -EINVAL;
+
+ ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
index 09eb700c5e7e..ad3dd208024c 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
rproc_shutdown(rproc);
+ } else if (sysfs_streq(buf, "detach")) {
+ if (rproc->state != RPROC_ATTACHED)
+ return -EINVAL;
+
+ ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 15/16] remoteproc: Properly deal with a detach request when attached
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:21 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:21 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> This patch introduces the capability to detach a remote processor
> that has been attached by the remoteproc core. For that to happen
> a rproc::ops::detach() operation needs to be available.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> New for V6:
> - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted
> to avoid dealing with complex resource table management problems.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
>
> drivers/remoteproc/remoteproc_cdev.c | 5 +++++
> drivers/remoteproc/remoteproc_sysfs.c | 5 +++++
> 2 files changed, 10 insertions(+)
>
> diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> index 0249d8f6c3f8..2db494816d5f 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
> return -EINVAL;
>
> rproc_shutdown(rproc);
> + } else if (!strncmp(cmd, "detach", len)) {
> + if (rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
> } else {
> dev_err(&rproc->dev, "Unrecognized option\n");
> ret = -EINVAL;
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
> index 09eb700c5e7e..ad3dd208024c 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
> return -EINVAL;
>
> rproc_shutdown(rproc);
> + } else if (sysfs_streq(buf, "detach")) {
> + if (rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
> } else {
> dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
> ret = -EINVAL;
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 15/16] remoteproc: Properly deal with a detach request when attached
@ 2021-02-26 16:21 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:21 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> This patch introduces the capability to detach a remote processor
> that has been attached by the remoteproc core. For that to happen
> a rproc::ops::detach() operation needs to be available.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Reviewed-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Thanks,
Arnaud
> ---
> New for V6:
> - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted
> to avoid dealing with complex resource table management problems.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
>
> drivers/remoteproc/remoteproc_cdev.c | 5 +++++
> drivers/remoteproc/remoteproc_sysfs.c | 5 +++++
> 2 files changed, 10 insertions(+)
>
> diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> index 0249d8f6c3f8..2db494816d5f 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const char __user *buf, size_
> return -EINVAL;
>
> rproc_shutdown(rproc);
> + } else if (!strncmp(cmd, "detach", len)) {
> + if (rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
> } else {
> dev_err(&rproc->dev, "Unrecognized option\n");
> ret = -EINVAL;
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c
> index 09eb700c5e7e..ad3dd208024c 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
> return -EINVAL;
>
> rproc_shutdown(rproc);
> + } else if (sysfs_streq(buf, "detach")) {
> + if (rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
> } else {
> dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
> ret = -EINVAL;
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* [PATCH v6 16/16] remoteproc: Refactor rproc delete and cdev release path
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-23 23:35 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Refactor function rproc_del() and rproc_cdev_release() to take
into account the current state of the remote processor when choosing
the state to transition to.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted.
to avoid dealing with complex resource table management problems.
- Transition to the next state is no longer dictated by a DT binding for
the same reason as above.
- Removed Peng and Arnaud's RB tags because of the above.
---
drivers/remoteproc/remoteproc_cdev.c | 10 ++++++++--
drivers/remoteproc/remoteproc_core.c | 9 +++++++--
2 files changed, 15 insertions(+), 4 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index 2db494816d5f..0b8a84c04f76 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -86,11 +86,17 @@ static long rproc_device_ioctl(struct file *filp, unsigned int ioctl, unsigned l
static int rproc_cdev_release(struct inode *inode, struct file *filp)
{
struct rproc *rproc = container_of(inode->i_cdev, struct rproc, cdev);
+ int ret = 0;
+
+ if (!rproc->cdev_put_on_release)
+ return 0;
- if (rproc->cdev_put_on_release && rproc->state == RPROC_RUNNING)
+ if (rproc->state == RPROC_RUNNING)
rproc_shutdown(rproc);
+ else if (rproc->state == RPROC_ATTACHED)
+ ret = rproc_detach(rproc);
- return 0;
+ return ret;
}
static const struct file_operations rproc_fops = {
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 00452da25fba..a05d5fec43b1 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2542,11 +2542,16 @@ EXPORT_SYMBOL(rproc_put);
*/
int rproc_del(struct rproc *rproc)
{
+ int ret = 0;
+
if (!rproc)
return -EINVAL;
/* TODO: make sure this works with rproc->power > 1 */
- rproc_shutdown(rproc);
+ if (rproc->state == RPROC_RUNNING)
+ rproc_shutdown(rproc);
+ else if (rproc->state == RPROC_ATTACHED)
+ ret = rproc_detach(rproc);
mutex_lock(&rproc->lock);
rproc->state = RPROC_DELETED;
@@ -2565,7 +2570,7 @@ int rproc_del(struct rproc *rproc)
device_del(&rproc->dev);
- return 0;
+ return ret;
}
EXPORT_SYMBOL(rproc_del);
--
2.25.1
^ permalink raw reply related [flat|nested] 60+ messages in thread* [PATCH v6 16/16] remoteproc: Refactor rproc delete and cdev release path
@ 2021-02-23 23:35 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-02-23 23:35 UTC (permalink / raw)
To: ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Refactor function rproc_del() and rproc_cdev_release() to take
into account the current state of the remote processor when choosing
the state to transition to.
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
---
New for V6:
- The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted.
to avoid dealing with complex resource table management problems.
- Transition to the next state is no longer dictated by a DT binding for
the same reason as above.
- Removed Peng and Arnaud's RB tags because of the above.
---
drivers/remoteproc/remoteproc_cdev.c | 10 ++++++++--
drivers/remoteproc/remoteproc_core.c | 9 +++++++--
2 files changed, 15 insertions(+), 4 deletions(-)
diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
index 2db494816d5f..0b8a84c04f76 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -86,11 +86,17 @@ static long rproc_device_ioctl(struct file *filp, unsigned int ioctl, unsigned l
static int rproc_cdev_release(struct inode *inode, struct file *filp)
{
struct rproc *rproc = container_of(inode->i_cdev, struct rproc, cdev);
+ int ret = 0;
+
+ if (!rproc->cdev_put_on_release)
+ return 0;
- if (rproc->cdev_put_on_release && rproc->state == RPROC_RUNNING)
+ if (rproc->state == RPROC_RUNNING)
rproc_shutdown(rproc);
+ else if (rproc->state == RPROC_ATTACHED)
+ ret = rproc_detach(rproc);
- return 0;
+ return ret;
}
static const struct file_operations rproc_fops = {
diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index 00452da25fba..a05d5fec43b1 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2542,11 +2542,16 @@ EXPORT_SYMBOL(rproc_put);
*/
int rproc_del(struct rproc *rproc)
{
+ int ret = 0;
+
if (!rproc)
return -EINVAL;
/* TODO: make sure this works with rproc->power > 1 */
- rproc_shutdown(rproc);
+ if (rproc->state == RPROC_RUNNING)
+ rproc_shutdown(rproc);
+ else if (rproc->state == RPROC_ATTACHED)
+ ret = rproc_detach(rproc);
mutex_lock(&rproc->lock);
rproc->state = RPROC_DELETED;
@@ -2565,7 +2570,7 @@ int rproc_del(struct rproc *rproc)
device_del(&rproc->dev);
- return 0;
+ return ret;
}
EXPORT_SYMBOL(rproc_del);
--
2.25.1
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 60+ messages in thread* Re: [PATCH v6 16/16] remoteproc: Refactor rproc delete and cdev release path
2021-02-23 23:35 ` Mathieu Poirier
@ 2021-02-26 16:23 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:23 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Refactor function rproc_del() and rproc_cdev_release() to take
> into account the current state of the remote processor when choosing
> the state to transition to.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> ---
> New for V6:
> - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted.
> to avoid dealing with complex resource table management problems.
> - Transition to the next state is no longer dictated by a DT binding for
> the same reason as above.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
>
> drivers/remoteproc/remoteproc_cdev.c | 10 ++++++++--
> drivers/remoteproc/remoteproc_core.c | 9 +++++++--
> 2 files changed, 15 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> index 2db494816d5f..0b8a84c04f76 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -86,11 +86,17 @@ static long rproc_device_ioctl(struct file *filp, unsigned int ioctl, unsigned l
> static int rproc_cdev_release(struct inode *inode, struct file *filp)
> {
> struct rproc *rproc = container_of(inode->i_cdev, struct rproc, cdev);
> + int ret = 0;
> +
> + if (!rproc->cdev_put_on_release)
> + return 0;
>
> - if (rproc->cdev_put_on_release && rproc->state == RPROC_RUNNING)
> + if (rproc->state == RPROC_RUNNING)
> rproc_shutdown(rproc);
> + else if (rproc->state == RPROC_ATTACHED)
> + ret = rproc_detach(rproc);
>
> - return 0;
> + return ret;
> }
>
> static const struct file_operations rproc_fops = {
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 00452da25fba..a05d5fec43b1 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -2542,11 +2542,16 @@ EXPORT_SYMBOL(rproc_put);
> */
> int rproc_del(struct rproc *rproc)
> {
> + int ret = 0;
> +
> if (!rproc)
> return -EINVAL;
>
> /* TODO: make sure this works with rproc->power > 1 */
> - rproc_shutdown(rproc);
> + if (rproc->state == RPROC_RUNNING)
> + rproc_shutdown(rproc);
> + else if (rproc->state == RPROC_ATTACHED)
> + ret = rproc_detach(rproc);
Here i would not update the code to not change the existing behavior of an
attached firmware.
The decision between a detach or a shutdown probably depends on platform.
We could (as a next step) reintroduce the "autonomous-on-core-reboot" DT
property for the decision.
Regards
Arnaud
>
> mutex_lock(&rproc->lock);
> rproc->state = RPROC_DELETED;
> @@ -2565,7 +2570,7 @@ int rproc_del(struct rproc *rproc)
>
> device_del(&rproc->dev);
>
> - return 0;
> + return ret;
> }
> EXPORT_SYMBOL(rproc_del);
>
>
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 16/16] remoteproc: Refactor rproc delete and cdev release path
@ 2021-02-26 16:23 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:23 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Refactor function rproc_del() and rproc_cdev_release() to take
> into account the current state of the remote processor when choosing
> the state to transition to.
>
> Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> ---
> New for V6:
> - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted.
> to avoid dealing with complex resource table management problems.
> - Transition to the next state is no longer dictated by a DT binding for
> the same reason as above.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
>
> drivers/remoteproc/remoteproc_cdev.c | 10 ++++++++--
> drivers/remoteproc/remoteproc_core.c | 9 +++++++--
> 2 files changed, 15 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> index 2db494816d5f..0b8a84c04f76 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -86,11 +86,17 @@ static long rproc_device_ioctl(struct file *filp, unsigned int ioctl, unsigned l
> static int rproc_cdev_release(struct inode *inode, struct file *filp)
> {
> struct rproc *rproc = container_of(inode->i_cdev, struct rproc, cdev);
> + int ret = 0;
> +
> + if (!rproc->cdev_put_on_release)
> + return 0;
>
> - if (rproc->cdev_put_on_release && rproc->state == RPROC_RUNNING)
> + if (rproc->state == RPROC_RUNNING)
> rproc_shutdown(rproc);
> + else if (rproc->state == RPROC_ATTACHED)
> + ret = rproc_detach(rproc);
>
> - return 0;
> + return ret;
> }
>
> static const struct file_operations rproc_fops = {
> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> index 00452da25fba..a05d5fec43b1 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -2542,11 +2542,16 @@ EXPORT_SYMBOL(rproc_put);
> */
> int rproc_del(struct rproc *rproc)
> {
> + int ret = 0;
> +
> if (!rproc)
> return -EINVAL;
>
> /* TODO: make sure this works with rproc->power > 1 */
> - rproc_shutdown(rproc);
> + if (rproc->state == RPROC_RUNNING)
> + rproc_shutdown(rproc);
> + else if (rproc->state == RPROC_ATTACHED)
> + ret = rproc_detach(rproc);
Here i would not update the code to not change the existing behavior of an
attached firmware.
The decision between a detach or a shutdown probably depends on platform.
We could (as a next step) reintroduce the "autonomous-on-core-reboot" DT
property for the decision.
Regards
Arnaud
>
> mutex_lock(&rproc->lock);
> rproc->state = RPROC_DELETED;
> @@ -2565,7 +2570,7 @@ int rproc_del(struct rproc *rproc)
>
> device_del(&rproc->dev);
>
> - return 0;
> + return ret;
> }
> EXPORT_SYMBOL(rproc_del);
>
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 16/16] remoteproc: Refactor rproc delete and cdev release path
2021-02-26 16:23 ` Arnaud POULIQUEN
@ 2021-03-01 18:58 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:58 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, bjorn.andersson, arnaud.pouliquen, mcoquelin.stm32,
alexandre.torgue, linux-remoteproc, linux-kernel,
linux-arm-kernel
On Fri, Feb 26, 2021 at 05:23:45PM +0100, Arnaud POULIQUEN wrote:
>
>
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > Refactor function rproc_del() and rproc_cdev_release() to take
> > into account the current state of the remote processor when choosing
> > the state to transition to.
> >
> > Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> > ---
> > New for V6:
> > - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted.
> > to avoid dealing with complex resource table management problems.
> > - Transition to the next state is no longer dictated by a DT binding for
> > the same reason as above.
> > - Removed Peng and Arnaud's RB tags because of the above.
> > ---
> >
> > drivers/remoteproc/remoteproc_cdev.c | 10 ++++++++--
> > drivers/remoteproc/remoteproc_core.c | 9 +++++++--
> > 2 files changed, 15 insertions(+), 4 deletions(-)
> >
> > diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> > index 2db494816d5f..0b8a84c04f76 100644
> > --- a/drivers/remoteproc/remoteproc_cdev.c
> > +++ b/drivers/remoteproc/remoteproc_cdev.c
> > @@ -86,11 +86,17 @@ static long rproc_device_ioctl(struct file *filp, unsigned int ioctl, unsigned l
> > static int rproc_cdev_release(struct inode *inode, struct file *filp)
> > {
> > struct rproc *rproc = container_of(inode->i_cdev, struct rproc, cdev);
> > + int ret = 0;
> > +
> > + if (!rproc->cdev_put_on_release)
> > + return 0;
> >
> > - if (rproc->cdev_put_on_release && rproc->state == RPROC_RUNNING)
> > + if (rproc->state == RPROC_RUNNING)
> > rproc_shutdown(rproc);
> > + else if (rproc->state == RPROC_ATTACHED)
> > + ret = rproc_detach(rproc);
> >
> > - return 0;
> > + return ret;
> > }
> >
> > static const struct file_operations rproc_fops = {
> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> > index 00452da25fba..a05d5fec43b1 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -2542,11 +2542,16 @@ EXPORT_SYMBOL(rproc_put);
> > */
> > int rproc_del(struct rproc *rproc)
> > {
> > + int ret = 0;
> > +
> > if (!rproc)
> > return -EINVAL;
> >
> > /* TODO: make sure this works with rproc->power > 1 */
> > - rproc_shutdown(rproc);
> > + if (rproc->state == RPROC_RUNNING)
> > + rproc_shutdown(rproc);
> > + else if (rproc->state == RPROC_ATTACHED)
> > + ret = rproc_detach(rproc);
>
> Here i would not update the code to not change the existing behavior of an
> attached firmware.
Upon reflection your assessment is correct. This is an unintended
consequence of separating the attach and detach funtionality in two patchset.
Fortunately it is easily fixed by calling rproc_detach() before rproc_del() in
the platform driver, or using the DT.
That being said we can't do much for rproc_cdev_release(), otherwise systems
that only support attach/detach functionality would be broken.
> The decision between a detach or a shutdown probably depends on platform.
> We could (as a next step) reintroduce the "autonomous-on-core-reboot" DT
> property for the decision.
>
> Regards
> Arnaud
>
> >
> > mutex_lock(&rproc->lock);
> > rproc->state = RPROC_DELETED;
> > @@ -2565,7 +2570,7 @@ int rproc_del(struct rproc *rproc)
> >
> > device_del(&rproc->dev);
> >
> > - return 0;
> > + return ret;
> > }
> > EXPORT_SYMBOL(rproc_del);
> >
> >
^ permalink raw reply [flat|nested] 60+ messages in thread* Re: [PATCH v6 16/16] remoteproc: Refactor rproc delete and cdev release path
@ 2021-03-01 18:58 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:58 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, alexandre.torgue, arnaud.pouliquen, linux-remoteproc,
linux-kernel, bjorn.andersson, mcoquelin.stm32, linux-arm-kernel
On Fri, Feb 26, 2021 at 05:23:45PM +0100, Arnaud POULIQUEN wrote:
>
>
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > Refactor function rproc_del() and rproc_cdev_release() to take
> > into account the current state of the remote processor when choosing
> > the state to transition to.
> >
> > Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
> > ---
> > New for V6:
> > - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted.
> > to avoid dealing with complex resource table management problems.
> > - Transition to the next state is no longer dictated by a DT binding for
> > the same reason as above.
> > - Removed Peng and Arnaud's RB tags because of the above.
> > ---
> >
> > drivers/remoteproc/remoteproc_cdev.c | 10 ++++++++--
> > drivers/remoteproc/remoteproc_core.c | 9 +++++++--
> > 2 files changed, 15 insertions(+), 4 deletions(-)
> >
> > diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c
> > index 2db494816d5f..0b8a84c04f76 100644
> > --- a/drivers/remoteproc/remoteproc_cdev.c
> > +++ b/drivers/remoteproc/remoteproc_cdev.c
> > @@ -86,11 +86,17 @@ static long rproc_device_ioctl(struct file *filp, unsigned int ioctl, unsigned l
> > static int rproc_cdev_release(struct inode *inode, struct file *filp)
> > {
> > struct rproc *rproc = container_of(inode->i_cdev, struct rproc, cdev);
> > + int ret = 0;
> > +
> > + if (!rproc->cdev_put_on_release)
> > + return 0;
> >
> > - if (rproc->cdev_put_on_release && rproc->state == RPROC_RUNNING)
> > + if (rproc->state == RPROC_RUNNING)
> > rproc_shutdown(rproc);
> > + else if (rproc->state == RPROC_ATTACHED)
> > + ret = rproc_detach(rproc);
> >
> > - return 0;
> > + return ret;
> > }
> >
> > static const struct file_operations rproc_fops = {
> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
> > index 00452da25fba..a05d5fec43b1 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -2542,11 +2542,16 @@ EXPORT_SYMBOL(rproc_put);
> > */
> > int rproc_del(struct rproc *rproc)
> > {
> > + int ret = 0;
> > +
> > if (!rproc)
> > return -EINVAL;
> >
> > /* TODO: make sure this works with rproc->power > 1 */
> > - rproc_shutdown(rproc);
> > + if (rproc->state == RPROC_RUNNING)
> > + rproc_shutdown(rproc);
> > + else if (rproc->state == RPROC_ATTACHED)
> > + ret = rproc_detach(rproc);
>
> Here i would not update the code to not change the existing behavior of an
> attached firmware.
Upon reflection your assessment is correct. This is an unintended
consequence of separating the attach and detach funtionality in two patchset.
Fortunately it is easily fixed by calling rproc_detach() before rproc_del() in
the platform driver, or using the DT.
That being said we can't do much for rproc_cdev_release(), otherwise systems
that only support attach/detach functionality would be broken.
> The decision between a detach or a shutdown probably depends on platform.
> We could (as a next step) reintroduce the "autonomous-on-core-reboot" DT
> property for the decision.
>
> Regards
> Arnaud
>
> >
> > mutex_lock(&rproc->lock);
> > rproc->state = RPROC_DELETED;
> > @@ -2565,7 +2570,7 @@ int rproc_del(struct rproc *rproc)
> >
> > device_del(&rproc->dev);
> >
> > - return 0;
> > + return ret;
> > }
> > EXPORT_SYMBOL(rproc_del);
> >
> >
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* Re: [PATCH v6 00/16] remoteproc: Add support for detaching a remote processor
2021-02-23 23:34 ` Mathieu Poirier
@ 2021-02-26 16:40 ` Arnaud POULIQUEN
-1 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:40 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: mcoquelin.stm32, alexandre.torgue, linux-remoteproc,
linux-kernel, linux-arm-kernel
Hi Mathieu,
On 2/24/21 12:34 AM, Mathieu Poirier wrote:
> Following the work done here [1], this set provides support for the
> remoteproc core to release resources associated with a remote processor
> without having to switch it off. That way a platform driver can be removed
> or the application processor power cycled while the remote processor is
> still operating.
>
> Modifications for this revision are detailed in the changelog of each patch
> but the main difference is that going from RPROC_RUNNING -> RPROC_DETACHED
> is no longer supported to avoid dealing tricky resource table issues.
This seems reasonable to me. If necessary, this could be part of a separate series.
From test point of view, it is working pretty well on my side.
Thanks,
Arnaud
>
> Applies cleanly on rproc-next (e8b4e9a21af7). I will rebase on 5.12-rc1 when it
> comes out next week.
>
> Thanks,
> Mathieu
>
> Arnaud POULIQUEN (1):
> remoteproc: stm32: Move memory parsing to rproc_ops
>
> Mathieu Poirier (15):
> remoteproc: Remove useless check in rproc_del()
> remoteproc: Rename function rproc_actuate()
> remoteproc: Add new RPROC_ATTACHED state
> remoteproc: Properly represent the attached state
> remoteproc: Add new get_loaded_rsc_table() to rproc_ops
> remoteproc: stm32: Move resource table setup to rproc_ops
> remoteproc: Add new detach() remoteproc operation
> remoteproc: Introduce function __rproc_detach()
> remoteproc: Introduce function rproc_detach()
> remoteproc: Properly deal with the resource table when attached
> remoteproc: Properly deal with a kernel panic when attached
> remoteproc: Properly deal with a start request when attached
> remoteproc: Properly deal with a stop request when attached
> remoteproc: Properly deal with a detach request when attached
> remoteproc: Refactor rproc delete and cdev release path
>
> drivers/remoteproc/remoteproc_cdev.c | 21 +-
> drivers/remoteproc/remoteproc_core.c | 263 ++++++++++++++++++++---
> drivers/remoteproc/remoteproc_internal.h | 10 +
> drivers/remoteproc/remoteproc_sysfs.c | 17 +-
> drivers/remoteproc/stm32_rproc.c | 168 +++++++--------
> include/linux/remoteproc.h | 21 +-
> 6 files changed, 362 insertions(+), 138 deletions(-)
>
^ permalink raw reply [flat|nested] 60+ messages in thread
* Re: [PATCH v6 00/16] remoteproc: Add support for detaching a remote processor
@ 2021-02-26 16:40 ` Arnaud POULIQUEN
0 siblings, 0 replies; 60+ messages in thread
From: Arnaud POULIQUEN @ 2021-02-26 16:40 UTC (permalink / raw)
To: Mathieu Poirier, ohad, bjorn.andersson, arnaud.pouliquen
Cc: linux-arm-kernel, linux-remoteproc, alexandre.torgue,
mcoquelin.stm32, linux-kernel
Hi Mathieu,
On 2/24/21 12:34 AM, Mathieu Poirier wrote:
> Following the work done here [1], this set provides support for the
> remoteproc core to release resources associated with a remote processor
> without having to switch it off. That way a platform driver can be removed
> or the application processor power cycled while the remote processor is
> still operating.
>
> Modifications for this revision are detailed in the changelog of each patch
> but the main difference is that going from RPROC_RUNNING -> RPROC_DETACHED
> is no longer supported to avoid dealing tricky resource table issues.
This seems reasonable to me. If necessary, this could be part of a separate series.
From test point of view, it is working pretty well on my side.
Thanks,
Arnaud
>
> Applies cleanly on rproc-next (e8b4e9a21af7). I will rebase on 5.12-rc1 when it
> comes out next week.
>
> Thanks,
> Mathieu
>
> Arnaud POULIQUEN (1):
> remoteproc: stm32: Move memory parsing to rproc_ops
>
> Mathieu Poirier (15):
> remoteproc: Remove useless check in rproc_del()
> remoteproc: Rename function rproc_actuate()
> remoteproc: Add new RPROC_ATTACHED state
> remoteproc: Properly represent the attached state
> remoteproc: Add new get_loaded_rsc_table() to rproc_ops
> remoteproc: stm32: Move resource table setup to rproc_ops
> remoteproc: Add new detach() remoteproc operation
> remoteproc: Introduce function __rproc_detach()
> remoteproc: Introduce function rproc_detach()
> remoteproc: Properly deal with the resource table when attached
> remoteproc: Properly deal with a kernel panic when attached
> remoteproc: Properly deal with a start request when attached
> remoteproc: Properly deal with a stop request when attached
> remoteproc: Properly deal with a detach request when attached
> remoteproc: Refactor rproc delete and cdev release path
>
> drivers/remoteproc/remoteproc_cdev.c | 21 +-
> drivers/remoteproc/remoteproc_core.c | 263 ++++++++++++++++++++---
> drivers/remoteproc/remoteproc_internal.h | 10 +
> drivers/remoteproc/remoteproc_sysfs.c | 17 +-
> drivers/remoteproc/stm32_rproc.c | 168 +++++++--------
> include/linux/remoteproc.h | 21 +-
> 6 files changed, 362 insertions(+), 138 deletions(-)
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread
* Re: [PATCH v6 00/16] remoteproc: Add support for detaching a remote processor
2021-02-26 16:40 ` Arnaud POULIQUEN
@ 2021-03-01 18:58 ` Mathieu Poirier
-1 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:58 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, bjorn.andersson, arnaud.pouliquen, mcoquelin.stm32,
alexandre.torgue, linux-remoteproc, linux-kernel,
linux-arm-kernel
On Fri, Feb 26, 2021 at 05:40:49PM +0100, Arnaud POULIQUEN wrote:
> Hi Mathieu,
>
> On 2/24/21 12:34 AM, Mathieu Poirier wrote:
> > Following the work done here [1], this set provides support for the
> > remoteproc core to release resources associated with a remote processor
> > without having to switch it off. That way a platform driver can be removed
> > or the application processor power cycled while the remote processor is
> > still operating.
> >
> > Modifications for this revision are detailed in the changelog of each patch
> > but the main difference is that going from RPROC_RUNNING -> RPROC_DETACHED
> > is no longer supported to avoid dealing tricky resource table issues.
>
> This seems reasonable to me. If necessary, this could be part of a separate series.
>
> From test point of view, it is working pretty well on my side.
Thanks for taking a look a this.
Mathieu
>
> Thanks,
> Arnaud
>
> >
> > Applies cleanly on rproc-next (e8b4e9a21af7). I will rebase on 5.12-rc1 when it
> > comes out next week.
> >
> > Thanks,
> > Mathieu
> >
> > Arnaud POULIQUEN (1):
> > remoteproc: stm32: Move memory parsing to rproc_ops
> >
> > Mathieu Poirier (15):
> > remoteproc: Remove useless check in rproc_del()
> > remoteproc: Rename function rproc_actuate()
> > remoteproc: Add new RPROC_ATTACHED state
> > remoteproc: Properly represent the attached state
> > remoteproc: Add new get_loaded_rsc_table() to rproc_ops
> > remoteproc: stm32: Move resource table setup to rproc_ops
> > remoteproc: Add new detach() remoteproc operation
> > remoteproc: Introduce function __rproc_detach()
> > remoteproc: Introduce function rproc_detach()
> > remoteproc: Properly deal with the resource table when attached
> > remoteproc: Properly deal with a kernel panic when attached
> > remoteproc: Properly deal with a start request when attached
> > remoteproc: Properly deal with a stop request when attached
> > remoteproc: Properly deal with a detach request when attached
> > remoteproc: Refactor rproc delete and cdev release path
> >
> > drivers/remoteproc/remoteproc_cdev.c | 21 +-
> > drivers/remoteproc/remoteproc_core.c | 263 ++++++++++++++++++++---
> > drivers/remoteproc/remoteproc_internal.h | 10 +
> > drivers/remoteproc/remoteproc_sysfs.c | 17 +-
> > drivers/remoteproc/stm32_rproc.c | 168 +++++++--------
> > include/linux/remoteproc.h | 21 +-
> > 6 files changed, 362 insertions(+), 138 deletions(-)
> >
^ permalink raw reply [flat|nested] 60+ messages in thread
* Re: [PATCH v6 00/16] remoteproc: Add support for detaching a remote processor
@ 2021-03-01 18:58 ` Mathieu Poirier
0 siblings, 0 replies; 60+ messages in thread
From: Mathieu Poirier @ 2021-03-01 18:58 UTC (permalink / raw)
To: Arnaud POULIQUEN
Cc: ohad, alexandre.torgue, arnaud.pouliquen, linux-remoteproc,
linux-kernel, bjorn.andersson, mcoquelin.stm32, linux-arm-kernel
On Fri, Feb 26, 2021 at 05:40:49PM +0100, Arnaud POULIQUEN wrote:
> Hi Mathieu,
>
> On 2/24/21 12:34 AM, Mathieu Poirier wrote:
> > Following the work done here [1], this set provides support for the
> > remoteproc core to release resources associated with a remote processor
> > without having to switch it off. That way a platform driver can be removed
> > or the application processor power cycled while the remote processor is
> > still operating.
> >
> > Modifications for this revision are detailed in the changelog of each patch
> > but the main difference is that going from RPROC_RUNNING -> RPROC_DETACHED
> > is no longer supported to avoid dealing tricky resource table issues.
>
> This seems reasonable to me. If necessary, this could be part of a separate series.
>
> From test point of view, it is working pretty well on my side.
Thanks for taking a look a this.
Mathieu
>
> Thanks,
> Arnaud
>
> >
> > Applies cleanly on rproc-next (e8b4e9a21af7). I will rebase on 5.12-rc1 when it
> > comes out next week.
> >
> > Thanks,
> > Mathieu
> >
> > Arnaud POULIQUEN (1):
> > remoteproc: stm32: Move memory parsing to rproc_ops
> >
> > Mathieu Poirier (15):
> > remoteproc: Remove useless check in rproc_del()
> > remoteproc: Rename function rproc_actuate()
> > remoteproc: Add new RPROC_ATTACHED state
> > remoteproc: Properly represent the attached state
> > remoteproc: Add new get_loaded_rsc_table() to rproc_ops
> > remoteproc: stm32: Move resource table setup to rproc_ops
> > remoteproc: Add new detach() remoteproc operation
> > remoteproc: Introduce function __rproc_detach()
> > remoteproc: Introduce function rproc_detach()
> > remoteproc: Properly deal with the resource table when attached
> > remoteproc: Properly deal with a kernel panic when attached
> > remoteproc: Properly deal with a start request when attached
> > remoteproc: Properly deal with a stop request when attached
> > remoteproc: Properly deal with a detach request when attached
> > remoteproc: Refactor rproc delete and cdev release path
> >
> > drivers/remoteproc/remoteproc_cdev.c | 21 +-
> > drivers/remoteproc/remoteproc_core.c | 263 ++++++++++++++++++++---
> > drivers/remoteproc/remoteproc_internal.h | 10 +
> > drivers/remoteproc/remoteproc_sysfs.c | 17 +-
> > drivers/remoteproc/stm32_rproc.c | 168 +++++++--------
> > include/linux/remoteproc.h | 21 +-
> > 6 files changed, 362 insertions(+), 138 deletions(-)
> >
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 60+ messages in thread