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