kernel/dma/contiguous.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Contiguous Memory Allocator for DMA mapping framework
   4  * Copyright (c) 2010-2011 by Samsung Electronics.
   5  * Written by:
   6  *      Marek Szyprowski <m.szyprowski@samsung.com>
   7  *      Michal Nazarewicz <mina86@mina86.com>
   8  *
   9  * Contiguous Memory Allocator
  10  *
  11  *   The Contiguous Memory Allocator (CMA) makes it possible to
  12  *   allocate big contiguous chunks of memory after the system has
  13  *   booted.
  14  *
  15  * Why is it needed?
  16  *
  17  *   Various devices on embedded systems have no scatter-getter and/or
  18  *   IO map support and require contiguous blocks of memory to
  19  *   operate.  They include devices such as cameras, hardware video
  20  *   coders, etc.
  21  *
  22  *   Such devices often require big memory buffers (a full HD frame
  23  *   is, for instance, more than 2 mega pixels large, i.e. more than 6
  24  *   MB of memory), which makes mechanisms such as kmalloc() or
  25  *   alloc_page() ineffective.
  26  *
  27  *   At the same time, a solution where a big memory region is
  28  *   reserved for a device is suboptimal since often more memory is
  29  *   reserved then strictly required and, moreover, the memory is
  30  *   inaccessible to page system even if device drivers don't use it.
  31  *
  32  *   CMA tries to solve this issue by operating on memory regions
  33  *   where only movable pages can be allocated from.  This way, kernel
  34  *   can use the memory for pagecache and when device driver requests
  35  *   it, allocated pages can be migrated.
  36  */
  37
  38 #define pr_fmt(fmt) "cma: " fmt
  39
  40 #ifdef CONFIG_CMA_DEBUG
  41 #ifndef DEBUG
  42 #  define DEBUG
  43 #endif
  44 #endif
  45
  46 #include <asm/page.h>
  47
  48 #include <linux/memblock.h>
  49 #include <linux/err.h>
  50 #include <linux/sizes.h>
  51 #include <linux/dma-map-ops.h>
  52 #include <linux/cma.h>
  53 #include <linux/nospec.h>
  54
  55 #ifdef CONFIG_CMA_SIZE_MBYTES
  56 #define CMA_SIZE_MBYTES CONFIG_CMA_SIZE_MBYTES
  57 #else
  58 #define CMA_SIZE_MBYTES 0
  59 #endif
  60
  61 struct cma *dma_contiguous_default_area;
  62
  63 /*
  64  * Default global CMA area size can be defined in kernel's .config.
  65  * This is useful mainly for distro maintainers to create a kernel
  66  * that works correctly for most supported systems.
  67  * The size can be set in bytes or as a percentage of the total memory
  68  * in the system.
  69  *
  70  * Users, who want to set the size of global CMA area for their system
  71  * should use cma= kernel parameter.
  72  */
  73 static const phys_addr_t size_bytes __initconst =
  74         (phys_addr_t)CMA_SIZE_MBYTES * SZ_1M;
  75 static phys_addr_t  size_cmdline __initdata = -1;
  76 static phys_addr_t base_cmdline __initdata;
  77 static phys_addr_t limit_cmdline __initdata;
  78
  79 static int __init early_cma(char *p)
  80 {
  81         if (!p) {
  82                 pr_err("Config string not provided\n");
  83                 return -EINVAL;
  84         }
  85
  86         size_cmdline = memparse(p, &p);
  87         if (*p != '@')
  88                 return 0;
  89         base_cmdline = memparse(p + 1, &p);
  90         if (*p != '-') {
  91                 limit_cmdline = base_cmdline + size_cmdline;
  92                 return 0;
  93         }
  94         limit_cmdline = memparse(p + 1, &p);
  95
  96         return 0;
  97 }
  98 early_param("cma", early_cma);
  99
 100 #ifdef CONFIG_DMA_NUMA_CMA
 101
 102 static struct cma *dma_contiguous_numa_area[MAX_NUMNODES];
 103 static phys_addr_t numa_cma_size[MAX_NUMNODES] __initdata;
 104 static struct cma *dma_contiguous_pernuma_area[MAX_NUMNODES];
 105 static phys_addr_t pernuma_size_bytes __initdata;
 106
 107 static int __init early_numa_cma(char *p)
 108 {
 109         int nid, count = 0;
 110         unsigned long tmp;
 111         char *s = p;
 112
 113         while (*s) {
 114                 if (sscanf(s, "%lu%n", &tmp, &count) != 1)
 115                         break;
 116
 117                 if (s[count] == ':') {
 118                         if (tmp >= MAX_NUMNODES)
 119                                 break;
 120                         nid = array_index_nospec(tmp, MAX_NUMNODES);
 121
 122                         s += count + 1;
 123                         tmp = memparse(s, &s);
 124                         numa_cma_size[nid] = tmp;
 125
 126                         if (*s == ',')
 127                                 s++;
 128                         else
 129                                 break;
 130                 } else
 131                         break;
 132         }
 133
 134         return 0;
 135 }
 136 early_param("numa_cma", early_numa_cma);
 137
 138 static int __init early_cma_pernuma(char *p)
 139 {
 140         pernuma_size_bytes = memparse(p, &p);
 141         return 0;
 142 }
 143 early_param("cma_pernuma", early_cma_pernuma);
 144 #endif
 145
 146 #ifdef CONFIG_CMA_SIZE_PERCENTAGE
 147
 148 static phys_addr_t __init __maybe_unused cma_early_percent_memory(void)
 149 {
 150         unsigned long total_pages = PHYS_PFN(memblock_phys_mem_size());
 151
 152         return (total_pages * CONFIG_CMA_SIZE_PERCENTAGE / 100) << PAGE_SHIFT;
 153 }
 154
 155 #else
 156
 157 static inline __maybe_unused phys_addr_t cma_early_percent_memory(void)
 158 {
 159         return 0;
 160 }
 161
 162 #endif
 163
 164 #ifdef CONFIG_DMA_NUMA_CMA
 165 static void __init dma_numa_cma_reserve(void)
 166 {
 167         int nid;
 168
 169         for_each_node(nid) {
 170                 int ret;
 171                 char name[CMA_MAX_NAME];
 172                 struct cma **cma;
 173
 174                 if (!node_online(nid)) {
 175                         if (pernuma_size_bytes || numa_cma_size[nid])
 176                                 pr_warn("invalid node %d specified\n", nid);
 177                         continue;
 178                 }
 179
 180                 if (pernuma_size_bytes) {
 181
 182                         cma = &dma_contiguous_pernuma_area[nid];
 183                         snprintf(name, sizeof(name), "pernuma%d", nid);
 184                         ret = cma_declare_contiguous_nid(0, pernuma_size_bytes, 0, 0,
 185                                                          0, false, name, cma, nid);
 186                         if (ret)
 187                                 pr_warn("%s: reservation failed: err %d, node %d", __func__,
 188                                         ret, nid);
 189                 }
 190
 191                 if (numa_cma_size[nid]) {
 192
 193                         cma = &dma_contiguous_numa_area[nid];
 194                         snprintf(name, sizeof(name), "numa%d", nid);
 195                         ret = cma_declare_contiguous_nid(0, numa_cma_size[nid], 0, 0, 0, false,
 196                                                          name, cma, nid);
 197                         if (ret)
 198                                 pr_warn("%s: reservation failed: err %d, node %d", __func__,
 199                                         ret, nid);
 200                 }
 201         }
 202 }
 203 #else
 204 static inline void __init dma_numa_cma_reserve(void)
 205 {
 206 }
 207 #endif
 208
 209 /**
 210  * dma_contiguous_reserve() - reserve area(s) for contiguous memory handling
 211  * @limit: End address of the reserved memory (optional, 0 for any).
 212  *
 213  * This function reserves memory from early allocator. It should be
 214  * called by arch specific code once the early allocator (memblock or bootmem)
 215  * has been activated and all other subsystems have already allocated/reserved
 216  * memory.
 217  */
 218 void __init dma_contiguous_reserve(phys_addr_t limit)
 219 {
 220         phys_addr_t selected_size = 0;
 221         phys_addr_t selected_base = 0;
 222         phys_addr_t selected_limit = limit;
 223         bool fixed = false;
 224
 225         dma_numa_cma_reserve();
 226
 227         pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit);
 228
 229         if (size_cmdline != -1) {
 230                 selected_size = size_cmdline;
 231                 selected_base = base_cmdline;
 232                 selected_limit = min_not_zero(limit_cmdline, limit);
 233                 if (base_cmdline + size_cmdline == limit_cmdline)
 234                         fixed = true;
 235         } else {
 236 #ifdef CONFIG_CMA_SIZE_SEL_MBYTES
 237                 selected_size = size_bytes;
 238 #elif defined(CONFIG_CMA_SIZE_SEL_PERCENTAGE)
 239                 selected_size = cma_early_percent_memory();
 240 #elif defined(CONFIG_CMA_SIZE_SEL_MIN)
 241                 selected_size = min(size_bytes, cma_early_percent_memory());
 242 #elif defined(CONFIG_CMA_SIZE_SEL_MAX)
 243                 selected_size = max(size_bytes, cma_early_percent_memory());
 244 #endif
 245         }
 246
 247         if (selected_size && !dma_contiguous_default_area) {
 248                 pr_debug("%s: reserving %ld MiB for global area\n", __func__,
 249                          (unsigned long)selected_size / SZ_1M);
 250
 251                 dma_contiguous_reserve_area(selected_size, selected_base,
 252                                             selected_limit,
 253                                             &dma_contiguous_default_area,
 254                                             fixed);
 255         }
 256 }
 257
 258 void __weak
 259 dma_contiguous_early_fixup(phys_addr_t base, unsigned long size)
 260 {
 261 }
 262
 263 /**
 264  * dma_contiguous_reserve_area() - reserve custom contiguous area
 265  * @size: Size of the reserved area (in bytes),
 266  * @base: Base address of the reserved area optional, use 0 for any
 267  * @limit: End address of the reserved memory (optional, 0 for any).
 268  * @res_cma: Pointer to store the created cma region.
 269  * @fixed: hint about where to place the reserved area
 270  *
 271  * This function reserves memory from early allocator. It should be
 272  * called by arch specific code once the early allocator (memblock or bootmem)
 273  * has been activated and all other subsystems have already allocated/reserved
 274  * memory. This function allows to create custom reserved areas for specific
 275  * devices.
 276  *
 277  * If @fixed is true, reserve contiguous area at exactly @base.  If false,
 278  * reserve in range from @base to @limit.
 279  */
 280 int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base,
 281                                        phys_addr_t limit, struct cma **res_cma,
 282                                        bool fixed)
 283 {
 284         int ret;
 285
 286         ret = cma_declare_contiguous(base, size, limit, 0, 0, fixed,
 287                                         "reserved", res_cma);
 288         if (ret)
 289                 return ret;
 290
 291         /* Architecture specific contiguous memory fixup. */
 292         dma_contiguous_early_fixup(cma_get_base(*res_cma),
 293                                 cma_get_size(*res_cma));
 294
 295         return 0;
 296 }
 297
 298 /**
 299  * dma_alloc_from_contiguous() - allocate pages from contiguous area
 300  * @dev:   Pointer to device for which the allocation is performed.
 301  * @count: Requested number of pages.
 302  * @align: Requested alignment of pages (in PAGE_SIZE order).
 303  * @no_warn: Avoid printing message about failed allocation.
 304  *
 305  * This function allocates memory buffer for specified device. It uses
 306  * device specific contiguous memory area if available or the default
 307  * global one. Requires architecture specific dev_get_cma_area() helper
 308  * function.
 309  */
 310 struct page *dma_alloc_from_contiguous(struct device *dev, size_t count,
 311                                        unsigned int align, bool no_warn)
 312 {
 313         if (align > CONFIG_CMA_ALIGNMENT)
 314                 align = CONFIG_CMA_ALIGNMENT;
 315
 316         return cma_alloc(dev_get_cma_area(dev), count, align, no_warn);
 317 }
 318
 319 /**
 320  * dma_release_from_contiguous() - release allocated pages
 321  * @dev:   Pointer to device for which the pages were allocated.
 322  * @pages: Allocated pages.
 323  * @count: Number of allocated pages.
 324  *
 325  * This function releases memory allocated by dma_alloc_from_contiguous().
 326  * It returns false when provided pages do not belong to contiguous area and
 327  * true otherwise.
 328  */
 329 bool dma_release_from_contiguous(struct device *dev, struct page *pages,
 330                                  int count)
 331 {
 332         return cma_release(dev_get_cma_area(dev), pages, count);
 333 }
 334
 335 static struct page *cma_alloc_aligned(struct cma *cma, size_t size, gfp_t gfp)
 336 {
 337         unsigned int align = min(get_order(size), CONFIG_CMA_ALIGNMENT);
 338
 339         return cma_alloc(cma, size >> PAGE_SHIFT, align, gfp & __GFP_NOWARN);
 340 }
 341
 342 /**
 343  * dma_alloc_contiguous() - allocate contiguous pages
 344  * @dev:   Pointer to device for which the allocation is performed.
 345  * @size:  Requested allocation size.
 346  * @gfp:   Allocation flags.
 347  *
 348  * tries to use device specific contiguous memory area if available, or it
 349  * tries to use per-numa cma, if the allocation fails, it will fallback to
 350  * try default global one.
 351  *
 352  * Note that it bypass one-page size of allocations from the per-numa and
 353  * global area as the addresses within one page are always contiguous, so
 354  * there is no need to waste CMA pages for that kind; it also helps reduce
 355  * fragmentations.
 356  */
 357 struct page *dma_alloc_contiguous(struct device *dev, size_t size, gfp_t gfp)
 358 {
 359 #ifdef CONFIG_DMA_NUMA_CMA
 360         int nid = dev_to_node(dev);
 361 #endif
 362
 363         /* CMA can be used only in the context which permits sleeping */
 364         if (!gfpflags_allow_blocking(gfp))
 365                 return NULL;
 366         if (dev->cma_area)
 367                 return cma_alloc_aligned(dev->cma_area, size, gfp);
 368         if (size <= PAGE_SIZE)
 369                 return NULL;
 370
 371 #ifdef CONFIG_DMA_NUMA_CMA
 372         if (nid != NUMA_NO_NODE && !(gfp & (GFP_DMA | GFP_DMA32))) {
 373                 struct cma *cma = dma_contiguous_pernuma_area[nid];
 374                 struct page *page;
 375
 376                 if (cma) {
 377                         page = cma_alloc_aligned(cma, size, gfp);
 378                         if (page)
 379                                 return page;
 380                 }
 381
 382                 cma = dma_contiguous_numa_area[nid];
 383                 if (cma) {
 384                         page = cma_alloc_aligned(cma, size, gfp);
 385                         if (page)
 386                                 return page;
 387                 }
 388         }
 389 #endif
 390         if (!dma_contiguous_default_area)
 391                 return NULL;
 392
 393         return cma_alloc_aligned(dma_contiguous_default_area, size, gfp);
 394 }
 395
 396 /**
 397  * dma_free_contiguous() - release allocated pages
 398  * @dev:   Pointer to device for which the pages were allocated.
 399  * @page:  Pointer to the allocated pages.
 400  * @size:  Size of allocated pages.
 401  *
 402  * This function releases memory allocated by dma_alloc_contiguous(). As the
 403  * cma_release returns false when provided pages do not belong to contiguous
 404  * area and true otherwise, this function then does a fallback __free_pages()
 405  * upon a false-return.
 406  */
 407 void dma_free_contiguous(struct device *dev, struct page *page, size_t size)
 408 {
 409         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
 410
 411         /* if dev has its own cma, free page from there */
 412         if (dev->cma_area) {
 413                 if (cma_release(dev->cma_area, page, count))
 414                         return;
 415         } else {
 416                 /*
 417                  * otherwise, page is from either per-numa cma or default cma
 418                  */
 419 #ifdef CONFIG_DMA_NUMA_CMA
 420                 if (cma_release(dma_contiguous_pernuma_area[page_to_nid(page)],
 421                                         page, count))
 422                         return;
 423                 if (cma_release(dma_contiguous_numa_area[page_to_nid(page)],
 424                                         page, count))
 425                         return;
 426 #endif
 427                 if (cma_release(dma_contiguous_default_area, page, count))
 428                         return;
 429         }
 430
 431         /* not in any cma, free from buddy */
 432         __free_pages(page, get_order(size));
 433 }
 434
 435 /*
 436  * Support for reserved memory regions defined in device tree
 437  */
 438 #ifdef CONFIG_OF_RESERVED_MEM
 439 #include <linux/of.h>
 440 #include <linux/of_fdt.h>
 441 #include <linux/of_reserved_mem.h>
 442
 443 #undef pr_fmt
 444 #define pr_fmt(fmt) fmt
 445
 446 static int rmem_cma_device_init(struct reserved_mem *rmem, struct device *dev)
 447 {
 448         dev->cma_area = rmem->priv;
 449         return 0;
 450 }
 451
 452 static void rmem_cma_device_release(struct reserved_mem *rmem,
 453                                     struct device *dev)
 454 {
 455         dev->cma_area = NULL;
 456 }
 457
 458 static const struct reserved_mem_ops rmem_cma_ops = {
 459         .device_init    = rmem_cma_device_init,
 460         .device_release = rmem_cma_device_release,
 461 };
 462
 463 static int __init rmem_cma_setup(struct reserved_mem *rmem)
 464 {
 465         unsigned long node = rmem->fdt_node;
 466         bool default_cma = of_get_flat_dt_prop(node, "linux,cma-default", NULL);
 467         struct cma *cma;
 468         int err;
 469
 470         if (size_cmdline != -1 && default_cma) {
 471                 pr_info("Reserved memory: bypass %s node, using cmdline CMA params instead\n",
 472                         rmem->name);
 473                 return -EBUSY;
 474         }
 475
 476         if (!of_get_flat_dt_prop(node, "reusable", NULL) ||
 477             of_get_flat_dt_prop(node, "no-map", NULL))
 478                 return -EINVAL;
 479
 480         if (!IS_ALIGNED(rmem->base | rmem->size, CMA_MIN_ALIGNMENT_BYTES)) {
 481                 pr_err("Reserved memory: incorrect alignment of CMA region\n");
 482                 return -EINVAL;
 483         }
 484
 485         err = cma_init_reserved_mem(rmem->base, rmem->size, 0, rmem->name, &cma);
 486         if (err) {
 487                 pr_err("Reserved memory: unable to setup CMA region\n");
 488                 return err;
 489         }
 490         /* Architecture specific contiguous memory fixup. */
 491         dma_contiguous_early_fixup(rmem->base, rmem->size);
 492
 493         if (default_cma)
 494                 dma_contiguous_default_area = cma;
 495
 496         rmem->ops = &rmem_cma_ops;
 497         rmem->priv = cma;
 498
 499         pr_info("Reserved memory: created CMA memory pool at %pa, size %ld MiB\n",
 500                 &rmem->base, (unsigned long)rmem->size / SZ_1M);
 501
 502         return 0;
 503 }
 504 RESERVEDMEM_OF_DECLARE(cma, "shared-dma-pool", rmem_cma_setup);
 505 #endif