2 * Device tree based initialization code for reserved memory.
4 * Copyright (c) 2013, 2015 The Linux Foundation. All Rights Reserved.
5 * Copyright (c) 2013,2014 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com
7 * Author: Marek Szyprowski <m.szyprowski@samsung.com>
8 * Author: Josh Cartwright <joshc@codeaurora.org>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of the
13 * License or (at your optional) any later version of the license.
16 #include <linux/err.h>
18 #include <linux/of_fdt.h>
19 #include <linux/of_platform.h>
21 #include <linux/sizes.h>
22 #include <linux/of_reserved_mem.h>
23 #include <linux/sort.h>
25 #define MAX_RESERVED_REGIONS 16
26 static struct reserved_mem reserved_mem
[MAX_RESERVED_REGIONS
];
27 static int reserved_mem_count
;
29 #if defined(CONFIG_HAVE_MEMBLOCK)
30 #include <linux/memblock.h>
31 int __init __weak
early_init_dt_alloc_reserved_memory_arch(phys_addr_t size
,
32 phys_addr_t align
, phys_addr_t start
, phys_addr_t end
, bool nomap
,
33 phys_addr_t
*res_base
)
36 * We use __memblock_alloc_base() because memblock_alloc_base()
37 * panic()s on allocation failure.
39 phys_addr_t base
= __memblock_alloc_base(size
, align
, end
);
44 * Check if the allocated region fits in to start..end window
47 memblock_free(base
, size
);
53 return memblock_remove(base
, size
);
57 int __init __weak
early_init_dt_alloc_reserved_memory_arch(phys_addr_t size
,
58 phys_addr_t align
, phys_addr_t start
, phys_addr_t end
, bool nomap
,
59 phys_addr_t
*res_base
)
61 pr_err("Reserved memory not supported, ignoring region 0x%llx%s\n",
62 size
, nomap
? " (nomap)" : "");
68 * res_mem_save_node() - save fdt node for second pass initialization
70 void __init
fdt_reserved_mem_save_node(unsigned long node
, const char *uname
,
71 phys_addr_t base
, phys_addr_t size
)
73 struct reserved_mem
*rmem
= &reserved_mem
[reserved_mem_count
];
75 if (reserved_mem_count
== ARRAY_SIZE(reserved_mem
)) {
76 pr_err("Reserved memory: not enough space all defined regions.\n");
80 rmem
->fdt_node
= node
;
90 * res_mem_alloc_size() - allocate reserved memory described by 'size', 'align'
91 * and 'alloc-ranges' properties
93 static int __init
__reserved_mem_alloc_size(unsigned long node
,
94 const char *uname
, phys_addr_t
*res_base
, phys_addr_t
*res_size
)
96 int t_len
= (dt_root_addr_cells
+ dt_root_size_cells
) * sizeof(__be32
);
97 phys_addr_t start
= 0, end
= 0;
98 phys_addr_t base
= 0, align
= 0, size
;
104 prop
= of_get_flat_dt_prop(node
, "size", &len
);
108 if (len
!= dt_root_size_cells
* sizeof(__be32
)) {
109 pr_err("Reserved memory: invalid size property in '%s' node.\n",
113 size
= dt_mem_next_cell(dt_root_size_cells
, &prop
);
115 nomap
= of_get_flat_dt_prop(node
, "no-map", NULL
) != NULL
;
117 prop
= of_get_flat_dt_prop(node
, "alignment", &len
);
119 if (len
!= dt_root_addr_cells
* sizeof(__be32
)) {
120 pr_err("Reserved memory: invalid alignment property in '%s' node.\n",
124 align
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
127 prop
= of_get_flat_dt_prop(node
, "alloc-ranges", &len
);
130 if (len
% t_len
!= 0) {
131 pr_err("Reserved memory: invalid alloc-ranges property in '%s', skipping node.\n",
139 start
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
140 end
= start
+ dt_mem_next_cell(dt_root_size_cells
,
143 ret
= early_init_dt_alloc_reserved_memory_arch(size
,
144 align
, start
, end
, nomap
, &base
);
146 pr_debug("Reserved memory: allocated memory for '%s' node: base %pa, size %ld MiB\n",
148 (unsigned long)size
/ SZ_1M
);
155 ret
= early_init_dt_alloc_reserved_memory_arch(size
, align
,
158 pr_debug("Reserved memory: allocated memory for '%s' node: base %pa, size %ld MiB\n",
159 uname
, &base
, (unsigned long)size
/ SZ_1M
);
163 pr_info("Reserved memory: failed to allocate memory for node '%s'\n",
174 static const struct of_device_id __rmem_of_table_sentinel
175 __used
__section(__reservedmem_of_table_end
);
178 * res_mem_init_node() - call region specific reserved memory init code
180 static int __init
__reserved_mem_init_node(struct reserved_mem
*rmem
)
182 extern const struct of_device_id __reservedmem_of_table
[];
183 const struct of_device_id
*i
;
185 for (i
= __reservedmem_of_table
; i
< &__rmem_of_table_sentinel
; i
++) {
186 reservedmem_of_init_fn initfn
= i
->data
;
187 const char *compat
= i
->compatible
;
189 if (!of_flat_dt_is_compatible(rmem
->fdt_node
, compat
))
192 if (initfn(rmem
) == 0) {
193 pr_info("Reserved memory: initialized node %s, compatible id %s\n",
201 static int __init
__rmem_cmp(const void *a
, const void *b
)
203 const struct reserved_mem
*ra
= a
, *rb
= b
;
205 return ra
->base
- rb
->base
;
208 static void __init
__rmem_check_for_overlap(void)
212 if (reserved_mem_count
< 2)
215 sort(reserved_mem
, reserved_mem_count
, sizeof(reserved_mem
[0]),
217 for (i
= 0; i
< reserved_mem_count
- 1; i
++) {
218 struct reserved_mem
*this, *next
;
220 this = &reserved_mem
[i
];
221 next
= &reserved_mem
[i
+ 1];
222 if (!(this->base
&& next
->base
))
224 if (this->base
+ this->size
> next
->base
) {
225 phys_addr_t this_end
, next_end
;
227 this_end
= this->base
+ this->size
;
228 next_end
= next
->base
+ next
->size
;
230 "Reserved memory: OVERLAP DETECTED!\n%s (%pa--%pa) overlaps with %s (%pa--%pa)\n",
231 this->name
, &this->base
, &this_end
,
232 next
->name
, &next
->base
, &next_end
);
238 * fdt_init_reserved_mem - allocate and init all saved reserved memory regions
240 void __init
fdt_init_reserved_mem(void)
244 /* check for overlapping reserved regions */
245 __rmem_check_for_overlap();
247 for (i
= 0; i
< reserved_mem_count
; i
++) {
248 struct reserved_mem
*rmem
= &reserved_mem
[i
];
249 unsigned long node
= rmem
->fdt_node
;
254 prop
= of_get_flat_dt_prop(node
, "phandle", &len
);
256 prop
= of_get_flat_dt_prop(node
, "linux,phandle", &len
);
258 rmem
->phandle
= of_read_number(prop
, len
/4);
261 err
= __reserved_mem_alloc_size(node
, rmem
->name
,
262 &rmem
->base
, &rmem
->size
);
264 __reserved_mem_init_node(rmem
);
268 static inline struct reserved_mem
*__find_rmem(struct device_node
*node
)
275 for (i
= 0; i
< reserved_mem_count
; i
++)
276 if (reserved_mem
[i
].phandle
== node
->phandle
)
277 return &reserved_mem
[i
];
282 * of_reserved_mem_device_init() - assign reserved memory region to given device
284 * This function assign memory region pointed by "memory-region" device tree
285 * property to the given device.
287 int of_reserved_mem_device_init(struct device
*dev
)
289 struct reserved_mem
*rmem
;
290 struct device_node
*np
;
293 np
= of_parse_phandle(dev
->of_node
, "memory-region", 0);
297 rmem
= __find_rmem(np
);
300 if (!rmem
|| !rmem
->ops
|| !rmem
->ops
->device_init
)
303 ret
= rmem
->ops
->device_init(rmem
, dev
);
305 dev_info(dev
, "assigned reserved memory node %s\n", rmem
->name
);
309 EXPORT_SYMBOL_GPL(of_reserved_mem_device_init
);
312 * of_reserved_mem_device_release() - release reserved memory device structures
314 * This function releases structures allocated for memory region handling for
317 void of_reserved_mem_device_release(struct device
*dev
)
319 struct reserved_mem
*rmem
;
320 struct device_node
*np
;
322 np
= of_parse_phandle(dev
->of_node
, "memory-region", 0);
326 rmem
= __find_rmem(np
);
329 if (!rmem
|| !rmem
->ops
|| !rmem
->ops
->device_release
)
332 rmem
->ops
->device_release(rmem
, dev
);
334 EXPORT_SYMBOL_GPL(of_reserved_mem_device_release
);