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