renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-18 18:23:53 +08:00
Code

remoteproc: stm32: Properly handle the resource table when attaching

Browse Source 
Properly set the remote processor's resource table based on where it was
loaded by the external entity when attaching to a remote processor.

Mainly based on the work published by Arnaud Pouliquen [1].

[1]. https://patchwork.kernel.org/project/linux-remoteproc/list/?series=239877

Acked-by: Arnaud Pouliquen <arnaud.pouliquen@st.com>
Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Link: https://lore.kernel.org/r/20200714200445.1427257-10-mathieu.poirier@linaro.org
Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
This commit is contained in:
Mathieu Poirier 2020-07-14 14:04:43 -06:00 committed by Bjorn Andersson
parent dadbdb9c30
commit 11a7aaa72c
1 changed files with 76 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
drivers/remoteproc/stm32_rproc.c
View File

@ -39,6 +39,8 @@
#define STM32_MBX_VQ1_ID 1
#define STM32_MBX_SHUTDOWN "shutdown"
#define RSC_TBL_SIZE 1024
#define M4_STATE_OFF 0
#define M4_STATE_INI 1
#define M4_STATE_CRUN 2
@ -86,6 +88,7 @@ struct stm32_rproc {
struct stm32_mbox mb[MBOX_NB_MBX];
struct workqueue_struct *workqueue;
bool secured_soc;
void __iomem *rsc_va;
};
static int stm32_rproc_pa_to_da(struct rproc *rproc, phys_addr_t pa, u64 *da)
@ -669,6 +672,75 @@ static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
}
static int stm32_rproc_da_to_pa(struct platform_device *pdev,
struct stm32_rproc *ddata,
u64 da, phys_addr_t *pa)
{
struct device *dev = &pdev->dev;
struct stm32_rproc_mem *p_mem;
unsigned int i;
for (i = 0; i < ddata->nb_rmems; i++) {
p_mem = &ddata->rmems[i];
if (da < p_mem->dev_addr ||
da >= p_mem->dev_addr + p_mem->size)
continue;
*pa = da - p_mem->dev_addr + p_mem->bus_addr;
dev_dbg(dev, "da %llx to pa %#x\n", da, *pa);
return 0;
}
dev_err(dev, "can't translate da %llx\n", da);
return -EINVAL;
}
static int stm32_rproc_get_loaded_rsc_table(struct platform_device *pdev,
struct rproc *rproc,
struct stm32_rproc *ddata)
{
struct device *dev = &pdev->dev;
phys_addr_t rsc_pa;
u32 rsc_da;
int err;
err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
if (err) {
dev_err(dev, "failed to read rsc tbl addr\n");
return err;
}
if (!rsc_da)
/* no rsc table */
return 0;
err = stm32_rproc_da_to_pa(pdev, ddata, rsc_da, &rsc_pa);
if (err)
return err;
ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
if (IS_ERR_OR_NULL(ddata->rsc_va)) {
dev_err(dev, "Unable to map memory region: %pa+%zx\n",
&rsc_pa, RSC_TBL_SIZE);
ddata->rsc_va = NULL;
return -ENOMEM;
}
/*
* The resource table is already loaded in device memory, no need
* to work with a cached table.
*/
rproc->cached_table = NULL;
/* Assuming the resource table fits in 1kB is fair */
rproc->table_sz = RSC_TBL_SIZE;
rproc->table_ptr = (struct resource_table *)ddata->rsc_va;
return 0;
}
static int stm32_rproc_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
@ -708,6 +780,10 @@ static int stm32_rproc_probe(struct platform_device *pdev)
ret = stm32_rproc_parse_memory_regions(rproc);
if (ret)
goto free_resources;
ret = stm32_rproc_get_loaded_rsc_table(pdev, rproc, ddata);
if (ret)
goto free_resources;
}
rproc->has_iommu = false;