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
 26static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS];
 27static int reserved_mem_count;
 28
 29static 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 * res_mem_save_node() - save fdt node for second pass initialization
 50 */
 51void __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 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 * res_mem_alloc_size() - allocate reserved memory described by 'size', 'align'
 72 *			  and 'alloc-ranges' properties
 73 */
 74static 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	int 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	nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
 96
 97	prop = of_get_flat_dt_prop(node, "alignment", &len);
 98	if (prop) {
 99		if (len != dt_root_addr_cells * sizeof(__be32)) {
100			pr_err("invalid alignment property in '%s' node.\n",
101				uname);
102			return -EINVAL;
103		}
104		align = dt_mem_next_cell(dt_root_addr_cells, &prop);
105	}
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	    && !of_get_flat_dt_prop(node, "no-map", NULL)) {
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
164static const struct of_device_id __rmem_of_table_sentinel
165	__used __section(__reservedmem_of_table_end);
166
167/**
168 * res_mem_init_node() - call region specific reserved memory init code
169 */
170static 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
193static 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
206static 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 */
237void __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		int 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
275static 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
288struct rmem_assigned_device {
289	struct device *dev;
290	struct reserved_mem *rmem;
291	struct list_head list;
292};
293
294static LIST_HEAD(of_rmem_assigned_device_list);
295static 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 */
312int 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}
358EXPORT_SYMBOL_GPL(of_reserved_mem_device_init_by_idx);
359
360/**
361 * of_reserved_mem_device_release() - release reserved memory device structures
362 * @dev:	Pointer to the device to deconfigure
363 *
364 * This function releases structures allocated for memory region handling for
365 * the given device.
366 */
367void of_reserved_mem_device_release(struct device *dev)
368{
369	struct rmem_assigned_device *rd;
370	struct reserved_mem *rmem = NULL;
371
372	mutex_lock(&of_rmem_assigned_device_mutex);
373	list_for_each_entry(rd, &of_rmem_assigned_device_list, list) {
374		if (rd->dev == dev) {
375			rmem = rd->rmem;
376			list_del(&rd->list);
377			kfree(rd);
378			break;
379		}
380	}
381	mutex_unlock(&of_rmem_assigned_device_mutex);
382
383	if (!rmem || !rmem->ops || !rmem->ops->device_release)
384		return;
385
386	rmem->ops->device_release(rmem, dev);
387}
388EXPORT_SYMBOL_GPL(of_reserved_mem_device_release);
389
390/**
391 * of_reserved_mem_lookup() - acquire reserved_mem from a device node
392 * @np:		node pointer of the desired reserved-memory region
393 *
394 * This function allows drivers to acquire a reference to the reserved_mem
395 * struct based on a device node handle.
396 *
397 * Returns a reserved_mem reference, or NULL on error.
398 */
399struct reserved_mem *of_reserved_mem_lookup(struct device_node *np)
400{
401	const char *name;
402	int i;
403
404	if (!np->full_name)
405		return NULL;
406
407	name = kbasename(np->full_name);
408	for (i = 0; i < reserved_mem_count; i++)
409		if (!strcmp(reserved_mem[i].name, name))
410			return &reserved_mem[i];
411
412	return NULL;
413}
414EXPORT_SYMBOL_GPL(of_reserved_mem_lookup);