Rob Herring | af6074f | 2017-12-27 12:55:14 -0600 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 2 | /* |
| 3 | * Device tree based initialization code for reserved memory. |
| 4 | * |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 5 | * Copyright (c) 2013, 2015 The Linux Foundation. All Rights Reserved. |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 6 | * Copyright (c) 2013,2014 Samsung Electronics Co., Ltd. |
| 7 | * http://www.samsung.com |
| 8 | * Author: Marek Szyprowski <m.szyprowski@samsung.com> |
| 9 | * Author: Josh Cartwright <joshc@codeaurora.org> |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 10 | */ |
| 11 | |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 12 | #define pr_fmt(fmt) "OF: reserved mem: " fmt |
| 13 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 14 | #include <linux/err.h> |
Rob Herring | 54c180e | 2024-03-11 12:13:03 -0600 | [diff] [blame] | 15 | #include <linux/libfdt.h> |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 16 | #include <linux/of.h> |
| 17 | #include <linux/of_fdt.h> |
| 18 | #include <linux/of_platform.h> |
| 19 | #include <linux/mm.h> |
| 20 | #include <linux/sizes.h> |
| 21 | #include <linux/of_reserved_mem.h> |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 22 | #include <linux/sort.h> |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 23 | #include <linux/slab.h> |
Mike Rapoport | aca52c3 | 2018-10-30 15:07:44 -0700 | [diff] [blame] | 24 | #include <linux/memblock.h> |
Mike Rapoport | 658aafc | 2021-10-21 10:09:29 +0300 | [diff] [blame] | 25 | #include <linux/kmemleak.h> |
David Hildenbrand | e16faf2 | 2022-03-22 14:43:17 -0700 | [diff] [blame] | 26 | #include <linux/cma.h> |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 27 | |
Rob Herring | 12d55d3 | 2021-05-27 14:38:41 -0500 | [diff] [blame] | 28 | #include "of_private.h" |
| 29 | |
Patrick Daly | 632c990 | 2020-02-24 10:02:32 -0800 | [diff] [blame] | 30 | #define MAX_RESERVED_REGIONS 64 |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 31 | static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS]; |
| 32 | static int reserved_mem_count; |
| 33 | |
Christoph Hellwig | 221e1e0 | 2019-02-11 14:35:45 +0100 | [diff] [blame] | 34 | static int __init early_init_dt_alloc_reserved_memory_arch(phys_addr_t size, |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 35 | phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap, |
| 36 | phys_addr_t *res_base) |
| 37 | { |
Vinayak Menon | e53b50c | 2016-02-22 19:15:44 +0530 | [diff] [blame] | 38 | phys_addr_t base; |
Mike Rapoport | a7259df | 2021-09-02 15:00:26 -0700 | [diff] [blame] | 39 | int err = 0; |
Mike Rapoport | 42b46ae | 2019-03-11 23:29:31 -0700 | [diff] [blame] | 40 | |
Vinayak Menon | e53b50c | 2016-02-22 19:15:44 +0530 | [diff] [blame] | 41 | end = !end ? MEMBLOCK_ALLOC_ANYWHERE : end; |
Mike Rapoport | 7e1c4e2 | 2018-10-30 15:09:57 -0700 | [diff] [blame] | 42 | align = !align ? SMP_CACHE_BYTES : align; |
Mike Rapoport | a7259df | 2021-09-02 15:00:26 -0700 | [diff] [blame] | 43 | base = memblock_phys_alloc_range(size, align, start, end); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 44 | if (!base) |
| 45 | return -ENOMEM; |
| 46 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 47 | *res_base = base; |
Mike Rapoport | a7259df | 2021-09-02 15:00:26 -0700 | [diff] [blame] | 48 | if (nomap) { |
| 49 | err = memblock_mark_nomap(base, size); |
| 50 | if (err) |
Mike Rapoport | 3ecc683 | 2021-11-05 13:43:19 -0700 | [diff] [blame] | 51 | memblock_phys_free(base, size); |
Mike Rapoport | a7259df | 2021-09-02 15:00:26 -0700 | [diff] [blame] | 52 | } |
Mike Rapoport | 5c01a25 | 2019-03-11 23:30:58 -0700 | [diff] [blame] | 53 | |
Isaac J. Manjarres | ce4d9a1 | 2023-02-08 15:20:00 -0800 | [diff] [blame] | 54 | kmemleak_ignore_phys(base); |
| 55 | |
Mike Rapoport | a7259df | 2021-09-02 15:00:26 -0700 | [diff] [blame] | 56 | return err; |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 57 | } |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 58 | |
Lee Jones | ad1ce1a | 2021-03-18 10:40:36 +0000 | [diff] [blame] | 59 | /* |
chenqiwu | c8813f7 | 2020-05-11 23:04:57 +0800 | [diff] [blame] | 60 | * fdt_reserved_mem_save_node() - save fdt node for second pass initialization |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 61 | */ |
Rob Herring | 54c180e | 2024-03-11 12:13:03 -0600 | [diff] [blame] | 62 | static void __init fdt_reserved_mem_save_node(unsigned long node, const char *uname, |
| 63 | phys_addr_t base, phys_addr_t size) |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 64 | { |
| 65 | struct reserved_mem *rmem = &reserved_mem[reserved_mem_count]; |
| 66 | |
| 67 | if (reserved_mem_count == ARRAY_SIZE(reserved_mem)) { |
Danny Lin | 418370f | 2020-06-03 22:49:00 -0700 | [diff] [blame] | 68 | pr_err("not enough space for all defined regions.\n"); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 69 | return; |
| 70 | } |
| 71 | |
| 72 | rmem->fdt_node = node; |
| 73 | rmem->name = uname; |
| 74 | rmem->base = base; |
| 75 | rmem->size = size; |
| 76 | |
| 77 | reserved_mem_count++; |
| 78 | return; |
| 79 | } |
| 80 | |
Rob Herring | 54c180e | 2024-03-11 12:13:03 -0600 | [diff] [blame] | 81 | static int __init early_init_dt_reserve_memory(phys_addr_t base, |
| 82 | phys_addr_t size, bool nomap) |
| 83 | { |
| 84 | if (nomap) { |
| 85 | /* |
| 86 | * If the memory is already reserved (by another region), we |
| 87 | * should not allow it to be marked nomap, but don't worry |
| 88 | * if the region isn't memory as it won't be mapped. |
| 89 | */ |
| 90 | if (memblock_overlaps_region(&memblock.memory, base, size) && |
| 91 | memblock_is_region_reserved(base, size)) |
| 92 | return -EBUSY; |
| 93 | |
| 94 | return memblock_mark_nomap(base, size); |
| 95 | } |
| 96 | return memblock_reserve(base, size); |
| 97 | } |
| 98 | |
| 99 | /* |
| 100 | * __reserved_mem_reserve_reg() - reserve all memory described in 'reg' property |
| 101 | */ |
| 102 | static int __init __reserved_mem_reserve_reg(unsigned long node, |
| 103 | const char *uname) |
| 104 | { |
| 105 | int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32); |
| 106 | phys_addr_t base, size; |
| 107 | int len; |
| 108 | const __be32 *prop; |
| 109 | int first = 1; |
| 110 | bool nomap; |
| 111 | |
| 112 | prop = of_get_flat_dt_prop(node, "reg", &len); |
| 113 | if (!prop) |
| 114 | return -ENOENT; |
| 115 | |
| 116 | if (len && len % t_len != 0) { |
| 117 | pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n", |
| 118 | uname); |
| 119 | return -EINVAL; |
| 120 | } |
| 121 | |
| 122 | nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; |
| 123 | |
| 124 | while (len >= t_len) { |
| 125 | base = dt_mem_next_cell(dt_root_addr_cells, &prop); |
| 126 | size = dt_mem_next_cell(dt_root_size_cells, &prop); |
| 127 | |
| 128 | if (size && |
| 129 | early_init_dt_reserve_memory(base, size, nomap) == 0) |
| 130 | pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %lu MiB\n", |
| 131 | uname, &base, (unsigned long)(size / SZ_1M)); |
| 132 | else |
| 133 | pr_err("Reserved memory: failed to reserve memory for node '%s': base %pa, size %lu MiB\n", |
| 134 | uname, &base, (unsigned long)(size / SZ_1M)); |
| 135 | |
| 136 | len -= t_len; |
| 137 | if (first) { |
| 138 | fdt_reserved_mem_save_node(node, uname, base, size); |
| 139 | first = 0; |
| 140 | } |
| 141 | } |
| 142 | return 0; |
| 143 | } |
| 144 | |
| 145 | /* |
| 146 | * __reserved_mem_check_root() - check if #size-cells, #address-cells provided |
| 147 | * in /reserved-memory matches the values supported by the current implementation, |
| 148 | * also check if ranges property has been provided |
| 149 | */ |
| 150 | static int __init __reserved_mem_check_root(unsigned long node) |
| 151 | { |
| 152 | const __be32 *prop; |
| 153 | |
| 154 | prop = of_get_flat_dt_prop(node, "#size-cells", NULL); |
| 155 | if (!prop || be32_to_cpup(prop) != dt_root_size_cells) |
| 156 | return -EINVAL; |
| 157 | |
| 158 | prop = of_get_flat_dt_prop(node, "#address-cells", NULL); |
| 159 | if (!prop || be32_to_cpup(prop) != dt_root_addr_cells) |
| 160 | return -EINVAL; |
| 161 | |
| 162 | prop = of_get_flat_dt_prop(node, "ranges", NULL); |
| 163 | if (!prop) |
| 164 | return -EINVAL; |
| 165 | return 0; |
| 166 | } |
| 167 | |
| 168 | /* |
| 169 | * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory |
| 170 | */ |
| 171 | int __init fdt_scan_reserved_mem(void) |
| 172 | { |
| 173 | int node, child; |
| 174 | const void *fdt = initial_boot_params; |
| 175 | |
| 176 | node = fdt_path_offset(fdt, "/reserved-memory"); |
| 177 | if (node < 0) |
| 178 | return -ENODEV; |
| 179 | |
| 180 | if (__reserved_mem_check_root(node) != 0) { |
| 181 | pr_err("Reserved memory: unsupported node format, ignoring\n"); |
| 182 | return -EINVAL; |
| 183 | } |
| 184 | |
| 185 | fdt_for_each_subnode(child, fdt, node) { |
| 186 | const char *uname; |
| 187 | int err; |
| 188 | |
| 189 | if (!of_fdt_device_is_available(fdt, child)) |
| 190 | continue; |
| 191 | |
| 192 | uname = fdt_get_name(fdt, child, NULL); |
| 193 | |
| 194 | err = __reserved_mem_reserve_reg(child, uname); |
| 195 | if (err == -ENOENT && of_get_flat_dt_prop(child, "size", NULL)) |
| 196 | fdt_reserved_mem_save_node(child, uname, 0, 0); |
| 197 | } |
| 198 | return 0; |
| 199 | } |
| 200 | |
Lee Jones | ad1ce1a | 2021-03-18 10:40:36 +0000 | [diff] [blame] | 201 | /* |
Stephan Gerhold | 83ba736 | 2023-06-14 21:20:42 +0200 | [diff] [blame] | 202 | * __reserved_mem_alloc_in_range() - allocate reserved memory described with |
| 203 | * 'alloc-ranges'. Choose bottom-up/top-down depending on nearby existing |
| 204 | * reserved regions to keep the reserved memory contiguous if possible. |
| 205 | */ |
| 206 | static int __init __reserved_mem_alloc_in_range(phys_addr_t size, |
| 207 | phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap, |
| 208 | phys_addr_t *res_base) |
| 209 | { |
| 210 | bool prev_bottom_up = memblock_bottom_up(); |
| 211 | bool bottom_up = false, top_down = false; |
| 212 | int ret, i; |
| 213 | |
| 214 | for (i = 0; i < reserved_mem_count; i++) { |
| 215 | struct reserved_mem *rmem = &reserved_mem[i]; |
| 216 | |
| 217 | /* Skip regions that were not reserved yet */ |
| 218 | if (rmem->size == 0) |
| 219 | continue; |
| 220 | |
| 221 | /* |
| 222 | * If range starts next to an existing reservation, use bottom-up: |
| 223 | * |....RRRR................RRRRRRRR..............| |
| 224 | * --RRRR------ |
| 225 | */ |
| 226 | if (start >= rmem->base && start <= (rmem->base + rmem->size)) |
| 227 | bottom_up = true; |
| 228 | |
| 229 | /* |
| 230 | * If range ends next to an existing reservation, use top-down: |
| 231 | * |....RRRR................RRRRRRRR..............| |
| 232 | * -------RRRR----- |
| 233 | */ |
| 234 | if (end >= rmem->base && end <= (rmem->base + rmem->size)) |
| 235 | top_down = true; |
| 236 | } |
| 237 | |
| 238 | /* Change setting only if either bottom-up or top-down was selected */ |
| 239 | if (bottom_up != top_down) |
| 240 | memblock_set_bottom_up(bottom_up); |
| 241 | |
| 242 | ret = early_init_dt_alloc_reserved_memory_arch(size, align, |
| 243 | start, end, nomap, res_base); |
| 244 | |
| 245 | /* Restore old setting if needed */ |
| 246 | if (bottom_up != top_down) |
| 247 | memblock_set_bottom_up(prev_bottom_up); |
| 248 | |
| 249 | return ret; |
| 250 | } |
| 251 | |
| 252 | /* |
chenqiwu | c8813f7 | 2020-05-11 23:04:57 +0800 | [diff] [blame] | 253 | * __reserved_mem_alloc_size() - allocate reserved memory described by |
Yue Hu | 6f1188b | 2020-07-30 17:23:53 +0800 | [diff] [blame] | 254 | * 'size', 'alignment' and 'alloc-ranges' properties. |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 255 | */ |
| 256 | static int __init __reserved_mem_alloc_size(unsigned long node, |
| 257 | const char *uname, phys_addr_t *res_base, phys_addr_t *res_size) |
| 258 | { |
| 259 | int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32); |
| 260 | phys_addr_t start = 0, end = 0; |
| 261 | phys_addr_t base = 0, align = 0, size; |
Rob Herring | 9d0c4df | 2014-04-01 23:49:03 -0500 | [diff] [blame] | 262 | int len; |
| 263 | const __be32 *prop; |
Yue Hu | 6f1188b | 2020-07-30 17:23:53 +0800 | [diff] [blame] | 264 | bool nomap; |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 265 | int ret; |
| 266 | |
| 267 | prop = of_get_flat_dt_prop(node, "size", &len); |
| 268 | if (!prop) |
| 269 | return -EINVAL; |
| 270 | |
| 271 | if (len != dt_root_size_cells * sizeof(__be32)) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 272 | pr_err("invalid size property in '%s' node.\n", uname); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 273 | return -EINVAL; |
| 274 | } |
| 275 | size = dt_mem_next_cell(dt_root_size_cells, &prop); |
| 276 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 277 | prop = of_get_flat_dt_prop(node, "alignment", &len); |
| 278 | if (prop) { |
| 279 | if (len != dt_root_addr_cells * sizeof(__be32)) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 280 | pr_err("invalid alignment property in '%s' node.\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 281 | uname); |
| 282 | return -EINVAL; |
| 283 | } |
| 284 | align = dt_mem_next_cell(dt_root_addr_cells, &prop); |
| 285 | } |
| 286 | |
Yue Hu | 6f1188b | 2020-07-30 17:23:53 +0800 | [diff] [blame] | 287 | nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; |
| 288 | |
Jason Liu | 1cc8e34 | 2015-11-10 20:30:26 +0800 | [diff] [blame] | 289 | /* Need adjust the alignment to satisfy the CMA requirement */ |
Jaewon | 7d48281 | 2016-05-25 13:29:50 +0900 | [diff] [blame] | 290 | if (IS_ENABLED(CONFIG_CMA) |
| 291 | && of_flat_dt_is_compatible(node, "shared-dma-pool") |
| 292 | && of_get_flat_dt_prop(node, "reusable", NULL) |
David Hildenbrand | e16faf2 | 2022-03-22 14:43:17 -0700 | [diff] [blame] | 293 | && !nomap) |
| 294 | align = max_t(phys_addr_t, align, CMA_MIN_ALIGNMENT_BYTES); |
Jason Liu | 1cc8e34 | 2015-11-10 20:30:26 +0800 | [diff] [blame] | 295 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 296 | prop = of_get_flat_dt_prop(node, "alloc-ranges", &len); |
| 297 | if (prop) { |
| 298 | |
| 299 | if (len % t_len != 0) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 300 | pr_err("invalid alloc-ranges property in '%s', skipping node.\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 301 | uname); |
| 302 | return -EINVAL; |
| 303 | } |
| 304 | |
| 305 | base = 0; |
| 306 | |
| 307 | while (len > 0) { |
| 308 | start = dt_mem_next_cell(dt_root_addr_cells, &prop); |
| 309 | end = start + dt_mem_next_cell(dt_root_size_cells, |
| 310 | &prop); |
| 311 | |
Stephan Gerhold | 83ba736 | 2023-06-14 21:20:42 +0200 | [diff] [blame] | 312 | ret = __reserved_mem_alloc_in_range(size, align, |
| 313 | start, end, nomap, &base); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 314 | if (ret == 0) { |
Geert Uytterhoeven | 2892d8a | 2021-06-16 11:27:44 +0200 | [diff] [blame] | 315 | pr_debug("allocated memory for '%s' node: base %pa, size %lu MiB\n", |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 316 | uname, &base, |
Geert Uytterhoeven | 2892d8a | 2021-06-16 11:27:44 +0200 | [diff] [blame] | 317 | (unsigned long)(size / SZ_1M)); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 318 | break; |
| 319 | } |
| 320 | len -= t_len; |
| 321 | } |
| 322 | |
| 323 | } else { |
| 324 | ret = early_init_dt_alloc_reserved_memory_arch(size, align, |
| 325 | 0, 0, nomap, &base); |
| 326 | if (ret == 0) |
Geert Uytterhoeven | 2892d8a | 2021-06-16 11:27:44 +0200 | [diff] [blame] | 327 | pr_debug("allocated memory for '%s' node: base %pa, size %lu MiB\n", |
| 328 | uname, &base, (unsigned long)(size / SZ_1M)); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | if (base == 0) { |
Vincent Whitchurch | 6991cd7 | 2022-06-28 13:35:40 +0200 | [diff] [blame] | 332 | pr_err("failed to allocate memory for node '%s': size %lu MiB\n", |
| 333 | uname, (unsigned long)(size / SZ_1M)); |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 334 | return -ENOMEM; |
| 335 | } |
| 336 | |
| 337 | *res_base = base; |
| 338 | *res_size = size; |
| 339 | |
| 340 | return 0; |
| 341 | } |
| 342 | |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 343 | static const struct of_device_id __rmem_of_table_sentinel |
Joe Perches | 33def84 | 2020-10-21 19:36:07 -0700 | [diff] [blame] | 344 | __used __section("__reservedmem_of_table_end"); |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 345 | |
Lee Jones | ad1ce1a | 2021-03-18 10:40:36 +0000 | [diff] [blame] | 346 | /* |
chenqiwu | c8813f7 | 2020-05-11 23:04:57 +0800 | [diff] [blame] | 347 | * __reserved_mem_init_node() - call region specific reserved memory init code |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 348 | */ |
| 349 | static int __init __reserved_mem_init_node(struct reserved_mem *rmem) |
| 350 | { |
| 351 | extern const struct of_device_id __reservedmem_of_table[]; |
| 352 | const struct of_device_id *i; |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 353 | int ret = -ENOENT; |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 354 | |
| 355 | for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) { |
Rob Herring | df3ed93 | 2017-05-11 10:15:10 -0500 | [diff] [blame] | 356 | reservedmem_of_init_fn initfn = i->data; |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 357 | const char *compat = i->compatible; |
| 358 | |
| 359 | if (!of_flat_dt_is_compatible(rmem->fdt_node, compat)) |
| 360 | continue; |
| 361 | |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 362 | ret = initfn(rmem); |
| 363 | if (ret == 0) { |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 364 | pr_info("initialized node %s, compatible id %s\n", |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 365 | rmem->name, compat); |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 366 | break; |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 367 | } |
| 368 | } |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 369 | return ret; |
Marek Szyprowski | f618c47 | 2014-02-28 14:42:49 +0100 | [diff] [blame] | 370 | } |
| 371 | |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 372 | static int __init __rmem_cmp(const void *a, const void *b) |
| 373 | { |
| 374 | const struct reserved_mem *ra = a, *rb = b; |
| 375 | |
Michael Ellerman | 9eb8cd2 | 2015-11-18 21:46:38 +1100 | [diff] [blame] | 376 | if (ra->base < rb->base) |
| 377 | return -1; |
| 378 | |
| 379 | if (ra->base > rb->base) |
| 380 | return 1; |
| 381 | |
Vincent Whitchurch | ca05f33 | 2020-10-21 11:53:59 +0200 | [diff] [blame] | 382 | /* |
| 383 | * Put the dynamic allocations (address == 0, size == 0) before static |
| 384 | * allocations at address 0x0 so that overlap detection works |
| 385 | * correctly. |
| 386 | */ |
| 387 | if (ra->size < rb->size) |
| 388 | return -1; |
| 389 | if (ra->size > rb->size) |
| 390 | return 1; |
| 391 | |
Stephan Gerhold | 4cea282 | 2023-06-14 21:20:43 +0200 | [diff] [blame] | 392 | if (ra->fdt_node < rb->fdt_node) |
| 393 | return -1; |
| 394 | if (ra->fdt_node > rb->fdt_node) |
| 395 | return 1; |
| 396 | |
Michael Ellerman | 9eb8cd2 | 2015-11-18 21:46:38 +1100 | [diff] [blame] | 397 | return 0; |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 398 | } |
| 399 | |
| 400 | static void __init __rmem_check_for_overlap(void) |
| 401 | { |
| 402 | int i; |
| 403 | |
| 404 | if (reserved_mem_count < 2) |
| 405 | return; |
| 406 | |
| 407 | sort(reserved_mem, reserved_mem_count, sizeof(reserved_mem[0]), |
| 408 | __rmem_cmp, NULL); |
| 409 | for (i = 0; i < reserved_mem_count - 1; i++) { |
| 410 | struct reserved_mem *this, *next; |
| 411 | |
| 412 | this = &reserved_mem[i]; |
| 413 | next = &reserved_mem[i + 1]; |
Vincent Whitchurch | ca05f33 | 2020-10-21 11:53:59 +0200 | [diff] [blame] | 414 | |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 415 | if (this->base + this->size > next->base) { |
| 416 | phys_addr_t this_end, next_end; |
| 417 | |
| 418 | this_end = this->base + this->size; |
| 419 | next_end = next->base + next->size; |
Rob Herring | 606ad42 | 2016-06-15 08:32:18 -0500 | [diff] [blame] | 420 | pr_err("OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n", |
Michael Ellerman | 85a1c77 | 2015-11-10 16:08:33 +1100 | [diff] [blame] | 421 | this->name, &this->base, &this_end, |
| 422 | next->name, &next->base, &next_end); |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 423 | } |
| 424 | } |
| 425 | } |
| 426 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 427 | /** |
chenqiwu | c8813f7 | 2020-05-11 23:04:57 +0800 | [diff] [blame] | 428 | * fdt_init_reserved_mem() - allocate and init all saved reserved memory regions |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 429 | */ |
| 430 | void __init fdt_init_reserved_mem(void) |
| 431 | { |
| 432 | int i; |
Mitchel Humpherys | ae1add2 | 2015-09-15 18:30:36 -0700 | [diff] [blame] | 433 | |
| 434 | /* check for overlapping reserved regions */ |
| 435 | __rmem_check_for_overlap(); |
| 436 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 437 | for (i = 0; i < reserved_mem_count; i++) { |
| 438 | struct reserved_mem *rmem = &reserved_mem[i]; |
| 439 | unsigned long node = rmem->fdt_node; |
| 440 | int err = 0; |
Yue Hu | 6f1188b | 2020-07-30 17:23:53 +0800 | [diff] [blame] | 441 | bool nomap; |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 442 | |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 443 | nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 444 | |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 445 | if (rmem->size == 0) |
| 446 | err = __reserved_mem_alloc_size(node, rmem->name, |
| 447 | &rmem->base, &rmem->size); |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 448 | if (err == 0) { |
| 449 | err = __reserved_mem_init_node(rmem); |
| 450 | if (err != 0 && err != -ENOENT) { |
| 451 | pr_info("node %s compatible matching fail\n", |
| 452 | rmem->name); |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 453 | if (nomap) |
Dong Aisheng | 7b25995 | 2021-06-11 21:11:53 +0800 | [diff] [blame] | 454 | memblock_clear_nomap(rmem->base, rmem->size); |
Dong Aisheng | 3c6867a | 2021-06-11 21:11:52 +0800 | [diff] [blame] | 455 | else |
Mike Rapoport | 3ecc683 | 2021-11-05 13:43:19 -0700 | [diff] [blame] | 456 | memblock_phys_free(rmem->base, |
| 457 | rmem->size); |
Martin Liu | aeb9267 | 2023-02-10 00:09:55 +0800 | [diff] [blame] | 458 | } else { |
| 459 | phys_addr_t end = rmem->base + rmem->size - 1; |
| 460 | bool reusable = |
| 461 | (of_get_flat_dt_prop(node, "reusable", NULL)) != NULL; |
| 462 | |
Geert Uytterhoeven | 6ee7afb | 2023-02-16 09:37:25 +0100 | [diff] [blame] | 463 | pr_info("%pa..%pa (%lu KiB) %s %s %s\n", |
Martin Liu | aeb9267 | 2023-02-10 00:09:55 +0800 | [diff] [blame] | 464 | &rmem->base, &end, (unsigned long)(rmem->size / SZ_1K), |
| 465 | nomap ? "nomap" : "map", |
| 466 | reusable ? "reusable" : "non-reusable", |
| 467 | rmem->name ? rmem->name : "unknown"); |
pierre Kuo | d0b8ed4 | 2019-02-19 15:45:00 +0800 | [diff] [blame] | 468 | } |
| 469 | } |
Marek Szyprowski | 3f0c820 | 2014-02-28 14:42:48 +0100 | [diff] [blame] | 470 | } |
| 471 | } |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 472 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 473 | struct rmem_assigned_device { |
| 474 | struct device *dev; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 475 | struct reserved_mem *rmem; |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 476 | struct list_head list; |
| 477 | }; |
| 478 | |
| 479 | static LIST_HEAD(of_rmem_assigned_device_list); |
| 480 | static DEFINE_MUTEX(of_rmem_assigned_device_mutex); |
| 481 | |
| 482 | /** |
| 483 | * of_reserved_mem_device_init_by_idx() - assign reserved memory region to |
| 484 | * given device |
| 485 | * @dev: Pointer to the device to configure |
| 486 | * @np: Pointer to the device_node with 'reserved-memory' property |
| 487 | * @idx: Index of selected region |
| 488 | * |
| 489 | * This function assigns respective DMA-mapping operations based on reserved |
| 490 | * memory region specified by 'memory-region' property in @np node to the @dev |
| 491 | * device. When driver needs to use more than one reserved memory region, it |
| 492 | * should allocate child devices and initialize regions by name for each of |
| 493 | * child device. |
| 494 | * |
| 495 | * Returns error code or zero on success. |
| 496 | */ |
| 497 | int of_reserved_mem_device_init_by_idx(struct device *dev, |
| 498 | struct device_node *np, int idx) |
| 499 | { |
| 500 | struct rmem_assigned_device *rd; |
| 501 | struct device_node *target; |
| 502 | struct reserved_mem *rmem; |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 503 | int ret; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 504 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 505 | if (!np || !dev) |
| 506 | return -EINVAL; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 507 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 508 | target = of_parse_phandle(np, "memory-region", idx); |
| 509 | if (!target) |
Marek Szyprowski | 9f5a802 | 2016-06-08 03:51:53 -0300 | [diff] [blame] | 510 | return -ENODEV; |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 511 | |
Chris Goldsworthy | 5dba517 | 2019-10-19 18:57:24 -0700 | [diff] [blame] | 512 | if (!of_device_is_available(target)) { |
| 513 | of_node_put(target); |
Krishna Reddy | d698a38 | 2019-05-22 16:17:11 +0530 | [diff] [blame] | 514 | return 0; |
Chris Goldsworthy | 5dba517 | 2019-10-19 18:57:24 -0700 | [diff] [blame] | 515 | } |
Krishna Reddy | d698a38 | 2019-05-22 16:17:11 +0530 | [diff] [blame] | 516 | |
Oreoluwa Babatunde | c56436e | 2024-05-02 12:24:03 -0700 | [diff] [blame] | 517 | rmem = of_reserved_mem_lookup(target); |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 518 | of_node_put(target); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 519 | |
| 520 | if (!rmem || !rmem->ops || !rmem->ops->device_init) |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 521 | return -EINVAL; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 522 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 523 | rd = kmalloc(sizeof(struct rmem_assigned_device), GFP_KERNEL); |
| 524 | if (!rd) |
| 525 | return -ENOMEM; |
| 526 | |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 527 | ret = rmem->ops->device_init(rmem, dev); |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 528 | if (ret == 0) { |
| 529 | rd->dev = dev; |
| 530 | rd->rmem = rmem; |
| 531 | |
| 532 | mutex_lock(&of_rmem_assigned_device_mutex); |
| 533 | list_add(&rd->list, &of_rmem_assigned_device_list); |
| 534 | mutex_unlock(&of_rmem_assigned_device_mutex); |
| 535 | |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 536 | dev_info(dev, "assigned reserved memory node %s\n", rmem->name); |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 537 | } else { |
| 538 | kfree(rd); |
| 539 | } |
Marek Szyprowski | 47f29df | 2014-10-29 14:50:29 -0700 | [diff] [blame] | 540 | |
| 541 | return ret; |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 542 | } |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 543 | EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_idx); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 544 | |
| 545 | /** |
Thierry Reding | 0da0e31 | 2020-04-03 19:44:52 +0200 | [diff] [blame] | 546 | * of_reserved_mem_device_init_by_name() - assign named reserved memory region |
| 547 | * to given device |
| 548 | * @dev: pointer to the device to configure |
| 549 | * @np: pointer to the device node with 'memory-region' property |
| 550 | * @name: name of the selected memory region |
| 551 | * |
| 552 | * Returns: 0 on success or a negative error-code on failure. |
| 553 | */ |
| 554 | int of_reserved_mem_device_init_by_name(struct device *dev, |
| 555 | struct device_node *np, |
| 556 | const char *name) |
| 557 | { |
| 558 | int idx = of_property_match_string(np, "memory-region-names", name); |
| 559 | |
| 560 | return of_reserved_mem_device_init_by_idx(dev, np, idx); |
| 561 | } |
| 562 | EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_name); |
| 563 | |
| 564 | /** |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 565 | * of_reserved_mem_device_release() - release reserved memory device structures |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 566 | * @dev: Pointer to the device to deconfigure |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 567 | * |
| 568 | * This function releases structures allocated for memory region handling for |
| 569 | * the given device. |
| 570 | */ |
| 571 | void of_reserved_mem_device_release(struct device *dev) |
| 572 | { |
Thierry Reding | 081df76 | 2020-04-03 19:46:57 +0200 | [diff] [blame] | 573 | struct rmem_assigned_device *rd, *tmp; |
| 574 | LIST_HEAD(release_list); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 575 | |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 576 | mutex_lock(&of_rmem_assigned_device_mutex); |
Thierry Reding | 081df76 | 2020-04-03 19:46:57 +0200 | [diff] [blame] | 577 | list_for_each_entry_safe(rd, tmp, &of_rmem_assigned_device_list, list) { |
| 578 | if (rd->dev == dev) |
| 579 | list_move_tail(&rd->list, &release_list); |
Marek Szyprowski | 59ce403 | 2016-05-24 15:31:24 +0200 | [diff] [blame] | 580 | } |
| 581 | mutex_unlock(&of_rmem_assigned_device_mutex); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 582 | |
Thierry Reding | 081df76 | 2020-04-03 19:46:57 +0200 | [diff] [blame] | 583 | list_for_each_entry_safe(rd, tmp, &release_list, list) { |
| 584 | if (rd->rmem && rd->rmem->ops && rd->rmem->ops->device_release) |
| 585 | rd->rmem->ops->device_release(rd->rmem, dev); |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 586 | |
Thierry Reding | 081df76 | 2020-04-03 19:46:57 +0200 | [diff] [blame] | 587 | kfree(rd); |
| 588 | } |
Marek Szyprowski | 9dcfee0 | 2014-07-14 10:28:04 +0200 | [diff] [blame] | 589 | } |
George G. Davis | 615fde7 | 2015-01-09 09:29:05 -0500 | [diff] [blame] | 590 | EXPORT_SYMBOL_GPL(of_reserved_mem_device_release); |
Bjorn Andersson | eb297bc | 2017-10-10 22:08:54 -0700 | [diff] [blame] | 591 | |
| 592 | /** |
| 593 | * of_reserved_mem_lookup() - acquire reserved_mem from a device node |
| 594 | * @np: node pointer of the desired reserved-memory region |
| 595 | * |
| 596 | * This function allows drivers to acquire a reference to the reserved_mem |
| 597 | * struct based on a device node handle. |
| 598 | * |
| 599 | * Returns a reserved_mem reference, or NULL on error. |
| 600 | */ |
| 601 | struct reserved_mem *of_reserved_mem_lookup(struct device_node *np) |
| 602 | { |
| 603 | const char *name; |
| 604 | int i; |
| 605 | |
| 606 | if (!np->full_name) |
| 607 | return NULL; |
| 608 | |
| 609 | name = kbasename(np->full_name); |
| 610 | for (i = 0; i < reserved_mem_count; i++) |
| 611 | if (!strcmp(reserved_mem[i].name, name)) |
| 612 | return &reserved_mem[i]; |
| 613 | |
| 614 | return NULL; |
| 615 | } |
| 616 | EXPORT_SYMBOL_GPL(of_reserved_mem_lookup); |