github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-30 18:13:41 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

remoteproc: Use of_reserved_mem_region_* functions for "memory-region"

Browse Source 
Use the newly added of_reserved_mem_region_to_resource() and
of_reserved_mem_region_count() functions to handle "memory-region"
properties.

The error handling is a bit different in some cases. Often
"memory-region" is optional, so failed lookup is not an error. But then
an error in of_reserved_mem_lookup() is treated as an error. However,
that distinction is not really important. Either the region is available
and usable or it is not. So now, it is just
of_reserved_mem_region_to_resource() which is checked for an error.

Acked-by: Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
Tested-by: Peng Fan <peng.fan@nxp.com> # i.MX93-11x11-EVK for imx_rproc.c
Reviewed-by: Geert Uytterhoeven <geert+renesas@glider.be> # rcar
Tested-by: Beleswar Padhi <b-padhi@ti.com> # TI
Signed-off-by: Rob Herring (Arm) <robh@kernel.org>
Link: https://lore.kernel.org/r/20251124182751.507624-1-robh@kernel.org
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
This commit is contained in:
Rob Herring (Arm) 2025-11-24 12:27:47 -06:00 committed by Mathieu Poirier
parent 6f880e7bd1
commit 67a7bc7f03
7 changed files with 127 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
drivers/remoteproc/imx_dsp_rproc.c
View File

@ -658,11 +658,9 @@ static int imx_dsp_rproc_add_carveout(struct imx_dsp_rproc *priv)
struct rproc *rproc = priv->rproc; struct rproc *rproc = priv->rproc;
struct device *dev = rproc->dev.parent; struct device *dev = rproc->dev.parent;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
struct of_phandle_iterator it;
struct rproc_mem_entry *mem; struct rproc_mem_entry *mem;
struct reserved_mem *rmem;
void __iomem *cpu_addr; void __iomem *cpu_addr;
int a; int a, i = 0;
u64 da; u64 da;
/* Remap required addresses */ /* Remap required addresses */
@ -693,49 +691,40 @@ static int imx_dsp_rproc_add_carveout(struct imx_dsp_rproc *priv)
rproc_add_carveout(rproc, mem); rproc_add_carveout(rproc, mem);
} }
of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); while (1) {
while (of_phandle_iterator_next(&it) == 0) { int err;
struct resource res;
err = of_reserved_mem_region_to_resource(np, i++, &res);
if (err)
return 0;
/* /*
* Ignore the first memory region which will be used vdev buffer. * Ignore the first memory region which will be used vdev buffer.
* No need to do extra handlings, rproc_add_virtio_dev will handle it. * No need to do extra handlings, rproc_add_virtio_dev will handle it.
*/ */
if (!strcmp(it.node->name, "vdev0buffer")) if (strstarts(res.name, "vdev0buffer"))
continue; continue;
rmem = of_reserved_mem_lookup(it.node); if (imx_dsp_rproc_sys_to_da(priv, res.start, resource_size(&res), &da))
if (!rmem) {
of_node_put(it.node);
dev_err(dev, "unable to acquire memory-region\n");
return -EINVAL; return -EINVAL;
}
if (imx_dsp_rproc_sys_to_da(priv, rmem->base, rmem->size, &da)) { cpu_addr = devm_ioremap_resource_wc(dev, &res);
of_node_put(it.node);
return -EINVAL;
}
cpu_addr = devm_ioremap_wc(dev, rmem->base, rmem->size);
if (!cpu_addr) { if (!cpu_addr) {
of_node_put(it.node); dev_err(dev, "failed to map memory %pR\n", &res);
dev_err(dev, "failed to map memory %p\n", &rmem->base);
return -ENOMEM; return -ENOMEM;
} }
/* Register memory region */ /* Register memory region */
mem = rproc_mem_entry_init(dev, (void __force *)cpu_addr, (dma_addr_t)rmem->base, mem = rproc_mem_entry_init(dev, (void __force *)cpu_addr, (dma_addr_t)res.start,
rmem->size, da, NULL, NULL, it.node->name); resource_size(&res), da, NULL, NULL,
"%.*s", strchrnul(res.name, '@') - res.name, res.name);
if (mem) { if (!mem)
rproc_coredump_add_segment(rproc, da, rmem->size);
} else {
of_node_put(it.node);
return -ENOMEM; return -ENOMEM;
}
rproc_coredump_add_segment(rproc, da, resource_size(&res));
rproc_add_carveout(rproc, mem); rproc_add_carveout(rproc, mem);
} }
return 0;
} }
/* Prepare function for rproc_ops */ /* Prepare function for rproc_ops */

70
drivers/remoteproc/imx_rproc.c
View File

@ -490,50 +490,44 @@ static int imx_rproc_prepare(struct rproc *rproc)
{ {
struct imx_rproc *priv = rproc->priv; struct imx_rproc *priv = rproc->priv;
struct device_node *np = priv->dev->of_node; struct device_node *np = priv->dev->of_node;
struct of_phandle_iterator it;
struct rproc_mem_entry *mem; struct rproc_mem_entry *mem;
struct reserved_mem *rmem; int i = 0;
u32 da; u32 da;
/* Register associated reserved memory regions */ /* Register associated reserved memory regions */
of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); while (1) {
while (of_phandle_iterator_next(&it) == 0) { int err;
struct resource res;
err = of_reserved_mem_region_to_resource(np, i++, &res);
if (err)
return 0;
/* /*
* Ignore the first memory region which will be used vdev buffer. * Ignore the first memory region which will be used vdev buffer.
* No need to do extra handlings, rproc_add_virtio_dev will handle it. * No need to do extra handlings, rproc_add_virtio_dev will handle it.
*/ */
if (!strcmp(it.node->name, "vdev0buffer")) if (strstarts(res.name, "vdev0buffer"))
continue; continue;
if (!strcmp(it.node->name, "rsc-table")) if (strstarts(res.name, "rsc-table"))
continue; continue;
rmem = of_reserved_mem_lookup(it.node);
if (!rmem) {
of_node_put(it.node);
dev_err(priv->dev, "unable to acquire memory-region\n");
return -EINVAL;
}
/* No need to translate pa to da, i.MX use same map */ /* No need to translate pa to da, i.MX use same map */
da = rmem->base; da = res.start;
/* Register memory region */ /* Register memory region */
mem = rproc_mem_entry_init(priv->dev, NULL, (dma_addr_t)rmem->base, rmem->size, da, mem = rproc_mem_entry_init(priv->dev, NULL, (dma_addr_t)res.start,
resource_size(&res), da,
imx_rproc_mem_alloc, imx_rproc_mem_release, imx_rproc_mem_alloc, imx_rproc_mem_release,
it.node->name); "%.*s", strchrnul(res.name, '@') - res.name,
res.name);
if (mem) { if (!mem)
rproc_coredump_add_segment(rproc, da, rmem->size);
} else {
of_node_put(it.node);
return -ENOMEM; return -ENOMEM;
}
rproc_coredump_add_segment(rproc, da, resource_size(&res));
rproc_add_carveout(rproc, mem); rproc_add_carveout(rproc, mem);
} }
return 0;
} }
static int imx_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) static int imx_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
@ -671,47 +665,37 @@ static int imx_rproc_addr_init(struct imx_rproc *priv,
} }
/* memory-region is optional property */ /* memory-region is optional property */
nph = of_count_phandle_with_args(np, "memory-region", NULL); nph = of_reserved_mem_region_count(np);
if (nph <= 0) if (nph <= 0)
return 0; return 0;
/* remap optional addresses */ /* remap optional addresses */
for (a = 0; a < nph; a++) { for (a = 0; a < nph; a++) {
struct device_node *node;
struct resource res; struct resource res;
node = of_parse_phandle(np, "memory-region", a); err = of_reserved_mem_region_to_resource(np, a, &res);
if (!node)
continue;
/* Not map vdevbuffer, vdevring region */
if (!strncmp(node->name, "vdev", strlen("vdev"))) {
of_node_put(node);
continue;
}
err = of_address_to_resource(node, 0, &res);
if (err) { if (err) {
dev_err(dev, "unable to resolve memory region\n"); dev_err(dev, "unable to resolve memory region\n");
of_node_put(node);
return err; return err;
} }
if (b >= IMX_RPROC_MEM_MAX) { /* Not map vdevbuffer, vdevring region */
of_node_put(node); if (strstarts(res.name, "vdev"))
continue;
if (b >= IMX_RPROC_MEM_MAX)
break; break;
}
/* Not use resource version, because we might share region */ /* Not use resource version, because we might share region */
priv->mem[b].cpu_addr = devm_ioremap_wc(&pdev->dev, res.start, resource_size(&res)); priv->mem[b].cpu_addr = devm_ioremap_resource_wc(&pdev->dev, &res);
if (!priv->mem[b].cpu_addr) { if (!priv->mem[b].cpu_addr) {
dev_err(dev, "failed to remap %pr\n", &res); dev_err(dev, "failed to remap %pr\n", &res);
of_node_put(node);
return -ENOMEM; return -ENOMEM;
} }
priv->mem[b].sys_addr = res.start; priv->mem[b].sys_addr = res.start;
priv->mem[b].size = resource_size(&res); priv->mem[b].size = resource_size(&res);
if (!strcmp(node->name, "rsc-table")) if (!strcmp(res.name, "rsc-table"))
priv->rsc_table = priv->mem[b].cpu_addr; priv->rsc_table = priv->mem[b].cpu_addr;
of_node_put(node);
b++; b++;
} }

36
drivers/remoteproc/rcar_rproc.c
View File

@ -52,46 +52,36 @@ static int rcar_rproc_prepare(struct rproc *rproc)
{ {
struct device *dev = rproc->dev.parent; struct device *dev = rproc->dev.parent;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
struct of_phandle_iterator it;
struct rproc_mem_entry *mem; struct rproc_mem_entry *mem;
struct reserved_mem *rmem; int i = 0;
u32 da; u32 da;
/* Register associated reserved memory regions */ /* Register associated reserved memory regions */
of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); while (1) {
while (of_phandle_iterator_next(&it) == 0) { struct resource res;
int ret;
rmem = of_reserved_mem_lookup(it.node); ret = of_reserved_mem_region_to_resource(np, i++, &res);
if (!rmem) { if (ret)
of_node_put(it.node); return 0;
dev_err(&rproc->dev,
"unable to acquire memory-region\n");
return -EINVAL;
}
if (rmem->base > U32_MAX) { if (res.start > U32_MAX)
of_node_put(it.node);
return -EINVAL; return -EINVAL;
}
/* No need to translate pa to da, R-Car use same map */ /* No need to translate pa to da, R-Car use same map */
da = rmem->base; da = res.start;
mem = rproc_mem_entry_init(dev, NULL, mem = rproc_mem_entry_init(dev, NULL,
rmem->base, res.start,
rmem->size, da, resource_size(&res), da,
rcar_rproc_mem_alloc, rcar_rproc_mem_alloc,
rcar_rproc_mem_release, rcar_rproc_mem_release,
it.node->name); res.name);
if (!mem) { if (!mem)
of_node_put(it.node);
return -ENOMEM; return -ENOMEM;
}
rproc_add_carveout(rproc, mem); rproc_add_carveout(rproc, mem);
} }
return 0;
} }
static int rcar_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) static int rcar_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)

41
drivers/remoteproc/st_remoteproc.c
View File

@ -120,40 +120,39 @@ static int st_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
struct device *dev = rproc->dev.parent; struct device *dev = rproc->dev.parent;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
struct rproc_mem_entry *mem; struct rproc_mem_entry *mem;
struct reserved_mem *rmem; int entries;
struct of_phandle_iterator it;
int index = 0;
of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); entries = of_reserved_mem_region_count(np);
while (of_phandle_iterator_next(&it) == 0) {
rmem = of_reserved_mem_lookup(it.node); for (int index = 0; index < entries; index++) {
if (!rmem) { struct resource res;
of_node_put(it.node); int ret;
dev_err(dev, "unable to acquire memory-region\n");
return -EINVAL; ret = of_reserved_mem_region_to_resource(np, index, &res);
} if (ret)
return ret;
/* No need to map vdev buffer */ /* No need to map vdev buffer */
if (strcmp(it.node->name, "vdev0buffer")) { if (!strstarts(res.name, "vdev0buffer")) {
/* Register memory region */ /* Register memory region */
mem = rproc_mem_entry_init(dev, NULL, mem = rproc_mem_entry_init(dev, NULL,
(dma_addr_t)rmem->base, (dma_addr_t)res.start,
rmem->size, rmem->base, resource_size(&res), res.start,
st_rproc_mem_alloc, st_rproc_mem_alloc,
st_rproc_mem_release, st_rproc_mem_release,
it.node->name); "%.*s",
strchrnul(res.name, '@') - res.name,
res.name);
} else { } else {
/* Register reserved memory for vdev buffer allocation */ /* Register reserved memory for vdev buffer allocation */
mem = rproc_of_resm_mem_entry_init(dev, index, mem = rproc_of_resm_mem_entry_init(dev, index,
rmem->size, resource_size(&res),
rmem->base, res.start,
it.node->name); "vdev0buffer");
} }
if (!mem) { if (!mem)
of_node_put(it.node);
return -ENOMEM; return -ENOMEM;
}
rproc_add_carveout(rproc, mem); rproc_add_carveout(rproc, mem);
index++; index++;

46
drivers/remoteproc/stm32_rproc.c
View File

@ -213,60 +213,52 @@ static int stm32_rproc_prepare(struct rproc *rproc)
{ {
struct device *dev = rproc->dev.parent; struct device *dev = rproc->dev.parent;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
struct of_phandle_iterator it;
struct rproc_mem_entry *mem; struct rproc_mem_entry *mem;
struct reserved_mem *rmem;
u64 da; u64 da;
int index = 0; int index = 0, mr = 0;
/* Register associated reserved memory regions */ /* Register associated reserved memory regions */
of_phandle_iterator_init(&it, np, "memory-region", NULL, 0); while (1) {
while (of_phandle_iterator_next(&it) == 0) { struct resource res;
rmem = of_reserved_mem_lookup(it.node); int ret;
if (!rmem) {
of_node_put(it.node);
dev_err(dev, "unable to acquire memory-region\n");
return -EINVAL;
}
if (stm32_rproc_pa_to_da(rproc, rmem->base, &da) < 0) { ret = of_reserved_mem_region_to_resource(np, mr++, &res);
of_node_put(it.node); if (ret)
dev_err(dev, "memory region not valid %pa\n", return 0;
&rmem->base);
if (stm32_rproc_pa_to_da(rproc, res.start, &da) < 0) {
dev_err(dev, "memory region not valid %pR\n", &res);
return -EINVAL; return -EINVAL;
} }
/* No need to map vdev buffer */ /* No need to map vdev buffer */
if (strcmp(it.node->name, "vdev0buffer")) { if (!strstarts(res.name, "vdev0buffer")) {
/* Register memory region */ /* Register memory region */
mem = rproc_mem_entry_init(dev, NULL, mem = rproc_mem_entry_init(dev, NULL,
(dma_addr_t)rmem->base, (dma_addr_t)res.start,
rmem->size, da, resource_size(&res), da,
stm32_rproc_mem_alloc, stm32_rproc_mem_alloc,
stm32_rproc_mem_release, stm32_rproc_mem_release,
it.node->name); "%.*s", strchrnul(res.name, '@') - res.name,
res.name);
if (mem) if (mem)
rproc_coredump_add_segment(rproc, da, rproc_coredump_add_segment(rproc, da,
rmem->size); resource_size(&res));
} else { } else {
/* Register reserved memory for vdev buffer alloc */ /* Register reserved memory for vdev buffer alloc */
mem = rproc_of_resm_mem_entry_init(dev, index, mem = rproc_of_resm_mem_entry_init(dev, index,
rmem->size, resource_size(&res),
rmem->base, res.start,
it.node->name); "vdev0buffer");
} }
if (!mem) { if (!mem) {
of_node_put(it.node);
return -ENOMEM; return -ENOMEM;
} }
rproc_add_carveout(rproc, mem); rproc_add_carveout(rproc, mem);
index++; index++;
} }
return 0;
} }
static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw) static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)

28
drivers/remoteproc/ti_k3_common.c
View File

@ -470,13 +470,10 @@ int k3_reserved_mem_init(struct k3_rproc *kproc)
{ {
struct device *dev = kproc->dev; struct device *dev = kproc->dev;
struct device_node *np = dev->of_node; struct device_node *np = dev->of_node;
struct device_node *rmem_np;
struct reserved_mem *rmem;
int num_rmems; int num_rmems;
int ret, i; int ret, i;
num_rmems = of_property_count_elems_of_size(np, "memory-region", num_rmems = of_reserved_mem_region_count(np);
sizeof(phandle));
if (num_rmems < 0) { if (num_rmems < 0) {
dev_err(dev, "device does not reserved memory regions (%d)\n", dev_err(dev, "device does not reserved memory regions (%d)\n",
num_rmems); num_rmems);
@ -505,23 +502,20 @@ int k3_reserved_mem_init(struct k3_rproc *kproc)
/* use remaining reserved memory regions for static carveouts */ /* use remaining reserved memory regions for static carveouts */
for (i = 0; i < num_rmems; i++) { for (i = 0; i < num_rmems; i++) {
rmem_np = of_parse_phandle(np, "memory-region", i + 1); struct resource res;
if (!rmem_np)
return -EINVAL;
rmem = of_reserved_mem_lookup(rmem_np); ret = of_reserved_mem_region_to_resource(np, i + 1, &res);
of_node_put(rmem_np); if (ret)
if (!rmem) return ret;
return -EINVAL;
kproc->rmem[i].bus_addr = rmem->base; kproc->rmem[i].bus_addr = res.start;
/* 64-bit address regions currently not supported */ /* 64-bit address regions currently not supported */
kproc->rmem[i].dev_addr = (u32)rmem->base; kproc->rmem[i].dev_addr = (u32)res.start;
kproc->rmem[i].size = rmem->size; kproc->rmem[i].size = resource_size(&res);
kproc->rmem[i].cpu_addr = devm_ioremap_wc(dev, rmem->base, rmem->size); kproc->rmem[i].cpu_addr = devm_ioremap_resource_wc(dev, &res);
if (!kproc->rmem[i].cpu_addr) { if (!kproc->rmem[i].cpu_addr) {
dev_err(dev, "failed to map reserved memory#%d at %pa of size %pa\n", dev_err(dev, "failed to map reserved memory#%d at %pR\n",
i + 1, &rmem->base, &rmem->size); i + 1, &res);
return -ENOMEM; return -ENOMEM;
} }

53
drivers/remoteproc/xlnx_r5_remoteproc.c
View File

@ -492,53 +492,46 @@ static int add_mem_regions_carveout(struct rproc *rproc)
{ {
struct rproc_mem_entry *rproc_mem; struct rproc_mem_entry *rproc_mem;
struct zynqmp_r5_core *r5_core; struct zynqmp_r5_core *r5_core;
struct of_phandle_iterator it;
struct reserved_mem *rmem;
int i = 0; int i = 0;
r5_core = rproc->priv; r5_core = rproc->priv;
/* Register associated reserved memory regions */ /* Register associated reserved memory regions */
of_phandle_iterator_init(&it, r5_core->np, "memory-region", NULL, 0); while (1) {
int err;
struct resource res;
while (of_phandle_iterator_next(&it) == 0) { err = of_reserved_mem_region_to_resource(r5_core->np, i, &res);
rmem = of_reserved_mem_lookup(it.node); if (err)
if (!rmem) { return 0;
of_node_put(it.node);
dev_err(&rproc->dev, "unable to acquire memory-region\n");
return -EINVAL;
}
if (!strcmp(it.node->name, "vdev0buffer")) { if (strstarts(res.name, "vdev0buffer")) {
/* Init reserved memory for vdev buffer */ /* Init reserved memory for vdev buffer */
rproc_mem = rproc_of_resm_mem_entry_init(&rproc->dev, i, rproc_mem = rproc_of_resm_mem_entry_init(&rproc->dev, i,
rmem->size, resource_size(&res),
rmem->base, res.start,
it.node->name); "vdev0buffer");
} else { } else {
/* Register associated reserved memory regions */ /* Register associated reserved memory regions */
rproc_mem = rproc_mem_entry_init(&rproc->dev, NULL, rproc_mem = rproc_mem_entry_init(&rproc->dev, NULL,
(dma_addr_t)rmem->base, (dma_addr_t)res.start,
rmem->size, rmem->base, resource_size(&res), res.start,
zynqmp_r5_mem_region_map, zynqmp_r5_mem_region_map,
zynqmp_r5_mem_region_unmap, zynqmp_r5_mem_region_unmap,
it.node->name); "%.*s",
strchrnul(res.name, '@') - res.name,
res.name);
} }
if (!rproc_mem) { if (!rproc_mem)
of_node_put(it.node);
return -ENOMEM; return -ENOMEM;
}
rproc_add_carveout(rproc, rproc_mem); rproc_add_carveout(rproc, rproc_mem);
rproc_coredump_add_segment(rproc, rmem->base, rmem->size); rproc_coredump_add_segment(rproc, res.start, resource_size(&res));
dev_dbg(&rproc->dev, "reserved mem carveout %s addr=%llx, size=0x%llx", dev_dbg(&rproc->dev, "reserved mem carveout %pR\n", &res);
it.node->name, rmem->base, rmem->size);
i++; i++;
} }
return 0;
} }
static int add_sram_carveouts(struct rproc *rproc) static int add_sram_carveouts(struct rproc *rproc)
@ -808,7 +801,6 @@ static int zynqmp_r5_get_rsc_table_va(struct zynqmp_r5_core *r5_core)
struct device *dev = r5_core->dev; struct device *dev = r5_core->dev;
struct rsc_tbl_data *rsc_data_va; struct rsc_tbl_data *rsc_data_va;
struct resource res_mem; struct resource res_mem;
struct device_node *np;
int ret; int ret;
/* /*
@ -818,14 +810,7 @@ static int zynqmp_r5_get_rsc_table_va(struct zynqmp_r5_core *r5_core)
* contains that data structure which holds resource table address, size * contains that data structure which holds resource table address, size
* and some magic number to validate correct resource table entry. * and some magic number to validate correct resource table entry.
*/ */
np = of_parse_phandle(r5_core->np, "memory-region", 0); ret = of_reserved_mem_region_to_resource(r5_core->np, 0, &res_mem);
if (!np) {
dev_err(dev, "failed to get memory region dev node\n");
return -EINVAL;
}
ret = of_address_to_resource(np, 0, &res_mem);
of_node_put(np);
if (ret) { if (ret) {
dev_err(dev, "failed to get memory-region resource addr\n"); dev_err(dev, "failed to get memory-region resource addr\n");
return -EINVAL; return -EINVAL;