dma-buf: heaps: cma: Create CMA heap for each CMA reserved region

Aside from the main CMA region, it can be useful to allow userspace to
allocate from the other CMA reserved regions.

Indeed, those regions can have specific properties that can be useful to
a specific us-case.

For example, one of them platform I've been with has ECC enabled on the
entire memory but for a specific region. Using that region to allocate
framebuffers can be particular beneficial because enabling the ECC has a
performance and memory footprint cost.

Thus, exposing these regions as heaps user-space can allocate from and
import wherever needed allows to cover that use-case.

For now, only shared-dma-pools regions with the reusable property (ie,
backed by CMA) are supported, but eventually we'll want to support other
DMA pools types.

Since we collected all the CMA regions created during boot, we can
simply iterate over all of them to create the heaps.

This has a weird interaction with the recent work on the CMA name, in
particular the backward compatibility code created by commit
854acbe75ff4 ("dma-buf: heaps: Give default CMA heap a fixed name").

Indeed, the old name was either 'reserved', or the name of the
reserved-memory region device tree node if the linux,cma-default
property was set.

In both these cases, we have now collected this region during boot, and
we're using the same name. So we're now largely redundant with the
code to handle backward compatibility code, and we can thus remove it
and the associated Kconfig option.

Reviewed-by: T.J. Mercier <tjmercier@google.com>
Signed-off-by: Maxime Ripard <mripard@kernel.org>
Signed-off-by: Sumit Semwal <sumit.semwal@linaro.org>
   [sumits: rebased the doc to latest]
Link: https://lore.kernel.org/r/20251013-dma-buf-ecc-heap-v8-5-04ce150ea3d9@kernel.org

diff --git a/Documentation/userspace-api/dma-buf-heaps.rst b/Documentation/userspace-api/dma-buf-heaps.rst
index 5d68cab9ef131c4f8fd5f0562d7439705ce85a2e..05445c83b79a0d669248d7e4ad2e937b8fae8673 100644 (file)
--- a/Documentation/userspace-api/dma-buf-heaps.rst
+++ b/Documentation/userspace-api/dma-buf-heaps.rst
@@ -24,9 +24,12 @@ following heaps:
    ``CMA_SIZE_MBYTES`` or ``CMA_SIZE_PERCENTAGE`` Kconfig options. Prior
    to Linux 6.17, its name wasn't stable and could be called
    ``reserved``, ``linux,cma``, or ``default-pool``, depending on the
-   platform. From Linux 6.17 onwards, the creation of these heaps is
-   controlled through the ``DMABUF_HEAPS_CMA_LEGACY`` Kconfig option for
-   backwards compatibility.
+   platform.
+
+ - A heap will be created for each reusable region in the device tree
+   with the ``shared-dma-pool`` compatible, using the full device tree
+   node name as its name. The buffer semantics are identical to
+   ``default-cma-region``.
 
 Naming Convention
 =================

diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig
index bb369b38b001af51721b56e065df92825022f1f1..a5eef06c422644e8aadaf5aff2bd9a33c49c1ba3 100644 (file)
--- a/drivers/dma-buf/heaps/Kconfig
+++ b/drivers/dma-buf/heaps/Kconfig
@@ -12,13 +12,3 @@ config DMABUF_HEAPS_CMA
          Choose this option to enable dma-buf CMA heap. This heap is backed
          by the Contiguous Memory Allocator (CMA). If your system has these
          regions, you should say Y here.
-
-config DMABUF_HEAPS_CMA_LEGACY
-       bool "Legacy DMA-BUF CMA Heap"
-       default y
-       depends on DMABUF_HEAPS_CMA
-       help
-         Add a duplicate CMA-backed dma-buf heap with legacy naming derived
-         from the CMA area's devicetree node, or "reserved" if the area is not
-         defined in the devicetree. This uses the same underlying allocator as
-         CONFIG_DMABUF_HEAPS_CMA.

diff --git a/drivers/dma-buf/heaps/cma_heap.c b/drivers/dma-buf/heaps/cma_heap.c
index 2a901af635ed76cdb085915c03258c235e302792..42f88193eab9f8f4571064c7b3b8a73bca20fdf4 100644 (file)
--- a/drivers/dma-buf/heaps/cma_heap.c
+++ b/drivers/dma-buf/heaps/cma_heap.c
@@ -22,6 +22,8 @@
 #include <linux/io.h>
 #include <linux/mm.h>
 #include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_reserved_mem.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
@@ -409,33 +411,30 @@ static int __init __add_cma_heap(struct cma *cma, const char *name)
        return 0;
 }
 
-static int __init add_default_cma_heap(void)
+static int __init add_cma_heaps(void)
 {
        struct cma *default_cma = dev_get_cma_area(NULL);
-       const char *legacy_cma_name;
+       unsigned int i;
        int ret;
 
-       if (!default_cma)
-               return 0;
+       if (default_cma) {
+               ret = __add_cma_heap(default_cma, DEFAULT_CMA_NAME);
+               if (ret)
+                       return ret;
+       }
 
-       ret = __add_cma_heap(default_cma, DEFAULT_CMA_NAME);
-       if (ret)
-               return ret;
+       for (i = 0; i < dma_areas_num; i++) {
+               struct cma *cma = dma_areas[i];
 
-       if (IS_ENABLED(CONFIG_DMABUF_HEAPS_CMA_LEGACY)) {
-               legacy_cma_name = cma_get_name(default_cma);
-               if (!strcmp(legacy_cma_name, DEFAULT_CMA_NAME)) {
-                       pr_warn("legacy name and default name are the same, skipping legacy heap\n");
-                       return 0;
+               ret = __add_cma_heap(cma, cma_get_name(cma));
+               if (ret) {
+                       pr_warn("Failed to add CMA heap %s", cma_get_name(cma));
+                       continue;
                }
 
-               ret = __add_cma_heap(default_cma, legacy_cma_name);
-               if (ret)
-                       pr_warn("failed to add legacy heap: %pe\n",
-                               ERR_PTR(ret));
        }
 
        return 0;
 }
-module_init(add_default_cma_heap);
+module_init(add_cma_heaps);
 MODULE_DESCRIPTION("DMA-BUF CMA Heap");