diff mbox series

[v4,05/17] remoteproc: Add new get_loaded_rsc_table() remoteproc operation

Message ID 20201218173228.2277032-6-mathieu.poirier@linaro.org
State New
Headers show
Series remoteproc: Add support for detaching a rproc | expand

Commit Message

Mathieu Poirier Dec. 18, 2020, 5:32 p.m. UTC 
Add an 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>

---
 drivers/remoteproc/remoteproc_core.c     | 6 ++++++
 drivers/remoteproc/remoteproc_internal.h | 8 ++++++++
 include/linux/remoteproc.h               | 5 ++++-
 3 files changed, 18 insertions(+), 1 deletion(-)

-- 
2.25.1

Comments

Arnaud POULIQUEN Jan. 27, 2021, 8:44 a.m. UTC | #1 
Hi Mathieu,

Come back on you series...

On 12/18/20 6:32 PM, Mathieu Poirier wrote:
> Add an 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>

> ---

>  drivers/remoteproc/remoteproc_core.c     | 6 ++++++

>  drivers/remoteproc/remoteproc_internal.h | 8 ++++++++

>  include/linux/remoteproc.h               | 5 ++++-

>  3 files changed, 18 insertions(+), 1 deletion(-)

> 

> diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c

> index d0f6b39b56f9..3d87c910aca7 100644

> --- a/drivers/remoteproc/remoteproc_core.c

> +++ b/drivers/remoteproc/remoteproc_core.c

> @@ -1556,6 +1556,12 @@ static int rproc_attach(struct rproc *rproc)

>  		return ret;

>  	}

>  

> +	ret = rproc_get_loaded_rsc_table(rproc);

> +	if (ret) {

> +		dev_err(dev, "can't load resource table: %d\n", ret);

> +		goto disable_iommu;

> +	}

> +


This function is rather ambiguous. Without the example of stm32, it is not
obvious what the platform driver has to do in this ops. And the update of rproc
in the in the core instead of in platform driver seems to me more reliable.

Here is a suggestion considering that ->cached_table is always NULL:


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);

	*size = 0;
	return NULL;
}

then in rproc_attach:

	table_ptr = rproc_get_loaded_rsc_table(rproc, &tab_size);
	if (PTR_ERR(table_ptr) {
		dev_err(dev, "can't load resource table: %d\n", ret);
		goto disable_iommu;
	}
 	rproc->cached_table = NULL;
 	rproc->table_ptr = table_ptr;
 	rproc->table_sz = table_sz;


Thanks,
Arnaud

>  	/* reset max_notifyid */

>  	rproc->max_notifyid = -1;

>  

> diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h

> index c34002888d2c..c48b301d6ad1 100644

> --- a/drivers/remoteproc/remoteproc_internal.h

> +++ b/drivers/remoteproc/remoteproc_internal.h

> @@ -177,6 +177,14 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,

>  	return NULL;

>  }

>  

> +static inline int rproc_get_loaded_rsc_table(struct rproc *rproc)

> +{

> +	if (rproc->ops->get_loaded_rsc_table)

> +		return rproc->ops->get_loaded_rsc_table(rproc);

> +

> +	return 0;

> +}

> +

>  static inline

>  bool rproc_u64_fit_in_size_t(u64 val)

>  {

> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h

> index 3fa3ba6498e8..571615e77e6f 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

> @@ -389,6 +391,7 @@ struct rproc_ops {

>  			  int offset, int avail);

>  	struct resource_table *(*find_loaded_rsc_table)(

>  				struct rproc *rproc, const struct firmware *fw);

> +	int (*get_loaded_rsc_table)(struct rproc *rproc);

>  	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);

>
Mathieu Poirier Jan. 29, 2021, 9:37 p.m. UTC | #2 
On Wed, Jan 27, 2021 at 09:44:28AM +0100, Arnaud POULIQUEN wrote:
> Hi Mathieu,

> 

> Come back on you series...

> 

> On 12/18/20 6:32 PM, Mathieu Poirier wrote:

> > Add an 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>

> > ---

> >  drivers/remoteproc/remoteproc_core.c     | 6 ++++++

> >  drivers/remoteproc/remoteproc_internal.h | 8 ++++++++

> >  include/linux/remoteproc.h               | 5 ++++-

> >  3 files changed, 18 insertions(+), 1 deletion(-)

> > 

> > diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c

> > index d0f6b39b56f9..3d87c910aca7 100644

> > --- a/drivers/remoteproc/remoteproc_core.c

> > +++ b/drivers/remoteproc/remoteproc_core.c

> > @@ -1556,6 +1556,12 @@ static int rproc_attach(struct rproc *rproc)

> >  		return ret;

> >  	}

> >  

> > +	ret = rproc_get_loaded_rsc_table(rproc);

> > +	if (ret) {

> > +		dev_err(dev, "can't load resource table: %d\n", ret);

> > +		goto disable_iommu;

> > +	}

> > +

> 

> This function is rather ambiguous. Without the example of stm32, it is not

> obvious what the platform driver has to do in this ops. And the update of rproc

> in the in the core instead of in platform driver seems to me more reliable.

> 

> Here is a suggestion considering that ->cached_table is always NULL:

> 

> 

> 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);

> 

> 	*size = 0;

> 	return NULL;

> }

> 

> then in rproc_attach:

> 

> 	table_ptr = rproc_get_loaded_rsc_table(rproc, &tab_size);

> 	if (PTR_ERR(table_ptr) {

> 		dev_err(dev, "can't load resource table: %d\n", ret);

> 		goto disable_iommu;

> 	}

>  	rproc->cached_table = NULL;

>  	rproc->table_ptr = table_ptr;

>  	rproc->table_sz = table_sz;

>


Much better yes, thanks for the suggestion.
 
> 

> Thanks,

> Arnaud

> 

> >  	/* reset max_notifyid */

> >  	rproc->max_notifyid = -1;

> >  

> > diff --git a/drivers/remoteproc/remoteproc_internal.h b/drivers/remoteproc/remoteproc_internal.h

> > index c34002888d2c..c48b301d6ad1 100644

> > --- a/drivers/remoteproc/remoteproc_internal.h

> > +++ b/drivers/remoteproc/remoteproc_internal.h

> > @@ -177,6 +177,14 @@ struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,

> >  	return NULL;

> >  }

> >  

> > +static inline int rproc_get_loaded_rsc_table(struct rproc *rproc)

> > +{

> > +	if (rproc->ops->get_loaded_rsc_table)

> > +		return rproc->ops->get_loaded_rsc_table(rproc);

> > +

> > +	return 0;

> > +}

> > +

> >  static inline

> >  bool rproc_u64_fit_in_size_t(u64 val)

> >  {

> > diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h

> > index 3fa3ba6498e8..571615e77e6f 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

> > @@ -389,6 +391,7 @@ struct rproc_ops {

> >  			  int offset, int avail);

> >  	struct resource_table *(*find_loaded_rsc_table)(

> >  				struct rproc *rproc, const struct firmware *fw);

> > +	int (*get_loaded_rsc_table)(struct rproc *rproc);

> >  	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);

> >
diff mbox series

Patch

diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c
index d0f6b39b56f9..3d87c910aca7 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,12 @@  static int rproc_attach(struct rproc *rproc)
 		return ret;
 	}
 
+	ret = rproc_get_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..c48b301d6ad1 100644
--- a/drivers/remoteproc/remoteproc_internal.h
+++ b/drivers/remoteproc/remoteproc_internal.h
@@ -177,6 +177,14 @@  struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
 	return NULL;
 }
 
+static inline int rproc_get_loaded_rsc_table(struct rproc *rproc)
+{
+	if (rproc->ops->get_loaded_rsc_table)
+		return rproc->ops->get_loaded_rsc_table(rproc);
+
+	return 0;
+}
+
 static inline
 bool rproc_u64_fit_in_size_t(u64 val)
 {
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 3fa3ba6498e8..571615e77e6f 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
@@ -389,6 +391,7 @@  struct rproc_ops {
 			  int offset, int avail);
 	struct resource_table *(*find_loaded_rsc_table)(
 				struct rproc *rproc, const struct firmware *fw);
+	int (*get_loaded_rsc_table)(struct rproc *rproc);
 	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);