Skip to contentSkip to conversation

remoteproc: add support for co-processor booted before kernel

PATCH Superseded Loic Pallardy 2 participants 5 messages Nov 4, 2019 – Nov 13, 2019 Remote processor (remoteproc)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 remoteproc: add support for co-processor booted before kernel

Remote processor could boot independently or be started before Linux kernel by bootloader or any firmware.
This patch introduces a new property in rproc core, named preloaded, to be able to allocate resources and sub-devices like vdev and to synchronize with current state without loading firmware from file system. It is platform driver responsibility to implement the right firmware load ops according to HW specificities.

---
Change from v1:
- Keep bool in struct rproc

---
 drivers/remoteproc/remoteproc_core.c | 37 +++++++++++++++++++++++++++---------
 include/linux/remoteproc.h           |  2 ++
 2 files changed, 30 insertions(+), 9 deletions(-)
drivers/remoteproc/remoteproc_core.c +28 -9
index 3c5fbbbfb0f1..7eaf0f949afa 100644
@@ -1372,7 +1372,11 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
 	if (ret)
 		return ret;
 
-	dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
+	if (fw)
+		dev_info(dev, "Booting fw image %s, size %zd\n", name,
+			 fw->size);
+	else
+		dev_info(dev, "Synchronizing with preloaded co-processor\n");
 
 	/*
 	 * if enabling an IOMMU isn't relevant for this rproc, this is
@@ -1728,7 +1732,7 @@ static void rproc_crash_handler_work(struct work_struct *work)
  */
 int rproc_boot(struct rproc *rproc)
 {
-	const struct firmware *firmware_p;
+	const struct firmware *firmware_p = NULL;
 	struct device *dev;
 	int ret;
 
@@ -1759,11 +1763,17 @@ int rproc_boot(struct rproc *rproc)
 
 	dev_info(dev, "powering up %s\n", rproc->name);
 
-	/* load firmware */
-	ret = request_firmware(&firmware_p, rproc->firmware, dev);
-	if (ret < 0) {
-		dev_err(dev, "request_firmware failed: %d\n", ret);
-		goto downref_rproc;
+	if (!rproc->preloaded) {
+		/* load firmware */
+		ret = request_firmware(&firmware_p, rproc->firmware, dev);
+		if (ret < 0) {
+			dev_err(dev, "request_firmware failed: %d\n", ret);
+			goto downref_rproc;
+		}
+	} else {
+		/* set firmware name to null as unknown */
+		kfree(rproc->firmware);
+		rproc->firmware = NULL;
 	}
 
 	ret = rproc_fw_boot(rproc, firmware_p);
@@ -1917,8 +1927,17 @@ int rproc_add(struct rproc *rproc)
 	/* create debugfs entries */
 	rproc_create_debug_dir(rproc);
 
-	/* if rproc is marked always-on, request it to boot */
-	if (rproc->auto_boot) {
+	if (rproc->preloaded) {
+		/*
+		 * If rproc is marked already booted, no need to wait
+		 * for firmware.
+		 * Just handle associated resources and start sub devices
+		 */
+		ret = rproc_boot(rproc);
+		if (ret < 0)
+			return ret;
+	} else if (rproc->auto_boot) {
+		/* if rproc is marked always-on, request it to boot */
 		ret = rproc_trigger_auto_boot(rproc);
 		if (ret < 0)
 			return ret;
include/linux/remoteproc.h +2 -0
index 16ad66683ad0..b68fbd576a77 100644
@@ -479,6 +479,7 @@ 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
+ * @preloaded: remote processor has been preloaded before start sequence
  * @dump_segments: list of segments in the firmware
  * @nb_vdev: number of vdev currently handled by rproc
  */
@@ -512,6 +513,7 @@ struct rproc {
 	size_t table_sz;
 	bool has_iommu;
 	bool auto_boot;
+	bool preloaded;
 	struct list_head dump_segments;
 	int nb_vdev;
 };
Signature · 1 line
2.7.4
#1 lore raw
Quoted 8 lines · Loic Pallardy

Remote processor could boot independently or be started before Linux kernel by bootloader or any firmware.
This patch introduces a new property in rproc core, named preloaded, to be able to allocate resources and sub-devices like vdev and to synchronize with current state without loading firmware from file system. It is platform driver responsibility to implement the right firmware load ops according to HW specificities.

Is it just preloaded or already started?

Quoted 46 lines

---
Change from v1:
- Keep bool in struct rproc

---
 drivers/remoteproc/remoteproc_core.c | 37 +++++++++++++++++++++++++++---------
 include/linux/remoteproc.h           |  2 ++
 2 files changed, 30 insertions(+), 9 deletions(-)
drivers/remoteproc/remoteproc_core.c +7 -7
index 3c5fbbbfb0f1..7eaf0f949afa 100644
@@ -1372,7 +1372,11 @@ static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)
 	if (ret)
 		return ret;
 
-	dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
+	if (fw)
+		dev_info(dev, "Booting fw image %s, size %zd\n", name,
+			 fw->size);
+	else
+		dev_info(dev, "Synchronizing with preloaded co-processor\n");
 
 	/*
 	 * if enabling an IOMMU isn't relevant for this rproc, this is
@@ -1728,7 +1732,7 @@ static void rproc_crash_handler_work(struct work_struct *work)
  */
 int rproc_boot(struct rproc *rproc)
 {
-	const struct firmware *firmware_p;
+	const struct firmware *firmware_p = NULL;
 	struct device *dev;
 	int ret;
 
@@ -1759,11 +1763,17 @@ int rproc_boot(struct rproc *rproc)
 
 	dev_info(dev, "powering up %s\n", rproc->name);
 
-	/* load firmware */
-	ret = request_firmware(&firmware_p, rproc->firmware, dev);
-	if (ret < 0) {
-		dev_err(dev, "request_firmware failed: %d\n", ret);
-		goto downref_rproc;
+	if (!rproc->preloaded) {

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1776

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +10 -0
+		/* load firmware */
+		ret = request_firmware(&firmware_p, rproc->firmware, dev);
+		if (ret < 0) {
+			dev_err(dev, "request_firmware failed: %d\n", ret);
+			goto downref_rproc;
+		}
+	} else {
+		/* set firmware name to null as unknown */
+		kfree(rproc->firmware);
+		rproc->firmware = NULL;

What happens when the remoteproc crashes? What happens if I stop it and try to start it again?

Quoted 6 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	}
 
 	ret = rproc_fw_boot(rproc, firmware_p);
@@ -1917,8 +1927,17 @@ int rproc_add(struct rproc *rproc)
 	/* create debugfs entries */
 	rproc_create_debug_dir(rproc);

drivers/remoteproc/remoteproc_core.c int rproc_add(struct rproc *rproc) · line 1936

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +7 -2
 
-	/* if rproc is marked always-on, request it to boot */
-	if (rproc->auto_boot) {
+	if (rproc->preloaded) {
+		/*
+		 * If rproc is marked already booted, no need to wait
+		 * for firmware.
+		 * Just handle associated resources and start sub devices
+		 */
+		ret = rproc_boot(rproc);

This will trickle down to your remoteproc driver's start() callback. If you really mean that "preloaded" means "already started", then I presume you're having some logic in your start() to turn it into a nop?

Quoted 12 lines
drivers/remoteproc/remoteproc_core.c +4 -0
+		if (ret < 0)
+			return ret;
+	} else if (rproc->auto_boot) {
+		/* if rproc is marked always-on, request it to boot */
 		ret = rproc_trigger_auto_boot(rproc);
 		if (ret < 0)
 			return ret;
include/linux/remoteproc.h +0 -0
index 16ad66683ad0..b68fbd576a77 100644

include/linux/remoteproc.h struct rproc_dump_segment { · line 482

Quoted 4 lines
include/linux/remoteproc.h +1 -0
@@ -479,6 +479,7 @@ 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
+ * @preloaded: remote processor has been preloaded before start sequence

I think this should be "skip_firmware_load", or if you really mean that the bootloader started the remote process perhaps this should be "@fw_booted: remote processor was booted by firmware" (or something similar).

Regards,
Bjorn

Quoted 14 lines
include/linux/remoteproc.h +1 -0
  * @dump_segments: list of segments in the firmware
  * @nb_vdev: number of vdev currently handled by rproc
  */
@@ -512,6 +513,7 @@ struct rproc {
 	size_t table_sz;
 	bool has_iommu;
 	bool auto_boot;
+	bool preloaded;
 	struct list_head dump_segments;
 	int nb_vdev;
 };
Signature · 1 line
2.7.4
#2 lore raw

Hi Bjorn,

Thanks for your review.

Quoted 22 lines

-----Original Message-----
From: Bjorn Andersson <[email protected]>
Sent: samedi 9 novembre 2019 02:20
To: Loic PALLARDY <[email protected]>
Cc: [email protected]; [email protected]; linux- [email protected]; Arnaud POULIQUEN <[email protected]>; [email protected]; Fabien DESSENNE <[email protected]>; [email protected]
Subject: Re: [PATCH v2 1/1] remoteproc: add support for co-processor booted before kernel

Quoted 8 lines · Loic Pallardy

Remote processor could boot independently or be started before Linux kernel by bootloader or any firmware.
This patch introduces a new property in rproc core, named preloaded, to be able to allocate resources and sub-devices like vdev and to synchronize with current state without loading firmware from file system. It is platform driver responsibility to implement the right firmware load ops according to HW specificities.

Quoted 1 line

Is it just preloaded or already started?

At the beginning, this properties was indeed to support an already started coprocessor, but discussing with Suman few months ago, we detected some cases for which firmware may be loaded before kernel start (firmware located in embedded flash or loaded by bootloaders) or may be loaded by a dedicated driver interface before rproc framework be called. As rproc framework is mainly responsible for firmware loading and resource allocation, I named this property preloaded to cover as much as possible all cases.

Quoted 55 lines
Quoted 8 lines

---
Change from v1:
- Keep bool in struct rproc

---
 drivers/remoteproc/remoteproc_core.c | 37

+++++++++++++++++++++++++++---------

Review

Quoted 4 lines
 include/linux/remoteproc.h           |  2 ++
 2 files changed, 30 insertions(+), 9 deletions(-)
(quoted diff) +0 -0

b/drivers/remoteproc/remoteproc_core.c

drivers/remoteproc/remoteproc_core.c static int rproc_fw_boot(struct rproc *rproc,

Quoted 4 lines

index 3c5fbbbfb0f1..7eaf0f949afa 100644

drivers/remoteproc/remoteproc_core.c +0 -0
@@ -1372,7 +1372,11 @@ static int rproc_fw_boot(struct rproc *rproc,

const struct firmware *fw)

drivers/remoteproc/remoteproc_core.c static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)

Quoted 9 lines
drivers/remoteproc/remoteproc_core.c +5 -1
 	if (ret)
 		return ret;
 
-	dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
+	if (fw)
+		dev_info(dev, "Booting fw image %s, size %zd\n", name,
+			 fw->size);
+	else
+		dev_info(dev, "Synchronizing with preloaded co-

processor\n");

drivers/remoteproc/remoteproc_core.c static void rproc_crash_handler_work(struct

Quoted 4 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	/*
 	 * if enabling an IOMMU isn't relevant for this rproc, this is
@@ -1728,7 +1732,7 @@ static void rproc_crash_handler_work(struct

work_struct *work)

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +1 -1
  */
 int rproc_boot(struct rproc *rproc)
 {
-	const struct firmware *firmware_p;
+	const struct firmware *firmware_p = NULL;
 	struct device *dev;
 	int ret;
 
@@ -1759,11 +1763,17 @@ int rproc_boot(struct rproc *rproc)
 

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1768

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +3 -5
 	dev_info(dev, "powering up %s\n", rproc->name);
 
-	/* load firmware */
-	ret = request_firmware(&firmware_p, rproc->firmware, dev);
-	if (ret < 0) {
-		dev_err(dev, "request_firmware failed: %d\n", ret);
-		goto downref_rproc;
+	if (!rproc->preloaded) {
+		/* load firmware */
+		ret = request_firmware(&firmware_p, rproc->firmware,

dev);

Quoted 11 lines

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1776

Quoted 8 lines
drivers/remoteproc/remoteproc_core.c +8 -0
+		if (ret < 0) {
+			dev_err(dev, "request_firmware failed: %d\n", ret);
+			goto downref_rproc;
+		}
+	} else {
+		/* set firmware name to null as unknown */
+		kfree(rproc->firmware);
+		rproc->firmware = NULL;

What happens when the remoteproc crashes? What happens if I stop it and try to start it again?

Exactly, it should be stopped, then firmware should be provided and coprocessor restarted thanks to sysfs interface

Quoted 8 lines
Quoted 8 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	}
 
 	ret = rproc_fw_boot(rproc, firmware_p);
@@ -1917,8 +1927,17 @@ int rproc_add(struct rproc *rproc)
 	/* create debugfs entries */
 	rproc_create_debug_dir(rproc);
 
Quoted 13 lines

drivers/remoteproc/remoteproc_core.c int rproc_add(struct rproc *rproc) · line 1936

Quoted 9 lines
drivers/remoteproc/remoteproc_core.c +7 -2
-	/* if rproc is marked always-on, request it to boot */
-	if (rproc->auto_boot) {
+	if (rproc->preloaded) {
+		/*
+		 * If rproc is marked already booted, no need to wait
+		 * for firmware.
+		 * Just handle associated resources and start sub devices
+		 */
+		ret = rproc_boot(rproc);

This will trickle down to your remoteproc driver's start() callback. If you really mean that "preloaded" means "already started", then I presume you're having some logic in your start() to turn it into a nop?

Yes it is the responsibility of the driver to know in which state coprocessor is. Depending on the use case, driver could:
- do nothing if coprocessor already running
- boot coprocessor, if only firmware was preloaded
- reboot coprocessor to restart its execution on the preloaded firmware

Quoted 19 lines
Quoted 13 lines
drivers/remoteproc/remoteproc_core.c +4 -0
+		if (ret < 0)
+			return ret;
+	} else if (rproc->auto_boot) {
+		/* if rproc is marked always-on, request it to boot */
 		ret = rproc_trigger_auto_boot(rproc);
 		if (ret < 0)
 			return ret;
include/linux/remoteproc.h +0 -0
index 16ad66683ad0..b68fbd576a77 100644

include/linux/remoteproc.h struct rproc_dump_segment { · line 482

Quoted 4 lines
include/linux/remoteproc.h +1 -0
@@ -479,6 +479,7 @@ 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
+ * @preloaded: remote processor has been preloaded before start

sequence

Quoted 4 lines

I think this should be "skip_firmware_load", or if you really mean that the bootloader started the remote process perhaps this should be "@fw_booted: remote processor was booted by firmware" (or something similar).

I'm fine with "skip_firmware_load" or "skip_fw_load" to have a shorter name. I'll also add "preload" in patch title.

Regards,
Loic

Quoted 18 lines

Regards,
Bjorn

Quoted 14 lines
include/linux/remoteproc.h +1 -1
  * @dump_segments: list of segments in the firmware
  * @nb_vdev: number of vdev currently handled by rproc
  */
@@ -512,6 +513,7 @@ struct rproc {
 	size_t table_sz;
 	bool has_iommu;
 	bool auto_boot;
+	bool preloaded;
 	struct list_head dump_segments;
 	int nb_vdev;
 };
--

2.7.4

#3 lore raw
Quoted 27 lines · Loic PALLARDY

Hi Bjorn,

Thanks for your review.

Quoted 22 lines

-----Original Message-----
From: Bjorn Andersson <[email protected]>
Sent: samedi 9 novembre 2019 02:20
To: Loic PALLARDY <[email protected]>
Cc: [email protected]; [email protected]; linux- [email protected]; Arnaud POULIQUEN <[email protected]>; [email protected]; Fabien DESSENNE <[email protected]>; [email protected]
Subject: Re: [PATCH v2 1/1] remoteproc: add support for co-processor booted before kernel

Quoted 8 lines · Loic Pallardy

Remote processor could boot independently or be started before Linux kernel by bootloader or any firmware.
This patch introduces a new property in rproc core, named preloaded, to be able to allocate resources and sub-devices like vdev and to synchronize with current state without loading firmware from file system. It is platform driver responsibility to implement the right firmware load ops according to HW specificities.

Quoted 1 line

Is it just preloaded or already started?

Quoted 9 lines

At the beginning, this properties was indeed to support an already started coprocessor, but discussing with Suman few months ago, we detected some cases for which firmware may be loaded before kernel start (firmware located in embedded flash or loaded by bootloaders) or may be loaded by a dedicated driver interface before rproc framework be called.
As rproc framework is mainly responsible for firmware loading and resource allocation, I named this property preloaded to cover as much as possible all cases.

Cool, then I like this patch :)

Quoted 66 lines
Quoted 55 lines
Quoted 8 lines

---
Change from v1:
- Keep bool in struct rproc

---
 drivers/remoteproc/remoteproc_core.c | 37

+++++++++++++++++++++++++++---------

Review

Quoted 4 lines
 include/linux/remoteproc.h           |  2 ++
 2 files changed, 30 insertions(+), 9 deletions(-)
(quoted diff) +0 -0

b/drivers/remoteproc/remoteproc_core.c

drivers/remoteproc/remoteproc_core.c static int rproc_fw_boot(struct rproc *rproc,

Quoted 4 lines

index 3c5fbbbfb0f1..7eaf0f949afa 100644

drivers/remoteproc/remoteproc_core.c +0 -0
@@ -1372,7 +1372,11 @@ static int rproc_fw_boot(struct rproc *rproc,

const struct firmware *fw)

drivers/remoteproc/remoteproc_core.c static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)

Quoted 9 lines
drivers/remoteproc/remoteproc_core.c +5 -1
 	if (ret)
 		return ret;
 
-	dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
+	if (fw)
+		dev_info(dev, "Booting fw image %s, size %zd\n", name,
+			 fw->size);
+	else
+		dev_info(dev, "Synchronizing with preloaded co-

processor\n");

drivers/remoteproc/remoteproc_core.c static void rproc_crash_handler_work(struct

Quoted 4 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	/*
 	 * if enabling an IOMMU isn't relevant for this rproc, this is
@@ -1728,7 +1732,7 @@ static void rproc_crash_handler_work(struct

work_struct *work)

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +1 -1
  */
 int rproc_boot(struct rproc *rproc)
 {
-	const struct firmware *firmware_p;
+	const struct firmware *firmware_p = NULL;
 	struct device *dev;
 	int ret;
 
@@ -1759,11 +1763,17 @@ int rproc_boot(struct rproc *rproc)
 

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1768

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +3 -5
 	dev_info(dev, "powering up %s\n", rproc->name);
 
-	/* load firmware */
-	ret = request_firmware(&firmware_p, rproc->firmware, dev);
-	if (ret < 0) {
-		dev_err(dev, "request_firmware failed: %d\n", ret);
-		goto downref_rproc;
+	if (!rproc->preloaded) {
+		/* load firmware */
+		ret = request_firmware(&firmware_p, rproc->firmware,

dev);

Quoted 11 lines

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1776

Quoted 8 lines
drivers/remoteproc/remoteproc_core.c +8 -0
+		if (ret < 0) {
+			dev_err(dev, "request_firmware failed: %d\n", ret);
+			goto downref_rproc;
+		}
+	} else {
+		/* set firmware name to null as unknown */
+		kfree(rproc->firmware);
+		rproc->firmware = NULL;

What happens when the remoteproc crashes? What happens if I stop it and try to start it again?

Quoted 3 lines

Exactly, it should be stopped, then firmware should be provided and coprocessor restarted thanks to sysfs interface

But in both these cases you rely on the firmware being persistent in some memory - be it some protected portion of RAM or some ROM?

I.e. with this patch, and not setting "firmware" the remote is expected to just boot again on the same firmware.

Quoted 21 lines
Quoted 8 lines
Quoted 8 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	}
 
 	ret = rproc_fw_boot(rproc, firmware_p);
@@ -1917,8 +1927,17 @@ int rproc_add(struct rproc *rproc)
 	/* create debugfs entries */
 	rproc_create_debug_dir(rproc);
 
Quoted 13 lines

drivers/remoteproc/remoteproc_core.c int rproc_add(struct rproc *rproc) · line 1936

Quoted 9 lines
drivers/remoteproc/remoteproc_core.c +7 -2
-	/* if rproc is marked always-on, request it to boot */
-	if (rproc->auto_boot) {
+	if (rproc->preloaded) {
+		/*
+		 * If rproc is marked already booted, no need to wait
+		 * for firmware.
+		 * Just handle associated resources and start sub devices
+		 */
+		ret = rproc_boot(rproc);

This will trickle down to your remoteproc driver's start() callback. If you really mean that "preloaded" means "already started", then I presume you're having some logic in your start() to turn it into a nop?

Quoted 6 lines

Yes it is the responsibility of the driver to know in which state coprocessor is. Depending on the use case, driver could:
- do nothing if coprocessor already running
- boot coprocessor, if only firmware was preloaded
- reboot coprocessor to restart its execution on the preloaded firmware

I'm slightly worried about the cases of finding an already booted coprocessor, as this often means that we have to make assumptions about clock states etc.

But with the focus of supporting persistent firmware, I like this.

Quoted 19 lines
Quoted 19 lines
Quoted 13 lines
drivers/remoteproc/remoteproc_core.c +4 -0
+		if (ret < 0)
+			return ret;
+	} else if (rproc->auto_boot) {
+		/* if rproc is marked always-on, request it to boot */
 		ret = rproc_trigger_auto_boot(rproc);
 		if (ret < 0)
 			return ret;
include/linux/remoteproc.h +0 -0
index 16ad66683ad0..b68fbd576a77 100644

include/linux/remoteproc.h struct rproc_dump_segment { · line 482

Quoted 4 lines
include/linux/remoteproc.h +1 -0
@@ -479,6 +479,7 @@ 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
+ * @preloaded: remote processor has been preloaded before start

sequence

Quoted 7 lines
Quoted 4 lines

I think this should be "skip_firmware_load", or if you really mean that the bootloader started the remote process perhaps this should be "@fw_booted: remote processor was booted by firmware" (or something similar).

I'm fine with "skip_firmware_load" or "skip_fw_load" to have a shorter name. I'll also add "preload" in patch title.

skip_fw_load sounds good.

Thanks,
Bjorn

Quoted 21 lines

Regards,
Loic

Quoted 18 lines

Regards,
Bjorn

Quoted 14 lines
include/linux/remoteproc.h +1 -1
  * @dump_segments: list of segments in the firmware
  * @nb_vdev: number of vdev currently handled by rproc
  */
@@ -512,6 +513,7 @@ struct rproc {
 	size_t table_sz;
 	bool has_iommu;
 	bool auto_boot;
+	bool preloaded;
 	struct list_head dump_segments;
 	int nb_vdev;
 };
--

2.7.4

#4 lore raw
Quoted 128 lines

-----Original Message-----
From: [email protected] <linux-remoteproc- [email protected]> On Behalf Of Bjorn Andersson
Sent: mardi 12 novembre 2019 18:33
To: Loic PALLARDY <[email protected]>
Cc: [email protected]; [email protected]; linux- [email protected]; Arnaud POULIQUEN <[email protected]>; [email protected]; Fabien DESSENNE <[email protected]>; [email protected]
Subject: Re: [PATCH v2 1/1] remoteproc: add support for co-processor booted before kernel

Quoted 10 lines · Loic PALLARDY

Hi Bjorn,

Thanks for your review.

Quoted 6 lines

-----Original Message-----
From: Bjorn Andersson <[email protected]>
Sent: samedi 9 novembre 2019 02:20
To: Loic PALLARDY <[email protected]>
Cc: [email protected]; [email protected]; linux- [email protected]; Arnaud POULIQUEN

<[email protected]>;

Quoted 5 lines
Quoted 5 lines

[email protected]; Fabien DESSENNE <[email protected]>; [email protected]
Subject: Re: [PATCH v2 1/1] remoteproc: add support for co-processor booted before kernel

Quoted 7 lines
Quoted 7 lines · Loic Pallardy
Quoted 6 lines

Remote processor could boot independently or be started before Linux kernel by bootloader or any firmware.
This patch introduces a new property in rproc core, named preloaded, to be able to allocate resources and sub-devices like vdev and to synchronize with current state without loading firmware from file

system.

Quoted 5 lines
Quoted 5 lines
Quoted 3 lines

It is platform driver responsibility to implement the right firmware load ops according to HW specificities.

Is it just preloaded or already started?

Quoted 9 lines

At the beginning, this properties was indeed to support an already started coprocessor, but discussing with Suman few months ago, we detected some cases for which firmware may be loaded before kernel start (firmware located in embedded flash or loaded by bootloaders) or may be loaded by a dedicated driver interface before rproc framework be called.
As rproc framework is mainly responsible for firmware loading and resource allocation, I named this property preloaded to cover as much as possible all cases.

Cool, then I like this patch :)

Quoted 55 lines
Quoted 55 lines
Quoted 8 lines

---
Change from v1:
- Keep bool in struct rproc

---
 drivers/remoteproc/remoteproc_core.c | 37

+++++++++++++++++++++++++++---------

Review

Quoted 4 lines
 include/linux/remoteproc.h           |  2 ++
 2 files changed, 30 insertions(+), 9 deletions(-)
(quoted diff) +0 -0

b/drivers/remoteproc/remoteproc_core.c

drivers/remoteproc/remoteproc_core.c static int rproc_fw_boot(struct rproc *rproc,

Quoted 4 lines

index 3c5fbbbfb0f1..7eaf0f949afa 100644

drivers/remoteproc/remoteproc_core.c +0 -0
@@ -1372,7 +1372,11 @@ static int rproc_fw_boot(struct rproc *rproc,

const struct firmware *fw)

drivers/remoteproc/remoteproc_core.c static int rproc_fw_boot(struct rproc *rproc, const struct firmware *fw)

Quoted 9 lines
drivers/remoteproc/remoteproc_core.c +5 -1
 	if (ret)
 		return ret;
 
-	dev_info(dev, "Booting fw image %s, size %zd\n", name, fw->size);
+	if (fw)
+		dev_info(dev, "Booting fw image %s, size %zd\n", name,
+			 fw->size);
+	else
+		dev_info(dev, "Synchronizing with preloaded co-

processor\n");

drivers/remoteproc/remoteproc_core.c static void rproc_crash_handler_work(struct

Quoted 4 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	/*
 	 * if enabling an IOMMU isn't relevant for this rproc, this is
@@ -1728,7 +1732,7 @@ static void rproc_crash_handler_work(struct

work_struct *work)

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +1 -1
  */
 int rproc_boot(struct rproc *rproc)
 {
-	const struct firmware *firmware_p;
+	const struct firmware *firmware_p = NULL;
 	struct device *dev;
 	int ret;
 
@@ -1759,11 +1763,17 @@ int rproc_boot(struct rproc *rproc)
 

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1768

Quoted 10 lines
drivers/remoteproc/remoteproc_core.c +3 -5
 	dev_info(dev, "powering up %s\n", rproc->name);
 
-	/* load firmware */
-	ret = request_firmware(&firmware_p, rproc->firmware, dev);
-	if (ret < 0) {
-		dev_err(dev, "request_firmware failed: %d\n", ret);
-		goto downref_rproc;
+	if (!rproc->preloaded) {
+		/* load firmware */
+		ret = request_firmware(&firmware_p, rproc->firmware,

dev);

Quoted 10 lines
Quoted 10 lines

drivers/remoteproc/remoteproc_core.c int rproc_boot(struct rproc *rproc) · line 1776

Quoted 8 lines
drivers/remoteproc/remoteproc_core.c +8 -0
+		if (ret < 0) {
+			dev_err(dev, "request_firmware failed: %d\n", ret);
+			goto downref_rproc;
+		}
+	} else {
+		/* set firmware name to null as unknown */
+		kfree(rproc->firmware);
+		rproc->firmware = NULL;

What happens when the remoteproc crashes? What happens if I stop it

and

Quoted 4 lines
Quoted 1 line

try to start it again?

Exactly, it should be stopped, then firmware should be provided and coprocessor restarted thanks to sysfs interface

Quoted 5 lines

But in both these cases you rely on the firmware being persistent in some memory - be it some protected portion of RAM or some ROM?

I.e. with this patch, and not setting "firmware" the remote is expected to just boot again on the same firmware.

Today no, we need to reload a firmware, but indeed it is an option is we consider the code located in a protected memory. I have another patch to clean-up recovery operation, for example generating a core dump without automatically restarting the coprocessor... I'll rebase and share it too.

Quoted 31 lines
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
drivers/remoteproc/remoteproc_core.c +0 -0
 	}
 
 	ret = rproc_fw_boot(rproc, firmware_p);
@@ -1917,8 +1927,17 @@ int rproc_add(struct rproc *rproc)
 	/* create debugfs entries */
 	rproc_create_debug_dir(rproc);
 
Quoted 12 lines
Quoted 4 lines
Quoted 4 lines
drivers/remoteproc/remoteproc_core.c +2 -2
-	/* if rproc is marked always-on, request it to boot */
-	if (rproc->auto_boot) {
+	if (rproc->preloaded) {
+		/*
Quoted 8 lines

drivers/remoteproc/remoteproc_core.c int rproc_add(struct rproc *rproc) · line 1936

Quoted 5 lines
drivers/remoteproc/remoteproc_core.c +5 -0
+		 * If rproc is marked already booted, no need to wait
+		 * for firmware.
+		 * Just handle associated resources and start sub devices
+		 */
+		ret = rproc_boot(rproc);

This will trickle down to your remoteproc driver's start() callback. If you really mean that "preloaded" means "already started", then I

presume

Quoted 2 lines
Quoted 1 line

you're having some logic in your start() to turn it into a nop?

Yes it is the responsibility of the driver to know in which state coprocessor

is.

Quoted 5 lines

Depending on the use case, driver could:
- do nothing if coprocessor already running
- boot coprocessor, if only firmware was preloaded
- reboot coprocessor to restart its execution on the preloaded firmware

Quoted 3 lines

I'm slightly worried about the cases of finding an already booted coprocessor, as this often means that we have to make assumptions about clock states etc.

Yes that part is very platform driver specific and it will be driver responsibility to preserve or to update associated clocks.

Regards,
Loic

Quoted 59 lines

But with the focus of supporting persistent firmware, I like this.

Quoted 16 lines
Quoted 16 lines
Quoted 13 lines
drivers/remoteproc/remoteproc_core.c +4 -0
+		if (ret < 0)
+			return ret;
+	} else if (rproc->auto_boot) {
+		/* if rproc is marked always-on, request it to boot */
 		ret = rproc_trigger_auto_boot(rproc);
 		if (ret < 0)
 			return ret;
include/linux/remoteproc.h +0 -0
index 16ad66683ad0..b68fbd576a77 100644

include/linux/remoteproc.h struct rproc_dump_segment { · line 481

Quoted 3 lines
include/linux/remoteproc.h +0 -0
@@ -479,6 +479,7 @@ 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

Quoted 6 lines
Quoted 6 lines

include/linux/remoteproc.h struct rproc_dump_segment { · line 482

Quoted 1 line
include/linux/remoteproc.h +1 -0
+ * @preloaded: remote processor has been preloaded before start

sequence

I think this should be "skip_firmware_load", or if you really mean that the bootloader started the remote process perhaps this should be "@fw_booted: remote processor was booted by firmware" (or

something

Quoted 2 lines
Quoted 1 line

similar).

I'm fine with "skip_firmware_load" or "skip_fw_load" to have a shorter

name.

Quoted 2 lines

I'll also add "preload" in patch title.

skip_fw_load sounds good.

Thanks,
Bjorn

Quoted 21 lines

Regards,
Loic

Quoted 18 lines

Regards,
Bjorn

Quoted 14 lines
include/linux/remoteproc.h +1 -1
  * @dump_segments: list of segments in the firmware
  * @nb_vdev: number of vdev currently handled by rproc
  */
@@ -512,6 +513,7 @@ struct rproc {
 	size_t table_sz;
 	bool has_iommu;
 	bool auto_boot;
+	bool preloaded;
 	struct list_head dump_segments;
 	int nb_vdev;
 };
--

2.7.4