| Message ID | 20211115135032.129227-4-julien.massot@iot.bzh (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | Initial Renesas R-Car remoteproc support | expand |
Hi Julien, Thanks for the patch. One question CR7 Can be master boot processor. In that case How to avoid loading and booting CR7 processor from Linux? Reading boot modes?? Regards, biju > Subject: [PATCH v1 3/3] remoteproc: Add Renesas rcar driver > > Renesas Gen3 platform includes a Cortex-r7 processor. > > Both: the application cores (A5x) and the realtime core (CR7) share access > to the RAM and devices with the same address map, so device addresses are > equal to the Linux physical addresses. > > In order to initialize this remote processor we need to: > - power on the realtime core > - put the firmware in a ram area > - set the boot address for this firmware (reset vector) > - Deassert the reset > > This initial driver allows to start and stop the Cortex R7 processor. > > Signed-off-by: Julien Massot <julien.massot@iot.bzh> > --- > > Change since RFC: > - Improve Kconfig description. > - Use consistent device for pr_* messages. > - Drop unused dev and rproc member of struct rcar_rproc. > > --- > drivers/remoteproc/Kconfig | 12 ++ > drivers/remoteproc/Makefile | 1 + > drivers/remoteproc/rcar_rproc.c | 226 ++++++++++++++++++++++++++++++++ > 3 files changed, 239 insertions(+) > create mode 100644 drivers/remoteproc/rcar_rproc.c > > diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig index > 9a6eedc3994a..5b0c617d45f6 100644 > --- a/drivers/remoteproc/Kconfig > +++ b/drivers/remoteproc/Kconfig > @@ -261,6 +261,18 @@ config QCOM_WCNSS_PIL > verified and booted with the help of the Peripheral Authentication > System (PAS) in TrustZone. > > +config RCAR_REMOTEPROC > + tristate "Renesas R-CAR Gen3 remoteproc support" > + depends on ARCH_RENESAS > + depends on REMOTEPROC > + help > + Say y here to support R-Car realtime processor via the > + remote processor framework. An elf firmware can be loaded > + thanks to sysfs remoteproc entries. The remote processor > + can be started and stopped. > + This can be either built-in or a loadable module. > + If compiled as module (M), the module name is rcar_rproc. > + > config ST_REMOTEPROC > tristate "ST remoteproc support" > depends on ARCH_STI > diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile > index bb26c9e4ef9c..bb290cc08e99 100644 > --- a/drivers/remoteproc/Makefile > +++ b/drivers/remoteproc/Makefile > @@ -30,6 +30,7 @@ obj-$(CONFIG_QCOM_SYSMON) += qcom_sysmon.o > obj-$(CONFIG_QCOM_WCNSS_PIL) += qcom_wcnss_pil.o > qcom_wcnss_pil-y += qcom_wcnss.o > qcom_wcnss_pil-y += qcom_wcnss_iris.o > +obj-$(CONFIG_RCAR_REMOTEPROC) += rcar_rproc.o > obj-$(CONFIG_ST_REMOTEPROC) += st_remoteproc.o > obj-$(CONFIG_ST_SLIM_REMOTEPROC) += st_slim_rproc.o > obj-$(CONFIG_STM32_RPROC) += stm32_rproc.o > diff --git a/drivers/remoteproc/rcar_rproc.c > b/drivers/remoteproc/rcar_rproc.c new file mode 100644 index > 000000000000..795089dc4337 > --- /dev/null > +++ b/drivers/remoteproc/rcar_rproc.c > @@ -0,0 +1,226 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright (C) IoT.bzh 2021 > + */ > + > +#include <linux/module.h> > +#include <linux/of_device.h> > +#include <linux/of_reserved_mem.h> > +#include <linux/pm_runtime.h> > +#include <linux/remoteproc.h> > +#include <linux/reset.h> > +#include <linux/soc/renesas/rcar-rst.h> > + > +#include "remoteproc_internal.h" > + > +struct rcar_rproc { > + struct reset_control *rst; > +}; > + > +static int rcar_rproc_mem_alloc(struct rproc *rproc, > + struct rproc_mem_entry *mem) > +{ > + struct device *dev = &rproc->dev; > + void *va; > + > + dev_dbg(dev, "map memory: %pa+%lx\n", &mem->dma, mem->len); > + va = ioremap_wc(mem->dma, mem->len); > + if (IS_ERR_OR_NULL(va)) { > + dev_err(dev, "Unable to map memory region: %pa+%lx\n", > + &mem->dma, mem->len); > + return -ENOMEM; > + } > + > + /* Update memory entry va */ > + mem->va = va; > + > + return 0; > +} > + > +static int rcar_rproc_mem_release(struct rproc *rproc, > + struct rproc_mem_entry *mem) > +{ > + dev_dbg(&rproc->dev, "unmap memory: %pa\n", &mem->dma); > + iounmap(mem->va); > + > + return 0; > +} > + > +static int rcar_rproc_prepare(struct rproc *rproc) { > + struct device *dev = rproc->dev.parent; > + struct device_node *np = dev->of_node; > + struct of_phandle_iterator it; > + struct rproc_mem_entry *mem; > + struct reserved_mem *rmem; > + u64 da; > + > + /* Register associated reserved memory regions */ > + of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); > + while (of_phandle_iterator_next(&it) == 0) { > + > + rmem = of_reserved_mem_lookup(it.node); > + if (!rmem) { > + dev_err(&rproc->dev, > + "unable to acquire memory-region\n"); > + return -EINVAL; > + } > + > + /* No need to translate pa to da, R-Car use same map */ > + da = rmem->base; > + > + mem = rproc_mem_entry_init(dev, NULL, > + (dma_addr_t)rmem->base, > + rmem->size, da, > + rcar_rproc_mem_alloc, > + rcar_rproc_mem_release, > + it.node->name); > + > + if (!mem) > + return -ENOMEM; > + > + rproc_add_carveout(rproc, mem); > + } > + > + return 0; > +} > + > +static int rcar_rproc_parse_fw(struct rproc *rproc, const struct > +firmware *fw) { > + int ret; > + > + ret = rproc_elf_load_rsc_table(rproc, fw); > + if (ret) > + dev_info(&rproc->dev, "No resource table in elf\n"); > + > + return 0; > +} > + > +static int rcar_rproc_start(struct rproc *rproc) { > + struct rcar_rproc *priv = rproc->priv; > + int err; > + > + if (!rproc->bootaddr) > + return -EINVAL; > + > + err = rcar_rst_set_rproc_boot_addr(rproc->bootaddr); > + if (err) { > + dev_err(&rproc->dev, "failed to set rproc boot addr\n"); > + return err; > + } > + > + err = reset_control_deassert(priv->rst); > + if (err) > + dev_err(&rproc->dev, "failed to deassert reset\n"); > + > + return err; > +} > + > +static int rcar_rproc_stop(struct rproc *rproc) { > + struct rcar_rproc *priv = rproc->priv; > + int err; > + > + err = reset_control_assert(priv->rst); > + if (err) > + dev_err(&rproc->dev, "failed to assert reset\n"); > + > + return err; > +} > + > +static struct rproc_ops rcar_rproc_ops = { > + .prepare = rcar_rproc_prepare, > + .start = rcar_rproc_start, > + .stop = rcar_rproc_stop, > + .load = rproc_elf_load_segments, > + .parse_fw = rcar_rproc_parse_fw, > + .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table, > + .sanity_check = rproc_elf_sanity_check, > + .get_boot_addr = rproc_elf_get_boot_addr, > + > +}; > + > +static int rcar_rproc_probe(struct platform_device *pdev) { > + struct device *dev = &pdev->dev; > + struct device_node *np = dev->of_node; > + struct rcar_rproc *priv; > + struct rproc *rproc; > + int ret; > + > + rproc = rproc_alloc(dev, np->name, &rcar_rproc_ops, > + NULL, sizeof(*priv)); > + if (!rproc) > + return -ENOMEM; > + > + priv = rproc->priv; > + > + priv->rst = devm_reset_control_get_exclusive(dev, NULL); > + if (IS_ERR(priv->rst)) { > + ret = PTR_ERR(priv->rst); > + dev_err(dev, "fail to acquire rproc reset\n"); > + goto free_rproc; > + } > + > + pm_runtime_enable(dev); > + ret = pm_runtime_get_sync(dev); > + if (ret) { > + dev_err(dev, "failed to power up\n"); > + goto free_rproc; > + } > + > + dev_set_drvdata(dev, rproc); > + > + /* Manually start the rproc */ > + rproc->auto_boot = false; > + > + ret = rproc_add(rproc); > + if (ret) { > + dev_err(dev, "rproc_add failed\n"); > + goto pm_disable; > + } > + > + return 0; > + > +pm_disable: > + pm_runtime_disable(dev); > +free_rproc: > + rproc_free(rproc); > + > + return ret; > +} > + > +static int rcar_rproc_remove(struct platform_device *pdev) { > + struct device *dev = &pdev->dev; > + struct rproc *rproc = platform_get_drvdata(pdev); > + > + rproc_del(rproc); > + pm_runtime_disable(dev); > + rproc_free(rproc); > + > + return 0; > +} > + > +static const struct of_device_id rcar_rproc_of_match[] = { > + { .compatible = "renesas,rcar-cr7" }, > + {}, > +}; > + > +MODULE_DEVICE_TABLE(of, rcar_rproc_of_match); > + > +static struct platform_driver rcar_rproc_driver = { > + .probe = rcar_rproc_probe, > + .remove = rcar_rproc_remove, > + .driver = { > + .name = "rcar-rproc", > + .of_match_table = rcar_rproc_of_match, > + }, > +}; > + > +module_platform_driver(rcar_rproc_driver); > + > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("Renesas Gen3 R-Car remote processor control > +driver"); MODULE_AUTHOR("Julien Massot <julien.massot@iot.bzh>"); > -- > 2.31.1 >
Hi Biju, > > One question CR7 Can be master boot processor. In that case > How to avoid loading and booting CR7 processor from Linux? > Reading boot modes?? > Thanks for the question. I did not test this case. There is also other scenarios where the Cortex-R7 is started by an earlier component such as BL2, u-boot or OP-Tee. In these cases Linux should not try to start / stop this remote processor. One idea could be to read the power status CR7PSTR / PWRSR7, or use one of the MFIS register as a communication register. STM32 processor use this last solution to indicate that the remote processor is already started, in that scenario remoteproc driver starts in 'detached' state instead of 'offline' state. https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/remoteproc.h#n418 In that state, remoteproc driver can initiate communication with this remote processor but will not try to start or to stop it. That's something I have in mind, with an existing implementation there https://github.com/iotbzh/linux/blob/iot/julien/rproc/drivers/remoteproc/rcar_rproc.c#L524 (that is not ready for upstream yet :)). I guess this issue also exists when one device is dedicated to the secure world, so the device exists, but not available for Linux. The most obvious (and dirty ?) solution is to keep the device disabled in dts. Regards, Julien
Hi Julien, > Subject: Re: [PATCH v1 3/3] remoteproc: Add Renesas rcar driver > > Hi Biju, > > > > > One question CR7 Can be master boot processor. In that case How to > > avoid loading and booting CR7 processor from Linux? > > Reading boot modes?? > > > Thanks for the question. > > I did not test this case. OK. There is also other scenarios where the > Cortex-R7 is started by an earlier component such as BL2, u-boot or OP- > Tee. > In these cases Linux should not try to start / stop this remote processor. OK. But Linux can check whether CR7 is alive at frequent interval and issue Soft-reboot, if there is a hang. > One idea could be to read the power status CR7PSTR / PWRSR7, or use one of > the MFIS register as a communication register. I know MFIS is used for communication between CR7 and CA-57. But don't know much details. STM32 processor use this > last solution to indicate that the remote processor is already started, in > that scenario remoteproc driver starts in 'detached' state instead of > 'offline' state. > https://jpn01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgit.kern > el.org%2Fpub%2Fscm%2Flinux%2Fkernel%2Fgit%2Ftorvalds%2Flinux.git%2Ftree%2F > include%2Flinux%2Fremoteproc.h%23n418&data=04%7C01%7Cbiju.das.jz%40bp. > renesas.com%7C945a25980e5a49cc361a08d9a846020c%7C53d82571da1947e49cb4625a1 > 66a4a2a%7C0%7C0%7C637725840924834250%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wL > jAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000&sdata=yXH > 2qBpmUI2YtZRnApFdWt6iONcFKDPSPa45AirThBw%3D&reserved=0 > > In that state, remoteproc driver can initiate communication with this > remote processor but will not try to start or to stop it. > > That's something I have in mind, with an existing implementation there > https://jpn01.safelinks.protection.outlook.com/?url=https%3A%2F%2Fgithub.c > om%2Fiotbzh%2Flinux%2Fblob%2Fiot%2Fjulien%2Frproc%2Fdrivers%2Fremoteproc%2 > Frcar_rproc.c%23L524&data=04%7C01%7Cbiju.das.jz%40bp.renesas.com%7C945 > a25980e5a49cc361a08d9a846020c%7C53d82571da1947e49cb4625a166a4a2a%7C0%7C0%7 > C637725840924834250%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2 > luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000&sdata=WYKygEUiXyliOmX2CUxk > Yfj5pq2QOmZC%2BGtXRAlB%2Bws%3D&reserved=0 > (that is not ready for upstream yet :)). > > I guess this issue also exists when one device is dedicated to the secure > world, so the device exists, but not available for Linux. May be for prototyping activity, if some one wants to run an RTOS on CR7. This will be a good solution. Linux will load and boot CR7 which Run an RTOS which communicates with Linux. Once communication established Linux can check the health of CR7 at frequent intervals and take necessary action. Regards, Biju The most obvious > (and dirty ?) solution is to keep the device disabled in dts. > > Regards, > Julien
Hi, On Mon, Nov 15, 2021 at 02:50:32PM +0100, Julien Massot wrote: > Renesas Gen3 platform includes a Cortex-r7 processor. > > Both: the application cores (A5x) and the realtime core (CR7) > share access to the RAM and devices with the same address map, > so device addresses are equal to the Linux physical addresses. > > In order to initialize this remote processor we need to: > - power on the realtime core > - put the firmware in a ram area > - set the boot address for this firmware (reset vector) > - Deassert the reset > > This initial driver allows to start and stop the Cortex R7 > processor. > > Signed-off-by: Julien Massot <julien.massot@iot.bzh> > --- > > Change since RFC: > - Improve Kconfig description. > - Use consistent device for pr_* messages. > - Drop unused dev and rproc member of struct rcar_rproc. > > --- > drivers/remoteproc/Kconfig | 12 ++ > drivers/remoteproc/Makefile | 1 + > drivers/remoteproc/rcar_rproc.c | 226 ++++++++++++++++++++++++++++++++ > 3 files changed, 239 insertions(+) > create mode 100644 drivers/remoteproc/rcar_rproc.c > > diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig > index 9a6eedc3994a..5b0c617d45f6 100644 > --- a/drivers/remoteproc/Kconfig > +++ b/drivers/remoteproc/Kconfig > @@ -261,6 +261,18 @@ config QCOM_WCNSS_PIL > verified and booted with the help of the Peripheral Authentication > System (PAS) in TrustZone. > > +config RCAR_REMOTEPROC > + tristate "Renesas R-CAR Gen3 remoteproc support" > + depends on ARCH_RENESAS > + depends on REMOTEPROC You should be able to remove the dependency on REMOTEPROC since this is already in the "if REMOTEPROC" block. > + help > + Say y here to support R-Car realtime processor via the > + remote processor framework. An elf firmware can be loaded > + thanks to sysfs remoteproc entries. The remote processor > + can be started and stopped. > + This can be either built-in or a loadable module. > + If compiled as module (M), the module name is rcar_rproc. > + > config ST_REMOTEPROC > tristate "ST remoteproc support" > depends on ARCH_STI > diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile > index bb26c9e4ef9c..bb290cc08e99 100644 > --- a/drivers/remoteproc/Makefile > +++ b/drivers/remoteproc/Makefile > @@ -30,6 +30,7 @@ obj-$(CONFIG_QCOM_SYSMON) += qcom_sysmon.o > obj-$(CONFIG_QCOM_WCNSS_PIL) += qcom_wcnss_pil.o > qcom_wcnss_pil-y += qcom_wcnss.o > qcom_wcnss_pil-y += qcom_wcnss_iris.o > +obj-$(CONFIG_RCAR_REMOTEPROC) += rcar_rproc.o > obj-$(CONFIG_ST_REMOTEPROC) += st_remoteproc.o > obj-$(CONFIG_ST_SLIM_REMOTEPROC) += st_slim_rproc.o > obj-$(CONFIG_STM32_RPROC) += stm32_rproc.o > diff --git a/drivers/remoteproc/rcar_rproc.c b/drivers/remoteproc/rcar_rproc.c > new file mode 100644 > index 000000000000..795089dc4337 > --- /dev/null > +++ b/drivers/remoteproc/rcar_rproc.c > @@ -0,0 +1,226 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright (C) IoT.bzh 2021 > + */ > + > +#include <linux/module.h> > +#include <linux/of_device.h> > +#include <linux/of_reserved_mem.h> > +#include <linux/pm_runtime.h> > +#include <linux/remoteproc.h> > +#include <linux/reset.h> > +#include <linux/soc/renesas/rcar-rst.h> > + > +#include "remoteproc_internal.h" > + > +struct rcar_rproc { > + struct reset_control *rst; > +}; > + > +static int rcar_rproc_mem_alloc(struct rproc *rproc, > + struct rproc_mem_entry *mem) > +{ > + struct device *dev = &rproc->dev; > + void *va; > + > + dev_dbg(dev, "map memory: %pa+%lx\n", &mem->dma, mem->len); > + va = ioremap_wc(mem->dma, mem->len); > + if (IS_ERR_OR_NULL(va)) { > + dev_err(dev, "Unable to map memory region: %pa+%lx\n", The sparse checker doesn't like %lx so probably be better to go with just %x. Apologies for suggesting to use %lx. > + &mem->dma, mem->len); > + return -ENOMEM; > + } > + > + /* Update memory entry va */ > + mem->va = va; Talking about the sparse checker, you will see complaints about @va not being of type "void __iomem *". You can ignore those as this would likely require to refactor the rproc_mem_entry structure, which is outside the scope of this work. > + > + return 0; > +} > + > +static int rcar_rproc_mem_release(struct rproc *rproc, > + struct rproc_mem_entry *mem) > +{ > + dev_dbg(&rproc->dev, "unmap memory: %pa\n", &mem->dma); > + iounmap(mem->va); > + > + return 0; > +} > + > +static int rcar_rproc_prepare(struct rproc *rproc) > +{ > + struct device *dev = rproc->dev.parent; > + struct device_node *np = dev->of_node; > + struct of_phandle_iterator it; > + struct rproc_mem_entry *mem; > + struct reserved_mem *rmem; > + u64 da; > + > + /* Register associated reserved memory regions */ > + of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); > + while (of_phandle_iterator_next(&it) == 0) { > + > + rmem = of_reserved_mem_lookup(it.node); > + if (!rmem) { > + dev_err(&rproc->dev, > + "unable to acquire memory-region\n"); > + return -EINVAL; > + } > + > + /* No need to translate pa to da, R-Car use same map */ > + da = rmem->base; > + > + mem = rproc_mem_entry_init(dev, NULL, > + (dma_addr_t)rmem->base, > + rmem->size, da, > + rcar_rproc_mem_alloc, > + rcar_rproc_mem_release, > + it.node->name); > + > + if (!mem) > + return -ENOMEM; > + > + rproc_add_carveout(rproc, mem); > + } > + > + return 0; > +} > + > +static int rcar_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) > +{ > + int ret; > + > + ret = rproc_elf_load_rsc_table(rproc, fw); > + if (ret) > + dev_info(&rproc->dev, "No resource table in elf\n"); > + > + return 0; > +} > + > +static int rcar_rproc_start(struct rproc *rproc) > +{ > + struct rcar_rproc *priv = rproc->priv; > + int err; > + > + if (!rproc->bootaddr) > + return -EINVAL; > + > + err = rcar_rst_set_rproc_boot_addr(rproc->bootaddr); > + if (err) { > + dev_err(&rproc->dev, "failed to set rproc boot addr\n"); > + return err; > + } > + > + err = reset_control_deassert(priv->rst); > + if (err) > + dev_err(&rproc->dev, "failed to deassert reset\n"); > + > + return err; > +} > + > +static int rcar_rproc_stop(struct rproc *rproc) > +{ > + struct rcar_rproc *priv = rproc->priv; > + int err; > + > + err = reset_control_assert(priv->rst); > + if (err) > + dev_err(&rproc->dev, "failed to assert reset\n"); > + > + return err; > +} > + > +static struct rproc_ops rcar_rproc_ops = { > + .prepare = rcar_rproc_prepare, > + .start = rcar_rproc_start, > + .stop = rcar_rproc_stop, > + .load = rproc_elf_load_segments, > + .parse_fw = rcar_rproc_parse_fw, > + .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table, > + .sanity_check = rproc_elf_sanity_check, > + .get_boot_addr = rproc_elf_get_boot_addr, > + > +}; > + > +static int rcar_rproc_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct device_node *np = dev->of_node; > + struct rcar_rproc *priv; > + struct rproc *rproc; > + int ret; > + > + rproc = rproc_alloc(dev, np->name, &rcar_rproc_ops, > + NULL, sizeof(*priv)); > + if (!rproc) > + return -ENOMEM; > + > + priv = rproc->priv; > + > + priv->rst = devm_reset_control_get_exclusive(dev, NULL); > + if (IS_ERR(priv->rst)) { > + ret = PTR_ERR(priv->rst); > + dev_err(dev, "fail to acquire rproc reset\n"); > + goto free_rproc; > + } > + > + pm_runtime_enable(dev); > + ret = pm_runtime_get_sync(dev); > + if (ret) { > + dev_err(dev, "failed to power up\n"); > + goto free_rproc; > + } > + > + dev_set_drvdata(dev, rproc); > + > + /* Manually start the rproc */ > + rproc->auto_boot = false; > + > + ret = rproc_add(rproc); > + if (ret) { > + dev_err(dev, "rproc_add failed\n"); > + goto pm_disable; > + } > + > + return 0; > + > +pm_disable: > + pm_runtime_disable(dev); > +free_rproc: > + rproc_free(rproc); > + > + return ret; > +} > + > +static int rcar_rproc_remove(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct rproc *rproc = platform_get_drvdata(pdev); > + > + rproc_del(rproc); > + pm_runtime_disable(dev); > + rproc_free(rproc); > + > + return 0; > +} > + > +static const struct of_device_id rcar_rproc_of_match[] = { > + { .compatible = "renesas,rcar-cr7" }, > + {}, > +}; > + > +MODULE_DEVICE_TABLE(of, rcar_rproc_of_match); > + > +static struct platform_driver rcar_rproc_driver = { > + .probe = rcar_rproc_probe, > + .remove = rcar_rproc_remove, > + .driver = { > + .name = "rcar-rproc", > + .of_match_table = rcar_rproc_of_match, > + }, > +}; This set is just as clean as the RFC. If it wasn't for the DTS bindings that need to be ack'ed by Rob, I probably would have made the above modifications and applied this patch. Thanks, Mathieu > + > +module_platform_driver(rcar_rproc_driver); > + > +MODULE_LICENSE("GPL v2"); > +MODULE_DESCRIPTION("Renesas Gen3 R-Car remote processor control driver"); > +MODULE_AUTHOR("Julien Massot <julien.massot@iot.bzh>"); > -- > 2.31.1 > >
Hi Mathieu, Thanks for the review ! >> +config RCAR_REMOTEPROC >> + tristate "Renesas R-CAR Gen3 remoteproc support" >> + depends on ARCH_RENESAS >> + depends on REMOTEPROC > > You should be able to remove the dependency on REMOTEPROC since this is already in > the "if REMOTEPROC" block. Will fix. ... > >> + >> + dev_dbg(dev, "map memory: %pa+%lx\n", &mem->dma, mem->len); >> + va = ioremap_wc(mem->dma, mem->len); >> + if (IS_ERR_OR_NULL(va)) { >> + dev_err(dev, "Unable to map memory region: %pa+%lx\n", > > The sparse checker doesn't like %lx so probably be better to go with just %x. > Apologies for suggesting to use %lx. With %x gcc complains on arm64 build will go back to %zx. > >> + &mem->dma, mem->len); >> + return -ENOMEM; >> + } >> + >> + /* Update memory entry va */ >> + mem->va = va; > > Talking about the sparse checker, you will see complaints about @va not being of > type "void __iomem *". You can ignore those as this would likely require to > refactor the rproc_mem_entry structure, which is outside the scope of this work. Ok, to be honest, I was not aware of the sparse tool, thanks a lot to point me to this tool. > > This set is just as clean as the RFC. If it wasn't for the DTS bindings that > need to be ack'ed by Rob, I probably would have made the above modifications and > applied this patch. > > Thanks, > Mathieu No problem will send a v2. Regards, Julien
On Wed, 24 Nov 2021 at 04:07, Julien Massot <julien.massot@iot.bzh> wrote: > > Hi Mathieu, > Thanks for the review ! > > >> +config RCAR_REMOTEPROC > >> + tristate "Renesas R-CAR Gen3 remoteproc support" > >> + depends on ARCH_RENESAS > >> + depends on REMOTEPROC > > > > You should be able to remove the dependency on REMOTEPROC since this is already in > > the "if REMOTEPROC" block. > Will fix. > > ... > > > >> + > >> + dev_dbg(dev, "map memory: %pa+%lx\n", &mem->dma, mem->len); > >> + va = ioremap_wc(mem->dma, mem->len); > >> + if (IS_ERR_OR_NULL(va)) { > >> + dev_err(dev, "Unable to map memory region: %pa+%lx\n", > > > > The sparse checker doesn't like %lx so probably be better to go with just %x. > > Apologies for suggesting to use %lx. > > With %x gcc complains on arm64 build will go back to %zx. Ok > > > > >> + &mem->dma, mem->len); > >> + return -ENOMEM; > >> + } > >> + > >> + /* Update memory entry va */ > >> + mem->va = va; > > > > Talking about the sparse checker, you will see complaints about @va not being of > > type "void __iomem *". You can ignore those as this would likely require to > > refactor the rproc_mem_entry structure, which is outside the scope of this work. > > Ok, to be honest, I was not aware of the sparse tool, thanks a lot to point me to > this tool. > > > > > This set is just as clean as the RFC. If it wasn't for the DTS bindings that > > need to be ack'ed by Rob, I probably would have made the above modifications and > > applied this patch. > > > > Thanks, > > Mathieu > > No problem will send a v2. > > Regards, > Julien > -- > Julien Massot [IoT.bzh] >
diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig index 9a6eedc3994a..5b0c617d45f6 100644 --- a/drivers/remoteproc/Kconfig +++ b/drivers/remoteproc/Kconfig @@ -261,6 +261,18 @@ config QCOM_WCNSS_PIL verified and booted with the help of the Peripheral Authentication System (PAS) in TrustZone. +config RCAR_REMOTEPROC + tristate "Renesas R-CAR Gen3 remoteproc support" + depends on ARCH_RENESAS + depends on REMOTEPROC + help + Say y here to support R-Car realtime processor via the + remote processor framework. An elf firmware can be loaded + thanks to sysfs remoteproc entries. The remote processor + can be started and stopped. + This can be either built-in or a loadable module. + If compiled as module (M), the module name is rcar_rproc. + config ST_REMOTEPROC tristate "ST remoteproc support" depends on ARCH_STI diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile index bb26c9e4ef9c..bb290cc08e99 100644 --- a/drivers/remoteproc/Makefile +++ b/drivers/remoteproc/Makefile @@ -30,6 +30,7 @@ obj-$(CONFIG_QCOM_SYSMON) += qcom_sysmon.o obj-$(CONFIG_QCOM_WCNSS_PIL) += qcom_wcnss_pil.o qcom_wcnss_pil-y += qcom_wcnss.o qcom_wcnss_pil-y += qcom_wcnss_iris.o +obj-$(CONFIG_RCAR_REMOTEPROC) += rcar_rproc.o obj-$(CONFIG_ST_REMOTEPROC) += st_remoteproc.o obj-$(CONFIG_ST_SLIM_REMOTEPROC) += st_slim_rproc.o obj-$(CONFIG_STM32_RPROC) += stm32_rproc.o diff --git a/drivers/remoteproc/rcar_rproc.c b/drivers/remoteproc/rcar_rproc.c new file mode 100644 index 000000000000..795089dc4337 --- /dev/null +++ b/drivers/remoteproc/rcar_rproc.c @@ -0,0 +1,226 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) IoT.bzh 2021 + */ + +#include <linux/module.h> +#include <linux/of_device.h> +#include <linux/of_reserved_mem.h> +#include <linux/pm_runtime.h> +#include <linux/remoteproc.h> +#include <linux/reset.h> +#include <linux/soc/renesas/rcar-rst.h> + +#include "remoteproc_internal.h" + +struct rcar_rproc { + struct reset_control *rst; +}; + +static int rcar_rproc_mem_alloc(struct rproc *rproc, + struct rproc_mem_entry *mem) +{ + struct device *dev = &rproc->dev; + void *va; + + dev_dbg(dev, "map memory: %pa+%lx\n", &mem->dma, mem->len); + va = ioremap_wc(mem->dma, mem->len); + if (IS_ERR_OR_NULL(va)) { + dev_err(dev, "Unable to map memory region: %pa+%lx\n", + &mem->dma, mem->len); + return -ENOMEM; + } + + /* Update memory entry va */ + mem->va = va; + + return 0; +} + +static int rcar_rproc_mem_release(struct rproc *rproc, + struct rproc_mem_entry *mem) +{ + dev_dbg(&rproc->dev, "unmap memory: %pa\n", &mem->dma); + iounmap(mem->va); + + return 0; +} + +static int rcar_rproc_prepare(struct rproc *rproc) +{ + struct device *dev = rproc->dev.parent; + struct device_node *np = dev->of_node; + struct of_phandle_iterator it; + struct rproc_mem_entry *mem; + struct reserved_mem *rmem; + u64 da; + + /* Register associated reserved memory regions */ + of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); + while (of_phandle_iterator_next(&it) == 0) { + + rmem = of_reserved_mem_lookup(it.node); + if (!rmem) { + dev_err(&rproc->dev, + "unable to acquire memory-region\n"); + return -EINVAL; + } + + /* No need to translate pa to da, R-Car use same map */ + da = rmem->base; + + mem = rproc_mem_entry_init(dev, NULL, + (dma_addr_t)rmem->base, + rmem->size, da, + rcar_rproc_mem_alloc, + rcar_rproc_mem_release, + it.node->name); + + if (!mem) + return -ENOMEM; + + rproc_add_carveout(rproc, mem); + } + + return 0; +} + +static int rcar_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) +{ + int ret; + + ret = rproc_elf_load_rsc_table(rproc, fw); + if (ret) + dev_info(&rproc->dev, "No resource table in elf\n"); + + return 0; +} + +static int rcar_rproc_start(struct rproc *rproc) +{ + struct rcar_rproc *priv = rproc->priv; + int err; + + if (!rproc->bootaddr) + return -EINVAL; + + err = rcar_rst_set_rproc_boot_addr(rproc->bootaddr); + if (err) { + dev_err(&rproc->dev, "failed to set rproc boot addr\n"); + return err; + } + + err = reset_control_deassert(priv->rst); + if (err) + dev_err(&rproc->dev, "failed to deassert reset\n"); + + return err; +} + +static int rcar_rproc_stop(struct rproc *rproc) +{ + struct rcar_rproc *priv = rproc->priv; + int err; + + err = reset_control_assert(priv->rst); + if (err) + dev_err(&rproc->dev, "failed to assert reset\n"); + + return err; +} + +static struct rproc_ops rcar_rproc_ops = { + .prepare = rcar_rproc_prepare, + .start = rcar_rproc_start, + .stop = rcar_rproc_stop, + .load = rproc_elf_load_segments, + .parse_fw = rcar_rproc_parse_fw, + .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table, + .sanity_check = rproc_elf_sanity_check, + .get_boot_addr = rproc_elf_get_boot_addr, + +}; + +static int rcar_rproc_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *np = dev->of_node; + struct rcar_rproc *priv; + struct rproc *rproc; + int ret; + + rproc = rproc_alloc(dev, np->name, &rcar_rproc_ops, + NULL, sizeof(*priv)); + if (!rproc) + return -ENOMEM; + + priv = rproc->priv; + + priv->rst = devm_reset_control_get_exclusive(dev, NULL); + if (IS_ERR(priv->rst)) { + ret = PTR_ERR(priv->rst); + dev_err(dev, "fail to acquire rproc reset\n"); + goto free_rproc; + } + + pm_runtime_enable(dev); + ret = pm_runtime_get_sync(dev); + if (ret) { + dev_err(dev, "failed to power up\n"); + goto free_rproc; + } + + dev_set_drvdata(dev, rproc); + + /* Manually start the rproc */ + rproc->auto_boot = false; + + ret = rproc_add(rproc); + if (ret) { + dev_err(dev, "rproc_add failed\n"); + goto pm_disable; + } + + return 0; + +pm_disable: + pm_runtime_disable(dev); +free_rproc: + rproc_free(rproc); + + return ret; +} + +static int rcar_rproc_remove(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct rproc *rproc = platform_get_drvdata(pdev); + + rproc_del(rproc); + pm_runtime_disable(dev); + rproc_free(rproc); + + return 0; +} + +static const struct of_device_id rcar_rproc_of_match[] = { + { .compatible = "renesas,rcar-cr7" }, + {}, +}; + +MODULE_DEVICE_TABLE(of, rcar_rproc_of_match); + +static struct platform_driver rcar_rproc_driver = { + .probe = rcar_rproc_probe, + .remove = rcar_rproc_remove, + .driver = { + .name = "rcar-rproc", + .of_match_table = rcar_rproc_of_match, + }, +}; + +module_platform_driver(rcar_rproc_driver); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("Renesas Gen3 R-Car remote processor control driver"); +MODULE_AUTHOR("Julien Massot <julien.massot@iot.bzh>");
Renesas Gen3 platform includes a Cortex-r7 processor. Both: the application cores (A5x) and the realtime core (CR7) share access to the RAM and devices with the same address map, so device addresses are equal to the Linux physical addresses. In order to initialize this remote processor we need to: - power on the realtime core - put the firmware in a ram area - set the boot address for this firmware (reset vector) - Deassert the reset This initial driver allows to start and stop the Cortex R7 processor. Signed-off-by: Julien Massot <julien.massot@iot.bzh> --- Change since RFC: - Improve Kconfig description. - Use consistent device for pr_* messages. - Drop unused dev and rproc member of struct rcar_rproc. --- drivers/remoteproc/Kconfig | 12 ++ drivers/remoteproc/Makefile | 1 + drivers/remoteproc/rcar_rproc.c | 226 ++++++++++++++++++++++++++++++++ 3 files changed, 239 insertions(+) create mode 100644 drivers/remoteproc/rcar_rproc.c