1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Device tree based initialization code for reserved memory. 4 * 5 * Copyright (c) 2013, 2015 The Linux Foundation. All Rights Reserved. 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> 10 */ 11 12 #define pr_fmt(fmt) "OF: reserved mem: " fmt 13 14 #include <linux/err.h> 15 #include <linux/of.h> 16 #include <linux/of_fdt.h> 17 #include <linux/of_platform.h> 18 #include <linux/mm.h> 19 #include <linux/sizes.h> 20 #include <linux/of_reserved_mem.h> 21 #include <linux/sort.h> 22 #include <linux/slab.h> 23 #include <linux/memblock.h> 24 25 #define MAX_RESERVED_REGIONS 64 26 static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS]; 27 static int reserved_mem_count; 28 29 static int __init early_init_dt_alloc_reserved_memory_arch(phys_addr_t size, 30 phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap, 31 phys_addr_t *res_base) 32 { 33 phys_addr_t base; 34 35 end = !end ? MEMBLOCK_ALLOC_ANYWHERE : end; 36 align = !align ? SMP_CACHE_BYTES : align; 37 base = memblock_find_in_range(start, end, size, align); 38 if (!base) 39 return -ENOMEM; 40 41 *res_base = base; 42 if (nomap) 43 return memblock_remove(base, size); 44 45 return memblock_reserve(base, size); 46 } 47 48 /** 49 * fdt_reserved_mem_save_node() - save fdt node for second pass initialization 50 */ 51 void __init fdt_reserved_mem_save_node(unsigned long node, const char *uname, 52 phys_addr_t base, phys_addr_t size) 53 { 54 struct reserved_mem *rmem = &reserved_mem[reserved_mem_count]; 55 56 if (reserved_mem_count == ARRAY_SIZE(reserved_mem)) { 57 pr_err("not enough space for all defined regions.\n"); 58 return; 59 } 60 61 rmem->fdt_node = node; 62 rmem->name = uname; 63 rmem->base = base; 64 rmem->size = size; 65 66 reserved_mem_count++; 67 return; 68 } 69 70 /** 71 * __reserved_mem_alloc_size() - allocate reserved memory described by 72 * 'size', 'alignment' and 'alloc-ranges' properties. 73 */ 74 static int __init __reserved_mem_alloc_size(unsigned long node, 75 const char *uname, phys_addr_t *res_base, phys_addr_t *res_size) 76 { 77 int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32); 78 phys_addr_t start = 0, end = 0; 79 phys_addr_t base = 0, align = 0, size; 80 int len; 81 const __be32 *prop; 82 bool nomap; 83 int ret; 84 85 prop = of_get_flat_dt_prop(node, "size", &len); 86 if (!prop) 87 return -EINVAL; 88 89 if (len != dt_root_size_cells * sizeof(__be32)) { 90 pr_err("invalid size property in '%s' node.\n", uname); 91 return -EINVAL; 92 } 93 size = dt_mem_next_cell(dt_root_size_cells, &prop); 94 95 prop = of_get_flat_dt_prop(node, "alignment", &len); 96 if (prop) { 97 if (len != dt_root_addr_cells * sizeof(__be32)) { 98 pr_err("invalid alignment property in '%s' node.\n", 99 uname); 100 return -EINVAL; 101 } 102 align = dt_mem_next_cell(dt_root_addr_cells, &prop); 103 } 104 105 nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; 106 107 /* Need adjust the alignment to satisfy the CMA requirement */ 108 if (IS_ENABLED(CONFIG_CMA) 109 && of_flat_dt_is_compatible(node, "shared-dma-pool") 110 && of_get_flat_dt_prop(node, "reusable", NULL) 111 && !nomap) { 112 unsigned long order = 113 max_t(unsigned long, MAX_ORDER - 1, pageblock_order); 114 115 align = max(align, (phys_addr_t)PAGE_SIZE << order); 116 } 117 118 prop = of_get_flat_dt_prop(node, "alloc-ranges", &len); 119 if (prop) { 120 121 if (len % t_len != 0) { 122 pr_err("invalid alloc-ranges property in '%s', skipping node.\n", 123 uname); 124 return -EINVAL; 125 } 126 127 base = 0; 128 129 while (len > 0) { 130 start = dt_mem_next_cell(dt_root_addr_cells, &prop); 131 end = start + dt_mem_next_cell(dt_root_size_cells, 132 &prop); 133 134 ret = early_init_dt_alloc_reserved_memory_arch(size, 135 align, start, end, nomap, &base); 136 if (ret == 0) { 137 pr_debug("allocated memory for '%s' node: base %pa, size %ld MiB\n", 138 uname, &base, 139 (unsigned long)size / SZ_1M); 140 break; 141 } 142 len -= t_len; 143 } 144 145 } else { 146 ret = early_init_dt_alloc_reserved_memory_arch(size, align, 147 0, 0, nomap, &base); 148 if (ret == 0) 149 pr_debug("allocated memory for '%s' node: base %pa, size %ld MiB\n", 150 uname, &base, (unsigned long)size / SZ_1M); 151 } 152 153 if (base == 0) { 154 pr_info("failed to allocate memory for node '%s'\n", uname); 155 return -ENOMEM; 156 } 157 158 *res_base = base; 159 *res_size = size; 160 161 return 0; 162 } 163 164 static const struct of_device_id __rmem_of_table_sentinel 165 __used __section(__reservedmem_of_table_end); 166 167 /** 168 * __reserved_mem_init_node() - call region specific reserved memory init code 169 */ 170 static int __init __reserved_mem_init_node(struct reserved_mem *rmem) 171 { 172 extern const struct of_device_id __reservedmem_of_table[]; 173 const struct of_device_id *i; 174 int ret = -ENOENT; 175 176 for (i = __reservedmem_of_table; i < &__rmem_of_table_sentinel; i++) { 177 reservedmem_of_init_fn initfn = i->data; 178 const char *compat = i->compatible; 179 180 if (!of_flat_dt_is_compatible(rmem->fdt_node, compat)) 181 continue; 182 183 ret = initfn(rmem); 184 if (ret == 0) { 185 pr_info("initialized node %s, compatible id %s\n", 186 rmem->name, compat); 187 break; 188 } 189 } 190 return ret; 191 } 192 193 static int __init __rmem_cmp(const void *a, const void *b) 194 { 195 const struct reserved_mem *ra = a, *rb = b; 196 197 if (ra->base < rb->base) 198 return -1; 199 200 if (ra->base > rb->base) 201 return 1; 202 203 return 0; 204 } 205 206 static void __init __rmem_check_for_overlap(void) 207 { 208 int i; 209 210 if (reserved_mem_count < 2) 211 return; 212 213 sort(reserved_mem, reserved_mem_count, sizeof(reserved_mem[0]), 214 __rmem_cmp, NULL); 215 for (i = 0; i < reserved_mem_count - 1; i++) { 216 struct reserved_mem *this, *next; 217 218 this = &reserved_mem[i]; 219 next = &reserved_mem[i + 1]; 220 if (!(this->base && next->base)) 221 continue; 222 if (this->base + this->size > next->base) { 223 phys_addr_t this_end, next_end; 224 225 this_end = this->base + this->size; 226 next_end = next->base + next->size; 227 pr_err("OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n", 228 this->name, &this->base, &this_end, 229 next->name, &next->base, &next_end); 230 } 231 } 232 } 233 234 /** 235 * fdt_init_reserved_mem() - allocate and init all saved reserved memory regions 236 */ 237 void __init fdt_init_reserved_mem(void) 238 { 239 int i; 240 241 /* check for overlapping reserved regions */ 242 __rmem_check_for_overlap(); 243 244 for (i = 0; i < reserved_mem_count; i++) { 245 struct reserved_mem *rmem = &reserved_mem[i]; 246 unsigned long node = rmem->fdt_node; 247 int len; 248 const __be32 *prop; 249 int err = 0; 250 bool nomap; 251 252 nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; 253 prop = of_get_flat_dt_prop(node, "phandle", &len); 254 if (!prop) 255 prop = of_get_flat_dt_prop(node, "linux,phandle", &len); 256 if (prop) 257 rmem->phandle = of_read_number(prop, len/4); 258 259 if (rmem->size == 0) 260 err = __reserved_mem_alloc_size(node, rmem->name, 261 &rmem->base, &rmem->size); 262 if (err == 0) { 263 err = __reserved_mem_init_node(rmem); 264 if (err != 0 && err != -ENOENT) { 265 pr_info("node %s compatible matching fail\n", 266 rmem->name); 267 memblock_free(rmem->base, rmem->size); 268 if (nomap) 269 memblock_add(rmem->base, rmem->size); 270 } 271 } 272 } 273 } 274 275 static inline struct reserved_mem *__find_rmem(struct device_node *node) 276 { 277 unsigned int i; 278 279 if (!node->phandle) 280 return NULL; 281 282 for (i = 0; i < reserved_mem_count; i++) 283 if (reserved_mem[i].phandle == node->phandle) 284 return &reserved_mem[i]; 285 return NULL; 286 } 287 288 struct rmem_assigned_device { 289 struct device *dev; 290 struct reserved_mem *rmem; 291 struct list_head list; 292 }; 293 294 static LIST_HEAD(of_rmem_assigned_device_list); 295 static DEFINE_MUTEX(of_rmem_assigned_device_mutex); 296 297 /** 298 * of_reserved_mem_device_init_by_idx() - assign reserved memory region to 299 * given device 300 * @dev: Pointer to the device to configure 301 * @np: Pointer to the device_node with 'reserved-memory' property 302 * @idx: Index of selected region 303 * 304 * This function assigns respective DMA-mapping operations based on reserved 305 * memory region specified by 'memory-region' property in @np node to the @dev 306 * device. When driver needs to use more than one reserved memory region, it 307 * should allocate child devices and initialize regions by name for each of 308 * child device. 309 * 310 * Returns error code or zero on success. 311 */ 312 int of_reserved_mem_device_init_by_idx(struct device *dev, 313 struct device_node *np, int idx) 314 { 315 struct rmem_assigned_device *rd; 316 struct device_node *target; 317 struct reserved_mem *rmem; 318 int ret; 319 320 if (!np || !dev) 321 return -EINVAL; 322 323 target = of_parse_phandle(np, "memory-region", idx); 324 if (!target) 325 return -ENODEV; 326 327 if (!of_device_is_available(target)) { 328 of_node_put(target); 329 return 0; 330 } 331 332 rmem = __find_rmem(target); 333 of_node_put(target); 334 335 if (!rmem || !rmem->ops || !rmem->ops->device_init) 336 return -EINVAL; 337 338 rd = kmalloc(sizeof(struct rmem_assigned_device), GFP_KERNEL); 339 if (!rd) 340 return -ENOMEM; 341 342 ret = rmem->ops->device_init(rmem, dev); 343 if (ret == 0) { 344 rd->dev = dev; 345 rd->rmem = rmem; 346 347 mutex_lock(&of_rmem_assigned_device_mutex); 348 list_add(&rd->list, &of_rmem_assigned_device_list); 349 mutex_unlock(&of_rmem_assigned_device_mutex); 350 351 dev_info(dev, "assigned reserved memory node %s\n", rmem->name); 352 } else { 353 kfree(rd); 354 } 355 356 return ret; 357 } 358 EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_idx); 359 360 /** 361 * of_reserved_mem_device_init_by_name() - assign named reserved memory region 362 * to given device 363 * @dev: pointer to the device to configure 364 * @np: pointer to the device node with 'memory-region' property 365 * @name: name of the selected memory region 366 * 367 * Returns: 0 on success or a negative error-code on failure. 368 */ 369 int of_reserved_mem_device_init_by_name(struct device *dev, 370 struct device_node *np, 371 const char *name) 372 { 373 int idx = of_property_match_string(np, "memory-region-names", name); 374 375 return of_reserved_mem_device_init_by_idx(dev, np, idx); 376 } 377 EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_name); 378 379 /** 380 * of_reserved_mem_device_release() - release reserved memory device structures 381 * @dev: Pointer to the device to deconfigure 382 * 383 * This function releases structures allocated for memory region handling for 384 * the given device. 385 */ 386 void of_reserved_mem_device_release(struct device *dev) 387 { 388 struct rmem_assigned_device *rd, *tmp; 389 LIST_HEAD(release_list); 390 391 mutex_lock(&of_rmem_assigned_device_mutex); 392 list_for_each_entry_safe(rd, tmp, &of_rmem_assigned_device_list, list) { 393 if (rd->dev == dev) 394 list_move_tail(&rd->list, &release_list); 395 } 396 mutex_unlock(&of_rmem_assigned_device_mutex); 397 398 list_for_each_entry_safe(rd, tmp, &release_list, list) { 399 if (rd->rmem && rd->rmem->ops && rd->rmem->ops->device_release) 400 rd->rmem->ops->device_release(rd->rmem, dev); 401 402 kfree(rd); 403 } 404 } 405 EXPORT_SYMBOL_GPL(of_reserved_mem_device_release); 406 407 /** 408 * of_reserved_mem_lookup() - acquire reserved_mem from a device node 409 * @np: node pointer of the desired reserved-memory region 410 * 411 * This function allows drivers to acquire a reference to the reserved_mem 412 * struct based on a device node handle. 413 * 414 * Returns a reserved_mem reference, or NULL on error. 415 */ 416 struct reserved_mem *of_reserved_mem_lookup(struct device_node *np) 417 { 418 const char *name; 419 int i; 420 421 if (!np->full_name) 422 return NULL; 423 424 name = kbasename(np->full_name); 425 for (i = 0; i < reserved_mem_count; i++) 426 if (!strcmp(reserved_mem[i].name, name)) 427 return &reserved_mem[i]; 428 429 return NULL; 430 } 431 EXPORT_SYMBOL_GPL(of_reserved_mem_lookup); 432