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

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.

Signed-off-by: Rob Herring (Arm) <robh@kernel.org>
Link: https://lore.kernel.org/r/20251124182751.507624-2-robh@kernel.org
Signed-off-by: Bjorn Andersson <andersson@kernel.org>

diff --git a/drivers/remoteproc/qcom_q6v5_adsp.c b/drivers/remoteproc/qcom_q6v5_adsp.c
index e98b7e03162c7acc1fec360e257cf0bd84328a62..d3933a66ed3dd6e657a37ca40d67f5911b05be85 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_adsp.c
+++ b/drivers/remoteproc/qcom_q6v5_adsp.c
@@ -625,26 +625,20 @@ static int adsp_init_mmio(struct qcom_adsp *adsp,
 
 static int adsp_alloc_memory_region(struct qcom_adsp *adsp)
 {
-       struct reserved_mem *rmem = NULL;
-       struct device_node *node;
-
-       node = of_parse_phandle(adsp->dev->of_node, "memory-region", 0);
-       if (node)
-               rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
+       int ret;
+       struct resource res;
 
-       if (!rmem) {
+       ret = of_reserved_mem_region_to_resource(adsp->dev->of_node, 0, &res);
+       if (ret) {
                dev_err(adsp->dev, "unable to resolve memory-region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       adsp->mem_phys = adsp->mem_reloc = rmem->base;
-       adsp->mem_size = rmem->size;
-       adsp->mem_region = devm_ioremap_wc(adsp->dev,
-                               adsp->mem_phys, adsp->mem_size);
+       adsp->mem_phys = adsp->mem_reloc = res.start;
+       adsp->mem_size = resource_size(&res);
+       adsp->mem_region = devm_ioremap_resource_wc(adsp->dev, &res);
        if (!adsp->mem_region) {
-               dev_err(adsp->dev, "unable to map memory region: %pa+%zx\n",
-                       &rmem->base, adsp->mem_size);
+               dev_err(adsp->dev, "unable to map memory region: %pR\n", &res);
                return -EBUSY;
        }
 

diff --git a/drivers/remoteproc/qcom_q6v5_mss.c b/drivers/remoteproc/qcom_q6v5_mss.c
index 3087d895b87f446b60b3dcb1529c2a7078adfb73..91940977ca8989cc3bbafff1ef5656530a66a79f 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_mss.c
+++ b/drivers/remoteproc/qcom_q6v5_mss.c
@@ -1970,8 +1970,8 @@ static int q6v5_init_reset(struct q6v5 *qproc)
 static int q6v5_alloc_memory_region(struct q6v5 *qproc)
 {
        struct device_node *child;
-       struct reserved_mem *rmem;
-       struct device_node *node;
+       struct resource res;
+       int ret;
 
        /*
         * In the absence of mba/mpss sub-child, extract the mba and mpss
@@ -1979,71 +1979,49 @@ static int q6v5_alloc_memory_region(struct q6v5 *qproc)
         */
        child = of_get_child_by_name(qproc->dev->of_node, "mba");
        if (!child) {
-               node = of_parse_phandle(qproc->dev->of_node,
-                                       "memory-region", 0);
+               ret = of_reserved_mem_region_to_resource(qproc->dev->of_node, 0, &res);
        } else {
-               node = of_parse_phandle(child, "memory-region", 0);
+               ret = of_reserved_mem_region_to_resource(child, 0, &res);
                of_node_put(child);
        }
 
-       if (!node) {
-               dev_err(qproc->dev, "no mba memory-region specified\n");
-               return -EINVAL;
-       }
-
-       rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
-       if (!rmem) {
+       if (ret) {
                dev_err(qproc->dev, "unable to resolve mba region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       qproc->mba_phys = rmem->base;
-       qproc->mba_size = rmem->size;
+       qproc->mba_phys = res.start;
+       qproc->mba_size = resource_size(&res);
 
        if (!child) {
-               node = of_parse_phandle(qproc->dev->of_node,
-                                       "memory-region", 1);
+               ret = of_reserved_mem_region_to_resource(qproc->dev->of_node, 1, &res);
        } else {
                child = of_get_child_by_name(qproc->dev->of_node, "mpss");
-               node = of_parse_phandle(child, "memory-region", 0);
+               ret = of_reserved_mem_region_to_resource(child, 0, &res);
                of_node_put(child);
        }
 
-       if (!node) {
-               dev_err(qproc->dev, "no mpss memory-region specified\n");
-               return -EINVAL;
-       }
-
-       rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
-       if (!rmem) {
+       if (ret) {
                dev_err(qproc->dev, "unable to resolve mpss region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       qproc->mpss_phys = qproc->mpss_reloc = rmem->base;
-       qproc->mpss_size = rmem->size;
+       qproc->mpss_phys = qproc->mpss_reloc = res.start;
+       qproc->mpss_size = resource_size(&res);
 
        if (!child) {
-               node = of_parse_phandle(qproc->dev->of_node, "memory-region", 2);
+               ret = of_reserved_mem_region_to_resource(qproc->dev->of_node, 2, &res);
        } else {
                child = of_get_child_by_name(qproc->dev->of_node, "metadata");
-               node = of_parse_phandle(child, "memory-region", 0);
+               ret = of_reserved_mem_region_to_resource(child, 0, &res);
                of_node_put(child);
        }
 
-       if (!node)
+       if (ret)
                return 0;
 
-       rmem = of_reserved_mem_lookup(node);
-       if (!rmem) {
-               dev_err(qproc->dev, "unable to resolve metadata region\n");
-               return -EINVAL;
-       }
-
-       qproc->mdata_phys = rmem->base;
-       qproc->mdata_size = rmem->size;
+       qproc->mdata_phys = res.start;
+       qproc->mdata_size = resource_size(&res);
 
        return 0;
 }

diff --git a/drivers/remoteproc/qcom_q6v5_pas.c b/drivers/remoteproc/qcom_q6v5_pas.c
index 712bf3503e2b07abaeb1ab56a7dcc0734c0feca7..f7c2b04c115ae84aa87405478e2578823f3e48f0 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_pas.c
+++ b/drivers/remoteproc/qcom_q6v5_pas.c
@@ -547,53 +547,37 @@ static void qcom_pas_pds_detach(struct qcom_pas *pas, struct device **pds, size_
 
 static int qcom_pas_alloc_memory_region(struct qcom_pas *pas)
 {
-       struct reserved_mem *rmem;
-       struct device_node *node;
-
-       node = of_parse_phandle(pas->dev->of_node, "memory-region", 0);
-       if (!node) {
-               dev_err(pas->dev, "no memory-region specified\n");
-               return -EINVAL;
-       }
+       struct resource res;
+       int ret;
 
-       rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
-       if (!rmem) {
+       ret = of_reserved_mem_region_to_resource(pas->dev->of_node, 0, &res);
+       if (ret) {
                dev_err(pas->dev, "unable to resolve memory-region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       pas->mem_phys = pas->mem_reloc = rmem->base;
-       pas->mem_size = rmem->size;
-       pas->mem_region = devm_ioremap_wc(pas->dev, pas->mem_phys, pas->mem_size);
+       pas->mem_phys = pas->mem_reloc = res.start;
+       pas->mem_size = resource_size(&res);
+       pas->mem_region = devm_ioremap_resource_wc(pas->dev, &res);
        if (!pas->mem_region) {
-               dev_err(pas->dev, "unable to map memory region: %pa+%zx\n",
-                       &rmem->base, pas->mem_size);
+               dev_err(pas->dev, "unable to map memory region: %pR\n", &res);
                return -EBUSY;
        }
 
        if (!pas->dtb_pas_id)
                return 0;
 
-       node = of_parse_phandle(pas->dev->of_node, "memory-region", 1);
-       if (!node) {
-               dev_err(pas->dev, "no dtb memory-region specified\n");
-               return -EINVAL;
-       }
-
-       rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
-       if (!rmem) {
+       ret = of_reserved_mem_region_to_resource(pas->dev->of_node, 1, &res);
+       if (ret) {
                dev_err(pas->dev, "unable to resolve dtb memory-region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       pas->dtb_mem_phys = pas->dtb_mem_reloc = rmem->base;
-       pas->dtb_mem_size = rmem->size;
-       pas->dtb_mem_region = devm_ioremap_wc(pas->dev, pas->dtb_mem_phys, pas->dtb_mem_size);
+       pas->dtb_mem_phys = pas->dtb_mem_reloc = res.start;
+       pas->dtb_mem_size = resource_size(&res);
+       pas->dtb_mem_region = devm_ioremap_resource_wc(pas->dev, &res);
        if (!pas->dtb_mem_region) {
-               dev_err(pas->dev, "unable to map dtb memory region: %pa+%zx\n",
-                       &rmem->base, pas->dtb_mem_size);
+               dev_err(pas->dev, "unable to map dtb memory region: %pR\n", &res);
                return -EBUSY;
        }
 
@@ -603,7 +587,6 @@ static int qcom_pas_alloc_memory_region(struct qcom_pas *pas)
 static int qcom_pas_assign_memory_region(struct qcom_pas *pas)
 {
        struct qcom_scm_vmperm perm[MAX_ASSIGN_COUNT];
-       struct device_node *node;
        unsigned int perm_size;
        int offset;
        int ret;
@@ -612,17 +595,15 @@ static int qcom_pas_assign_memory_region(struct qcom_pas *pas)
                return 0;
 
        for (offset = 0; offset < pas->region_assign_count; ++offset) {
-               struct reserved_mem *rmem = NULL;
-
-               node = of_parse_phandle(pas->dev->of_node, "memory-region",
-                                       pas->region_assign_idx + offset);
-               if (node)
-                       rmem = of_reserved_mem_lookup(node);
-               of_node_put(node);
-               if (!rmem) {
+               struct resource res;
+
+               ret = of_reserved_mem_region_to_resource(pas->dev->of_node,
+                                                        pas->region_assign_idx + offset,
+                                                        &res);
+               if (ret) {
                        dev_err(pas->dev, "unable to resolve shareable memory-region index %d\n",
                                offset);
-                       return -EINVAL;
+                       return ret;
                }
 
                if (pas->region_assign_shared)  {
@@ -637,8 +618,8 @@ static int qcom_pas_assign_memory_region(struct qcom_pas *pas)
                        perm_size = 1;
                }
 
-               pas->region_assign_phys[offset] = rmem->base;
-               pas->region_assign_size[offset] = rmem->size;
+               pas->region_assign_phys[offset] = res.start;
+               pas->region_assign_size[offset] = resource_size(&res);
                pas->region_assign_owners[offset] = BIT(QCOM_SCM_VMID_HLOS);
 
                ret = qcom_scm_assign_mem(pas->region_assign_phys[offset],

diff --git a/drivers/remoteproc/qcom_q6v5_wcss.c b/drivers/remoteproc/qcom_q6v5_wcss.c
index 07c88623f597859302df5793f4614023663d1d98..ca748e3bcc7f9fc5cd9e36f6db8a61fd2eacf3b9 100644 (file)
--- a/drivers/remoteproc/qcom_q6v5_wcss.c
+++ b/drivers/remoteproc/qcom_q6v5_wcss.c
@@ -873,27 +873,22 @@ static int q6v5_wcss_init_mmio(struct q6v5_wcss *wcss,
 
 static int q6v5_alloc_memory_region(struct q6v5_wcss *wcss)
 {
-       struct reserved_mem *rmem = NULL;
-       struct device_node *node;
        struct device *dev = wcss->dev;
+       struct resource res;
+       int ret;
 
-       node = of_parse_phandle(dev->of_node, "memory-region", 0);
-       if (node)
-               rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
-
-       if (!rmem) {
+       ret = of_reserved_mem_region_to_resource(dev->of_node, 0, &res);
+       if (ret) {
                dev_err(dev, "unable to acquire memory-region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       wcss->mem_phys = rmem->base;
-       wcss->mem_reloc = rmem->base;
-       wcss->mem_size = rmem->size;
-       wcss->mem_region = devm_ioremap_wc(dev, wcss->mem_phys, wcss->mem_size);
+       wcss->mem_phys = res.start;
+       wcss->mem_reloc = res.start;
+       wcss->mem_size = resource_size(&res);
+       wcss->mem_region = devm_ioremap_resource_wc(dev, &res);
        if (!wcss->mem_region) {
-               dev_err(dev, "unable to map memory region: %pa+%pa\n",
-                       &rmem->base, &rmem->size);
+               dev_err(dev, "unable to map memory region: %pR\n", &res);
                return -EBUSY;
        }
 

diff --git a/drivers/remoteproc/qcom_wcnss.c b/drivers/remoteproc/qcom_wcnss.c
index 2c7e519a2254ba4bbeb9035c5947d55c3e090689..14005fb049a203616076e6cac8e1f8a71ebccf4e 100644 (file)
--- a/drivers/remoteproc/qcom_wcnss.c
+++ b/drivers/remoteproc/qcom_wcnss.c
@@ -526,25 +526,20 @@ static int wcnss_request_irq(struct qcom_wcnss *wcnss,
 
 static int wcnss_alloc_memory_region(struct qcom_wcnss *wcnss)
 {
-       struct reserved_mem *rmem = NULL;
-       struct device_node *node;
-
-       node = of_parse_phandle(wcnss->dev->of_node, "memory-region", 0);
-       if (node)
-               rmem = of_reserved_mem_lookup(node);
-       of_node_put(node);
+       struct resource res;
+       int ret;
 
-       if (!rmem) {
+       ret = of_reserved_mem_region_to_resource(wcnss->dev->of_node, 0, &res);
+       if (ret) {
                dev_err(wcnss->dev, "unable to resolve memory-region\n");
-               return -EINVAL;
+               return ret;
        }
 
-       wcnss->mem_phys = wcnss->mem_reloc = rmem->base;
-       wcnss->mem_size = rmem->size;
-       wcnss->mem_region = devm_ioremap_wc(wcnss->dev, wcnss->mem_phys, wcnss->mem_size);
+       wcnss->mem_phys = wcnss->mem_reloc = res.start;
+       wcnss->mem_size = resource_size(&res);
+       wcnss->mem_region = devm_ioremap_resource_wc(wcnss->dev, &res);
        if (!wcnss->mem_region) {
-               dev_err(wcnss->dev, "unable to map memory region: %pa+%zx\n",
-                       &rmem->base, wcnss->mem_size);
+               dev_err(wcnss->dev, "unable to map memory region: %pR\n", &res);
                return -EBUSY;
        }