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(ptr: p, retptr: &p); |
87 | if (*p != '@') |
88 | return 0; |
89 | base_cmdline = memparse(ptr: p + 1, retptr: &p); |
90 | if (*p != '-') { |
91 | limit_cmdline = base_cmdline + size_cmdline; |
92 | return 0; |
93 | } |
94 | limit_cmdline = memparse(ptr: p + 1, retptr: &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(ptr: s, retptr: &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(ptr: p, retptr: &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(buf: name, size: sizeof(name), fmt: "pernuma%d" , nid); |
184 | ret = cma_declare_contiguous_nid(base: 0, size: pernuma_size_bytes, limit: 0, alignment: 0, |
185 | order_per_bit: 0, fixed: false, name, res_cma: 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(buf: name, size: sizeof(name), fmt: "numa%d" , nid); |
195 | ret = cma_declare_contiguous_nid(base: 0, size: numa_cma_size[nid], limit: 0, alignment: 0, order_per_bit: 0, fixed: false, |
196 | name, res_cma: 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(size: selected_size, base: selected_base, |
252 | limit: selected_limit, |
253 | res_cma: &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, alignment: 0, order_per_bit: 0, fixed, |
287 | name: "reserved" , res_cma); |
288 | if (ret) |
289 | return ret; |
290 | |
291 | /* Architecture specific contiguous memory fixup. */ |
292 | dma_contiguous_early_fixup(base: cma_get_base(cma: *res_cma), |
293 | size: cma_get_size(cma: *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(cma: 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(cma: 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, count: size >> PAGE_SHIFT, align, no_warn: 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_flags: gfp)) |
365 | return NULL; |
366 | if (dev->cma_area) |
367 | return cma_alloc_aligned(cma: 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(cma: 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(cma: dev->cma_area, pages: 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(cma: dma_contiguous_pernuma_area[page_to_nid(page)], |
421 | pages: page, count)) |
422 | return; |
423 | if (cma_release(cma: dma_contiguous_numa_area[page_to_nid(page)], |
424 | pages: page, count)) |
425 | return; |
426 | #endif |
427 | if (cma_release(cma: dma_contiguous_default_area, pages: page, count)) |
428 | return; |
429 | } |
430 | |
431 | /* not in any cma, free from buddy */ |
432 | __free_pages(page, order: 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, name: "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, name: "reusable" , NULL) || |
477 | of_get_flat_dt_prop(node, name: "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(base: rmem->base, size: rmem->size, order_per_bit: 0, name: rmem->name, res_cma: &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(base: rmem->base, size: 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 |
506 | |