remoteproc: stm32: Properly handle the resource table when attaching

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>

diff --git a/drivers/remoteproc/stm32_rproc.c b/drivers/remoteproc/stm32_rproc.c
index 2a1cccd..882229f 100644 (file)
--- a/drivers/remoteproc/stm32_rproc.c
+++ b/drivers/remoteproc/stm32_rproc.c
@@ -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;