• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Functions for working with the Flattened Device Tree data format
4  *
5  * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
6  * benh@kernel.crashing.org
7  */
8 
9 #define pr_fmt(fmt)	"OF: fdt: " fmt
10 
11 #include <linux/crash_dump.h>
12 #include <linux/crc32.h>
13 #include <linux/kernel.h>
14 #include <linux/initrd.h>
15 #include <linux/memblock.h>
16 #include <linux/mutex.h>
17 #include <linux/of.h>
18 #include <linux/of_fdt.h>
19 #include <linux/of_reserved_mem.h>
20 #include <linux/sizes.h>
21 #include <linux/string.h>
22 #include <linux/errno.h>
23 #include <linux/slab.h>
24 #include <linux/libfdt.h>
25 #include <linux/debugfs.h>
26 #include <linux/serial_core.h>
27 #include <linux/sysfs.h>
28 #include <linux/random.h>
29 
30 #include <asm/setup.h>  /* for COMMAND_LINE_SIZE */
31 #include <asm/page.h>
32 
33 #include "of_private.h"
34 
35 /*
36  * of_fdt_limit_memory - limit the number of regions in the /memory node
37  * @limit: maximum entries
38  *
39  * Adjust the flattened device tree to have at most 'limit' number of
40  * memory entries in the /memory node. This function may be called
41  * any time after initial_boot_param is set.
42  */
of_fdt_limit_memory(int limit)43 void __init of_fdt_limit_memory(int limit)
44 {
45 	int memory;
46 	int len;
47 	const void *val;
48 	int nr_address_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
49 	int nr_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
50 	const __be32 *addr_prop;
51 	const __be32 *size_prop;
52 	int root_offset;
53 	int cell_size;
54 
55 	root_offset = fdt_path_offset(initial_boot_params, "/");
56 	if (root_offset < 0)
57 		return;
58 
59 	addr_prop = fdt_getprop(initial_boot_params, root_offset,
60 				"#address-cells", NULL);
61 	if (addr_prop)
62 		nr_address_cells = fdt32_to_cpu(*addr_prop);
63 
64 	size_prop = fdt_getprop(initial_boot_params, root_offset,
65 				"#size-cells", NULL);
66 	if (size_prop)
67 		nr_size_cells = fdt32_to_cpu(*size_prop);
68 
69 	cell_size = sizeof(uint32_t)*(nr_address_cells + nr_size_cells);
70 
71 	memory = fdt_path_offset(initial_boot_params, "/memory");
72 	if (memory > 0) {
73 		val = fdt_getprop(initial_boot_params, memory, "reg", &len);
74 		if (len > limit*cell_size) {
75 			len = limit*cell_size;
76 			pr_debug("Limiting number of entries to %d\n", limit);
77 			fdt_setprop(initial_boot_params, memory, "reg", val,
78 					len);
79 		}
80 	}
81 }
82 
of_fdt_device_is_available(const void * blob,unsigned long node)83 static bool of_fdt_device_is_available(const void *blob, unsigned long node)
84 {
85 	const char *status = fdt_getprop(blob, node, "status", NULL);
86 
87 	if (!status)
88 		return true;
89 
90 	if (!strcmp(status, "ok") || !strcmp(status, "okay"))
91 		return true;
92 
93 	return false;
94 }
95 
unflatten_dt_alloc(void ** mem,unsigned long size,unsigned long align)96 static void *unflatten_dt_alloc(void **mem, unsigned long size,
97 				       unsigned long align)
98 {
99 	void *res;
100 
101 	*mem = PTR_ALIGN(*mem, align);
102 	res = *mem;
103 	*mem += size;
104 
105 	return res;
106 }
107 
populate_properties(const void * blob,int offset,void ** mem,struct device_node * np,const char * nodename,bool dryrun)108 static void populate_properties(const void *blob,
109 				int offset,
110 				void **mem,
111 				struct device_node *np,
112 				const char *nodename,
113 				bool dryrun)
114 {
115 	struct property *pp, **pprev = NULL;
116 	int cur;
117 	bool has_name = false;
118 
119 	pprev = &np->properties;
120 	for (cur = fdt_first_property_offset(blob, offset);
121 	     cur >= 0;
122 	     cur = fdt_next_property_offset(blob, cur)) {
123 		const __be32 *val;
124 		const char *pname;
125 		u32 sz;
126 
127 		val = fdt_getprop_by_offset(blob, cur, &pname, &sz);
128 		if (!val) {
129 			pr_warn("Cannot locate property at 0x%x\n", cur);
130 			continue;
131 		}
132 
133 		if (!pname) {
134 			pr_warn("Cannot find property name at 0x%x\n", cur);
135 			continue;
136 		}
137 
138 		if (!strcmp(pname, "name"))
139 			has_name = true;
140 
141 		pp = unflatten_dt_alloc(mem, sizeof(struct property),
142 					__alignof__(struct property));
143 		if (dryrun)
144 			continue;
145 
146 		/* We accept flattened tree phandles either in
147 		 * ePAPR-style "phandle" properties, or the
148 		 * legacy "linux,phandle" properties.  If both
149 		 * appear and have different values, things
150 		 * will get weird. Don't do that.
151 		 */
152 		if (!strcmp(pname, "phandle") ||
153 		    !strcmp(pname, "linux,phandle")) {
154 			if (!np->phandle)
155 				np->phandle = be32_to_cpup(val);
156 		}
157 
158 		/* And we process the "ibm,phandle" property
159 		 * used in pSeries dynamic device tree
160 		 * stuff
161 		 */
162 		if (!strcmp(pname, "ibm,phandle"))
163 			np->phandle = be32_to_cpup(val);
164 
165 		pp->name   = (char *)pname;
166 		pp->length = sz;
167 		pp->value  = (__be32 *)val;
168 		*pprev     = pp;
169 		pprev      = &pp->next;
170 	}
171 
172 	/* With version 0x10 we may not have the name property,
173 	 * recreate it here from the unit name if absent
174 	 */
175 	if (!has_name) {
176 		const char *p = nodename, *ps = p, *pa = NULL;
177 		int len;
178 
179 		while (*p) {
180 			if ((*p) == '@')
181 				pa = p;
182 			else if ((*p) == '/')
183 				ps = p + 1;
184 			p++;
185 		}
186 
187 		if (pa < ps)
188 			pa = p;
189 		len = (pa - ps) + 1;
190 		pp = unflatten_dt_alloc(mem, sizeof(struct property) + len,
191 					__alignof__(struct property));
192 		if (!dryrun) {
193 			pp->name   = "name";
194 			pp->length = len;
195 			pp->value  = pp + 1;
196 			*pprev     = pp;
197 			memcpy(pp->value, ps, len - 1);
198 			((char *)pp->value)[len - 1] = 0;
199 			pr_debug("fixed up name for %s -> %s\n",
200 				 nodename, (char *)pp->value);
201 		}
202 	}
203 }
204 
populate_node(const void * blob,int offset,void ** mem,struct device_node * dad,struct device_node ** pnp,bool dryrun)205 static int populate_node(const void *blob,
206 			  int offset,
207 			  void **mem,
208 			  struct device_node *dad,
209 			  struct device_node **pnp,
210 			  bool dryrun)
211 {
212 	struct device_node *np;
213 	const char *pathp;
214 	int len;
215 
216 	pathp = fdt_get_name(blob, offset, &len);
217 	if (!pathp) {
218 		*pnp = NULL;
219 		return len;
220 	}
221 
222 	len++;
223 
224 	np = unflatten_dt_alloc(mem, sizeof(struct device_node) + len,
225 				__alignof__(struct device_node));
226 	if (!dryrun) {
227 		char *fn;
228 		of_node_init(np);
229 		np->full_name = fn = ((char *)np) + sizeof(*np);
230 
231 		memcpy(fn, pathp, len);
232 
233 		if (dad != NULL) {
234 			np->parent = dad;
235 			np->sibling = dad->child;
236 			dad->child = np;
237 		}
238 	}
239 
240 	populate_properties(blob, offset, mem, np, pathp, dryrun);
241 	if (!dryrun) {
242 		np->name = of_get_property(np, "name", NULL);
243 		if (!np->name)
244 			np->name = "<NULL>";
245 	}
246 
247 	*pnp = np;
248 	return 0;
249 }
250 
reverse_nodes(struct device_node * parent)251 static void reverse_nodes(struct device_node *parent)
252 {
253 	struct device_node *child, *next;
254 
255 	/* In-depth first */
256 	child = parent->child;
257 	while (child) {
258 		reverse_nodes(child);
259 
260 		child = child->sibling;
261 	}
262 
263 	/* Reverse the nodes in the child list */
264 	child = parent->child;
265 	parent->child = NULL;
266 	while (child) {
267 		next = child->sibling;
268 
269 		child->sibling = parent->child;
270 		parent->child = child;
271 		child = next;
272 	}
273 }
274 
275 /**
276  * unflatten_dt_nodes - Alloc and populate a device_node from the flat tree
277  * @blob: The parent device tree blob
278  * @mem: Memory chunk to use for allocating device nodes and properties
279  * @dad: Parent struct device_node
280  * @nodepp: The device_node tree created by the call
281  *
282  * Return: The size of unflattened device tree or error code
283  */
unflatten_dt_nodes(const void * blob,void * mem,struct device_node * dad,struct device_node ** nodepp)284 static int unflatten_dt_nodes(const void *blob,
285 			      void *mem,
286 			      struct device_node *dad,
287 			      struct device_node **nodepp)
288 {
289 	struct device_node *root;
290 	int offset = 0, depth = 0, initial_depth = 0;
291 #define FDT_MAX_DEPTH	64
292 	struct device_node *nps[FDT_MAX_DEPTH];
293 	void *base = mem;
294 	bool dryrun = !base;
295 	int ret;
296 
297 	if (nodepp)
298 		*nodepp = NULL;
299 
300 	/*
301 	 * We're unflattening device sub-tree if @dad is valid. There are
302 	 * possibly multiple nodes in the first level of depth. We need
303 	 * set @depth to 1 to make fdt_next_node() happy as it bails
304 	 * immediately when negative @depth is found. Otherwise, the device
305 	 * nodes except the first one won't be unflattened successfully.
306 	 */
307 	if (dad)
308 		depth = initial_depth = 1;
309 
310 	root = dad;
311 	nps[depth] = dad;
312 
313 	for (offset = 0;
314 	     offset >= 0 && depth >= initial_depth;
315 	     offset = fdt_next_node(blob, offset, &depth)) {
316 		if (WARN_ON_ONCE(depth >= FDT_MAX_DEPTH - 1))
317 			continue;
318 
319 		if (!IS_ENABLED(CONFIG_OF_KOBJ) &&
320 		    !of_fdt_device_is_available(blob, offset))
321 			continue;
322 
323 		ret = populate_node(blob, offset, &mem, nps[depth],
324 				   &nps[depth+1], dryrun);
325 		if (ret < 0)
326 			return ret;
327 
328 		if (!dryrun && nodepp && !*nodepp)
329 			*nodepp = nps[depth+1];
330 		if (!dryrun && !root)
331 			root = nps[depth+1];
332 	}
333 
334 	if (offset < 0 && offset != -FDT_ERR_NOTFOUND) {
335 		pr_err("Error %d processing FDT\n", offset);
336 		return -EINVAL;
337 	}
338 
339 	/*
340 	 * Reverse the child list. Some drivers assumes node order matches .dts
341 	 * node order
342 	 */
343 	if (!dryrun)
344 		reverse_nodes(root);
345 
346 	return mem - base;
347 }
348 
349 /**
350  * __unflatten_device_tree - create tree of device_nodes from flat blob
351  * @blob: The blob to expand
352  * @dad: Parent device node
353  * @mynodes: The device_node tree created by the call
354  * @dt_alloc: An allocator that provides a virtual address to memory
355  * for the resulting tree
356  * @detached: if true set OF_DETACHED on @mynodes
357  *
358  * unflattens a device-tree, creating the tree of struct device_node. It also
359  * fills the "name" and "type" pointers of the nodes so the normal device-tree
360  * walking functions can be used.
361  *
362  * Return: NULL on failure or the memory chunk containing the unflattened
363  * device tree on success.
364  */
__unflatten_device_tree(const void * blob,struct device_node * dad,struct device_node ** mynodes,void * (* dt_alloc)(u64 size,u64 align),bool detached)365 void *__unflatten_device_tree(const void *blob,
366 			      struct device_node *dad,
367 			      struct device_node **mynodes,
368 			      void *(*dt_alloc)(u64 size, u64 align),
369 			      bool detached)
370 {
371 	int size;
372 	void *mem;
373 	int ret;
374 
375 	if (mynodes)
376 		*mynodes = NULL;
377 
378 	pr_debug(" -> unflatten_device_tree()\n");
379 
380 	if (!blob) {
381 		pr_debug("No device tree pointer\n");
382 		return NULL;
383 	}
384 
385 	pr_debug("Unflattening device tree:\n");
386 	pr_debug("magic: %08x\n", fdt_magic(blob));
387 	pr_debug("size: %08x\n", fdt_totalsize(blob));
388 	pr_debug("version: %08x\n", fdt_version(blob));
389 
390 	if (fdt_check_header(blob)) {
391 		pr_err("Invalid device tree blob header\n");
392 		return NULL;
393 	}
394 
395 	/* First pass, scan for size */
396 	size = unflatten_dt_nodes(blob, NULL, dad, NULL);
397 	if (size <= 0)
398 		return NULL;
399 
400 	size = ALIGN(size, 4);
401 	pr_debug("  size is %d, allocating...\n", size);
402 
403 	/* Allocate memory for the expanded device tree */
404 	mem = dt_alloc(size + 4, __alignof__(struct device_node));
405 	if (!mem)
406 		return NULL;
407 
408 	memset(mem, 0, size);
409 
410 	*(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
411 
412 	pr_debug("  unflattening %p...\n", mem);
413 
414 	/* Second pass, do actual unflattening */
415 	ret = unflatten_dt_nodes(blob, mem, dad, mynodes);
416 
417 	if (be32_to_cpup(mem + size) != 0xdeadbeef)
418 		pr_warn("End of tree marker overwritten: %08x\n",
419 			be32_to_cpup(mem + size));
420 
421 	if (ret <= 0)
422 		return NULL;
423 
424 	if (detached && mynodes && *mynodes) {
425 		of_node_set_flag(*mynodes, OF_DETACHED);
426 		pr_debug("unflattened tree is detached\n");
427 	}
428 
429 	pr_debug(" <- unflatten_device_tree()\n");
430 	return mem;
431 }
432 
kernel_tree_alloc(u64 size,u64 align)433 static void *kernel_tree_alloc(u64 size, u64 align)
434 {
435 	return kzalloc(size, GFP_KERNEL);
436 }
437 
438 static DEFINE_MUTEX(of_fdt_unflatten_mutex);
439 
440 /**
441  * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
442  * @blob: Flat device tree blob
443  * @dad: Parent device node
444  * @mynodes: The device tree created by the call
445  *
446  * unflattens the device-tree passed by the firmware, creating the
447  * tree of struct device_node. It also fills the "name" and "type"
448  * pointers of the nodes so the normal device-tree walking functions
449  * can be used.
450  *
451  * Return: NULL on failure or the memory chunk containing the unflattened
452  * device tree on success.
453  */
of_fdt_unflatten_tree(const unsigned long * blob,struct device_node * dad,struct device_node ** mynodes)454 void *of_fdt_unflatten_tree(const unsigned long *blob,
455 			    struct device_node *dad,
456 			    struct device_node **mynodes)
457 {
458 	void *mem;
459 
460 	mutex_lock(&of_fdt_unflatten_mutex);
461 	mem = __unflatten_device_tree(blob, dad, mynodes, &kernel_tree_alloc,
462 				      true);
463 	mutex_unlock(&of_fdt_unflatten_mutex);
464 
465 	return mem;
466 }
467 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
468 
469 /* Everything below here references initial_boot_params directly. */
470 int __initdata dt_root_addr_cells;
471 int __initdata dt_root_size_cells;
472 
473 void *initial_boot_params __ro_after_init;
474 
475 #ifdef CONFIG_OF_EARLY_FLATTREE
476 
477 static u32 of_fdt_crc32;
478 
early_init_dt_reserve_memory(phys_addr_t base,phys_addr_t size,bool nomap)479 static int __init early_init_dt_reserve_memory(phys_addr_t base,
480 					       phys_addr_t size, bool nomap)
481 {
482 	if (nomap) {
483 		/*
484 		 * If the memory is already reserved (by another region), we
485 		 * should not allow it to be marked nomap, but don't worry
486 		 * if the region isn't memory as it won't be mapped.
487 		 */
488 		if (memblock_overlaps_region(&memblock.memory, base, size) &&
489 		    memblock_is_region_reserved(base, size))
490 			return -EBUSY;
491 
492 		return memblock_mark_nomap(base, size);
493 	}
494 	return memblock_reserve(base, size);
495 }
496 
497 /*
498  * __reserved_mem_reserve_reg() - reserve all memory described in 'reg' property
499  */
__reserved_mem_reserve_reg(unsigned long node,const char * uname)500 static int __init __reserved_mem_reserve_reg(unsigned long node,
501 					     const char *uname)
502 {
503 	int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
504 	phys_addr_t base, size;
505 	int len;
506 	const __be32 *prop;
507 	int first = 1;
508 	bool nomap;
509 
510 	prop = of_get_flat_dt_prop(node, "reg", &len);
511 	if (!prop)
512 		return -ENOENT;
513 
514 	if (len && len % t_len != 0) {
515 		pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
516 		       uname);
517 		return -EINVAL;
518 	}
519 
520 	nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
521 
522 	while (len >= t_len) {
523 		base = dt_mem_next_cell(dt_root_addr_cells, &prop);
524 		size = dt_mem_next_cell(dt_root_size_cells, &prop);
525 
526 		if (size &&
527 		    early_init_dt_reserve_memory(base, size, nomap) == 0)
528 			pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %lu MiB\n",
529 				uname, &base, (unsigned long)(size / SZ_1M));
530 		else
531 			pr_err("Reserved memory: failed to reserve memory for node '%s': base %pa, size %lu MiB\n",
532 			       uname, &base, (unsigned long)(size / SZ_1M));
533 
534 		len -= t_len;
535 		if (first) {
536 			fdt_reserved_mem_save_node(node, uname, base, size);
537 			first = 0;
538 		}
539 	}
540 	return 0;
541 }
542 
543 /*
544  * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
545  * in /reserved-memory matches the values supported by the current implementation,
546  * also check if ranges property has been provided
547  */
__reserved_mem_check_root(unsigned long node)548 static int __init __reserved_mem_check_root(unsigned long node)
549 {
550 	const __be32 *prop;
551 
552 	prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
553 	if (!prop || be32_to_cpup(prop) != dt_root_size_cells)
554 		return -EINVAL;
555 
556 	prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
557 	if (!prop || be32_to_cpup(prop) != dt_root_addr_cells)
558 		return -EINVAL;
559 
560 	prop = of_get_flat_dt_prop(node, "ranges", NULL);
561 	if (!prop)
562 		return -EINVAL;
563 	return 0;
564 }
565 
566 /*
567  * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
568  */
fdt_scan_reserved_mem(void)569 static int __init fdt_scan_reserved_mem(void)
570 {
571 	int node, child;
572 	const void *fdt = initial_boot_params;
573 
574 	node = fdt_path_offset(fdt, "/reserved-memory");
575 	if (node < 0)
576 		return -ENODEV;
577 
578 	if (__reserved_mem_check_root(node) != 0) {
579 		pr_err("Reserved memory: unsupported node format, ignoring\n");
580 		return -EINVAL;
581 	}
582 
583 	fdt_for_each_subnode(child, fdt, node) {
584 		const char *uname;
585 		int err;
586 
587 		if (!of_fdt_device_is_available(fdt, child))
588 			continue;
589 
590 		uname = fdt_get_name(fdt, child, NULL);
591 
592 		err = __reserved_mem_reserve_reg(child, uname);
593 		if (err == -ENOENT && of_get_flat_dt_prop(child, "size", NULL))
594 			fdt_reserved_mem_save_node(child, uname, 0, 0);
595 	}
596 	return 0;
597 }
598 
599 /*
600  * fdt_reserve_elfcorehdr() - reserves memory for elf core header
601  *
602  * This function reserves the memory occupied by an elf core header
603  * described in the device tree. This region contains all the
604  * information about primary kernel's core image and is used by a dump
605  * capture kernel to access the system memory on primary kernel.
606  */
fdt_reserve_elfcorehdr(void)607 static void __init fdt_reserve_elfcorehdr(void)
608 {
609 	if (!IS_ENABLED(CONFIG_CRASH_DUMP) || !elfcorehdr_size)
610 		return;
611 
612 	if (memblock_is_region_reserved(elfcorehdr_addr, elfcorehdr_size)) {
613 		pr_warn("elfcorehdr is overlapped\n");
614 		return;
615 	}
616 
617 	memblock_reserve(elfcorehdr_addr, elfcorehdr_size);
618 
619 	pr_info("Reserving %llu KiB of memory at 0x%llx for elfcorehdr\n",
620 		elfcorehdr_size >> 10, elfcorehdr_addr);
621 }
622 
623 /**
624  * early_init_fdt_scan_reserved_mem() - create reserved memory regions
625  *
626  * This function grabs memory from early allocator for device exclusive use
627  * defined in device tree structures. It should be called by arch specific code
628  * once the early allocator (i.e. memblock) has been fully activated.
629  */
early_init_fdt_scan_reserved_mem(void)630 void __init early_init_fdt_scan_reserved_mem(void)
631 {
632 	int n;
633 	u64 base, size;
634 
635 	if (!initial_boot_params)
636 		return;
637 
638 	/* Process header /memreserve/ fields */
639 	for (n = 0; ; n++) {
640 		fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
641 		if (!size)
642 			break;
643 		memblock_reserve(base, size);
644 	}
645 
646 	fdt_scan_reserved_mem();
647 	fdt_reserve_elfcorehdr();
648 	fdt_init_reserved_mem();
649 }
650 
651 /**
652  * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob
653  */
early_init_fdt_reserve_self(void)654 void __init early_init_fdt_reserve_self(void)
655 {
656 	if (!initial_boot_params)
657 		return;
658 
659 	/* Reserve the dtb region */
660 	memblock_reserve(__pa(initial_boot_params),
661 			 fdt_totalsize(initial_boot_params));
662 }
663 
664 /**
665  * of_scan_flat_dt - scan flattened tree blob and call callback on each.
666  * @it: callback function
667  * @data: context data pointer
668  *
669  * This function is used to scan the flattened device-tree, it is
670  * used to extract the memory information at boot before we can
671  * unflatten the tree
672  */
of_scan_flat_dt(int (* it)(unsigned long node,const char * uname,int depth,void * data),void * data)673 int __init of_scan_flat_dt(int (*it)(unsigned long node,
674 				     const char *uname, int depth,
675 				     void *data),
676 			   void *data)
677 {
678 	const void *blob = initial_boot_params;
679 	const char *pathp;
680 	int offset, rc = 0, depth = -1;
681 
682 	if (!blob)
683 		return 0;
684 
685 	for (offset = fdt_next_node(blob, -1, &depth);
686 	     offset >= 0 && depth >= 0 && !rc;
687 	     offset = fdt_next_node(blob, offset, &depth)) {
688 
689 		pathp = fdt_get_name(blob, offset, NULL);
690 		rc = it(offset, pathp, depth, data);
691 	}
692 	return rc;
693 }
694 
695 /**
696  * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each.
697  * @parent: parent node
698  * @it: callback function
699  * @data: context data pointer
700  *
701  * This function is used to scan sub-nodes of a node.
702  */
of_scan_flat_dt_subnodes(unsigned long parent,int (* it)(unsigned long node,const char * uname,void * data),void * data)703 int __init of_scan_flat_dt_subnodes(unsigned long parent,
704 				    int (*it)(unsigned long node,
705 					      const char *uname,
706 					      void *data),
707 				    void *data)
708 {
709 	const void *blob = initial_boot_params;
710 	int node;
711 
712 	fdt_for_each_subnode(node, blob, parent) {
713 		const char *pathp;
714 		int rc;
715 
716 		pathp = fdt_get_name(blob, node, NULL);
717 		rc = it(node, pathp, data);
718 		if (rc)
719 			return rc;
720 	}
721 	return 0;
722 }
723 
724 /**
725  * of_get_flat_dt_subnode_by_name - get the subnode by given name
726  *
727  * @node: the parent node
728  * @uname: the name of subnode
729  * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none
730  */
731 
of_get_flat_dt_subnode_by_name(unsigned long node,const char * uname)732 int __init of_get_flat_dt_subnode_by_name(unsigned long node, const char *uname)
733 {
734 	return fdt_subnode_offset(initial_boot_params, node, uname);
735 }
736 
737 /*
738  * of_get_flat_dt_root - find the root node in the flat blob
739  */
of_get_flat_dt_root(void)740 unsigned long __init of_get_flat_dt_root(void)
741 {
742 	return 0;
743 }
744 
745 /*
746  * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
747  *
748  * This function can be used within scan_flattened_dt callback to get
749  * access to properties
750  */
of_get_flat_dt_prop(unsigned long node,const char * name,int * size)751 const void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
752 				       int *size)
753 {
754 	return fdt_getprop(initial_boot_params, node, name, size);
755 }
756 
757 /**
758  * of_fdt_is_compatible - Return true if given node from the given blob has
759  * compat in its compatible list
760  * @blob: A device tree blob
761  * @node: node to test
762  * @compat: compatible string to compare with compatible list.
763  *
764  * Return: a non-zero value on match with smaller values returned for more
765  * specific compatible values.
766  */
of_fdt_is_compatible(const void * blob,unsigned long node,const char * compat)767 static int of_fdt_is_compatible(const void *blob,
768 		      unsigned long node, const char *compat)
769 {
770 	const char *cp;
771 	int cplen;
772 	unsigned long l, score = 0;
773 
774 	cp = fdt_getprop(blob, node, "compatible", &cplen);
775 	if (cp == NULL)
776 		return 0;
777 	while (cplen > 0) {
778 		score++;
779 		if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
780 			return score;
781 		l = strlen(cp) + 1;
782 		cp += l;
783 		cplen -= l;
784 	}
785 
786 	return 0;
787 }
788 
789 /**
790  * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
791  * @node: node to test
792  * @compat: compatible string to compare with compatible list.
793  */
of_flat_dt_is_compatible(unsigned long node,const char * compat)794 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
795 {
796 	return of_fdt_is_compatible(initial_boot_params, node, compat);
797 }
798 
799 /*
800  * of_flat_dt_match - Return true if node matches a list of compatible values
801  */
of_flat_dt_match(unsigned long node,const char * const * compat)802 static int __init of_flat_dt_match(unsigned long node, const char *const *compat)
803 {
804 	unsigned int tmp, score = 0;
805 
806 	if (!compat)
807 		return 0;
808 
809 	while (*compat) {
810 		tmp = of_fdt_is_compatible(initial_boot_params, node, *compat);
811 		if (tmp && (score == 0 || (tmp < score)))
812 			score = tmp;
813 		compat++;
814 	}
815 
816 	return score;
817 }
818 
819 /*
820  * of_get_flat_dt_phandle - Given a node in the flat blob, return the phandle
821  */
of_get_flat_dt_phandle(unsigned long node)822 uint32_t __init of_get_flat_dt_phandle(unsigned long node)
823 {
824 	return fdt_get_phandle(initial_boot_params, node);
825 }
826 
of_flat_dt_get_machine_name(void)827 const char * __init of_flat_dt_get_machine_name(void)
828 {
829 	const char *name;
830 	unsigned long dt_root = of_get_flat_dt_root();
831 
832 	name = of_get_flat_dt_prop(dt_root, "model", NULL);
833 	if (!name)
834 		name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
835 	return name;
836 }
837 
838 /**
839  * of_flat_dt_match_machine - Iterate match tables to find matching machine.
840  *
841  * @default_match: A machine specific ptr to return in case of no match.
842  * @get_next_compat: callback function to return next compatible match table.
843  *
844  * Iterate through machine match tables to find the best match for the machine
845  * compatible string in the FDT.
846  */
of_flat_dt_match_machine(const void * default_match,const void * (* get_next_compat)(const char * const **))847 const void * __init of_flat_dt_match_machine(const void *default_match,
848 		const void * (*get_next_compat)(const char * const**))
849 {
850 	const void *data = NULL;
851 	const void *best_data = default_match;
852 	const char *const *compat;
853 	unsigned long dt_root;
854 	unsigned int best_score = ~1, score = 0;
855 
856 	dt_root = of_get_flat_dt_root();
857 	while ((data = get_next_compat(&compat))) {
858 		score = of_flat_dt_match(dt_root, compat);
859 		if (score > 0 && score < best_score) {
860 			best_data = data;
861 			best_score = score;
862 		}
863 	}
864 	if (!best_data) {
865 		const char *prop;
866 		int size;
867 
868 		pr_err("\n unrecognized device tree list:\n[ ");
869 
870 		prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
871 		if (prop) {
872 			while (size > 0) {
873 				printk("'%s' ", prop);
874 				size -= strlen(prop) + 1;
875 				prop += strlen(prop) + 1;
876 			}
877 		}
878 		printk("]\n\n");
879 		return NULL;
880 	}
881 
882 	pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
883 
884 	return best_data;
885 }
886 
__early_init_dt_declare_initrd(unsigned long start,unsigned long end)887 static void __early_init_dt_declare_initrd(unsigned long start,
888 					   unsigned long end)
889 {
890 	/* ARM64 would cause a BUG to occur here when CONFIG_DEBUG_VM is
891 	 * enabled since __va() is called too early. ARM64 does make use
892 	 * of phys_initrd_start/phys_initrd_size so we can skip this
893 	 * conversion.
894 	 */
895 	if (!IS_ENABLED(CONFIG_ARM64)) {
896 		initrd_start = (unsigned long)__va(start);
897 		initrd_end = (unsigned long)__va(end);
898 		initrd_below_start_ok = 1;
899 	}
900 }
901 
902 /**
903  * early_init_dt_check_for_initrd - Decode initrd location from flat tree
904  * @node: reference to node containing initrd location ('chosen')
905  */
early_init_dt_check_for_initrd(unsigned long node)906 static void __init early_init_dt_check_for_initrd(unsigned long node)
907 {
908 	u64 start, end;
909 	int len;
910 	const __be32 *prop;
911 
912 	if (!IS_ENABLED(CONFIG_BLK_DEV_INITRD))
913 		return;
914 
915 	pr_debug("Looking for initrd properties... ");
916 
917 	prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
918 	if (!prop)
919 		return;
920 	start = of_read_number(prop, len/4);
921 
922 	prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
923 	if (!prop)
924 		return;
925 	end = of_read_number(prop, len/4);
926 	if (start > end)
927 		return;
928 
929 	__early_init_dt_declare_initrd(start, end);
930 	phys_initrd_start = start;
931 	phys_initrd_size = end - start;
932 
933 	pr_debug("initrd_start=0x%llx  initrd_end=0x%llx\n", start, end);
934 }
935 
936 /**
937  * early_init_dt_check_for_elfcorehdr - Decode elfcorehdr location from flat
938  * tree
939  * @node: reference to node containing elfcorehdr location ('chosen')
940  */
early_init_dt_check_for_elfcorehdr(unsigned long node)941 static void __init early_init_dt_check_for_elfcorehdr(unsigned long node)
942 {
943 	const __be32 *prop;
944 	int len;
945 
946 	if (!IS_ENABLED(CONFIG_CRASH_DUMP))
947 		return;
948 
949 	pr_debug("Looking for elfcorehdr property... ");
950 
951 	prop = of_get_flat_dt_prop(node, "linux,elfcorehdr", &len);
952 	if (!prop || (len < (dt_root_addr_cells + dt_root_size_cells)))
953 		return;
954 
955 	elfcorehdr_addr = dt_mem_next_cell(dt_root_addr_cells, &prop);
956 	elfcorehdr_size = dt_mem_next_cell(dt_root_size_cells, &prop);
957 
958 	pr_debug("elfcorehdr_start=0x%llx elfcorehdr_size=0x%llx\n",
959 		 elfcorehdr_addr, elfcorehdr_size);
960 }
961 
962 static unsigned long chosen_node_offset = -FDT_ERR_NOTFOUND;
963 
964 /*
965  * The main usage of linux,usable-memory-range is for crash dump kernel.
966  * Originally, the number of usable-memory regions is one. Now there may
967  * be two regions, low region and high region.
968  * To make compatibility with existing user-space and older kdump, the low
969  * region is always the last range of linux,usable-memory-range if exist.
970  */
971 #define MAX_USABLE_RANGES		2
972 
973 /**
974  * early_init_dt_check_for_usable_mem_range - Decode usable memory range
975  * location from flat tree
976  */
early_init_dt_check_for_usable_mem_range(void)977 void __init early_init_dt_check_for_usable_mem_range(void)
978 {
979 	struct memblock_region rgn[MAX_USABLE_RANGES] = {0};
980 	const __be32 *prop, *endp;
981 	int len, i;
982 	unsigned long node = chosen_node_offset;
983 
984 	if ((long)node < 0)
985 		return;
986 
987 	pr_debug("Looking for usable-memory-range property... ");
988 
989 	prop = of_get_flat_dt_prop(node, "linux,usable-memory-range", &len);
990 	if (!prop || (len % (dt_root_addr_cells + dt_root_size_cells)))
991 		return;
992 
993 	endp = prop + (len / sizeof(__be32));
994 	for (i = 0; i < MAX_USABLE_RANGES && prop < endp; i++) {
995 		rgn[i].base = dt_mem_next_cell(dt_root_addr_cells, &prop);
996 		rgn[i].size = dt_mem_next_cell(dt_root_size_cells, &prop);
997 
998 		pr_debug("cap_mem_regions[%d]: base=%pa, size=%pa\n",
999 			 i, &rgn[i].base, &rgn[i].size);
1000 	}
1001 
1002 	memblock_cap_memory_range(rgn[0].base, rgn[0].size);
1003 	for (i = 1; i < MAX_USABLE_RANGES && rgn[i].size; i++)
1004 		memblock_add(rgn[i].base, rgn[i].size);
1005 }
1006 
1007 #ifdef CONFIG_SERIAL_EARLYCON
1008 
early_init_dt_scan_chosen_stdout(void)1009 int __init early_init_dt_scan_chosen_stdout(void)
1010 {
1011 	int offset;
1012 	const char *p, *q, *options = NULL;
1013 	int l;
1014 	const struct earlycon_id *match;
1015 	const void *fdt = initial_boot_params;
1016 	int ret;
1017 
1018 	offset = fdt_path_offset(fdt, "/chosen");
1019 	if (offset < 0)
1020 		offset = fdt_path_offset(fdt, "/chosen@0");
1021 	if (offset < 0)
1022 		return -ENOENT;
1023 
1024 	p = fdt_getprop(fdt, offset, "stdout-path", &l);
1025 	if (!p)
1026 		p = fdt_getprop(fdt, offset, "linux,stdout-path", &l);
1027 	if (!p || !l)
1028 		return -ENOENT;
1029 
1030 	q = strchrnul(p, ':');
1031 	if (*q != '\0')
1032 		options = q + 1;
1033 	l = q - p;
1034 
1035 	/* Get the node specified by stdout-path */
1036 	offset = fdt_path_offset_namelen(fdt, p, l);
1037 	if (offset < 0) {
1038 		pr_warn("earlycon: stdout-path %.*s not found\n", l, p);
1039 		return 0;
1040 	}
1041 
1042 	for (match = __earlycon_table; match < __earlycon_table_end; match++) {
1043 		if (!match->compatible[0])
1044 			continue;
1045 
1046 		if (fdt_node_check_compatible(fdt, offset, match->compatible))
1047 			continue;
1048 
1049 		ret = of_setup_earlycon(match, offset, options);
1050 		if (!ret || ret == -EALREADY)
1051 			return 0;
1052 	}
1053 	return -ENODEV;
1054 }
1055 #endif
1056 
1057 /*
1058  * early_init_dt_scan_root - fetch the top level address and size cells
1059  */
early_init_dt_scan_root(void)1060 int __init early_init_dt_scan_root(void)
1061 {
1062 	const __be32 *prop;
1063 	const void *fdt = initial_boot_params;
1064 	int node = fdt_path_offset(fdt, "/");
1065 
1066 	if (node < 0)
1067 		return -ENODEV;
1068 
1069 	dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
1070 	dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
1071 
1072 	prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
1073 	if (prop)
1074 		dt_root_size_cells = be32_to_cpup(prop);
1075 	pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
1076 
1077 	prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
1078 	if (prop)
1079 		dt_root_addr_cells = be32_to_cpup(prop);
1080 	pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
1081 
1082 	return 0;
1083 }
1084 
dt_mem_next_cell(int s,const __be32 ** cellp)1085 u64 __init dt_mem_next_cell(int s, const __be32 **cellp)
1086 {
1087 	const __be32 *p = *cellp;
1088 
1089 	*cellp = p + s;
1090 	return of_read_number(p, s);
1091 }
1092 
1093 /*
1094  * early_init_dt_scan_memory - Look for and parse memory nodes
1095  */
early_init_dt_scan_memory(void)1096 int __init early_init_dt_scan_memory(void)
1097 {
1098 	int node, found_memory = 0;
1099 	const void *fdt = initial_boot_params;
1100 
1101 	fdt_for_each_subnode(node, fdt, 0) {
1102 		const char *type = of_get_flat_dt_prop(node, "device_type", NULL);
1103 		const __be32 *reg, *endp;
1104 		int l;
1105 		bool hotpluggable;
1106 
1107 		/* We are scanning "memory" nodes only */
1108 		if (type == NULL || strcmp(type, "memory") != 0)
1109 			continue;
1110 
1111 		if (!of_fdt_device_is_available(fdt, node))
1112 			continue;
1113 
1114 		reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
1115 		if (reg == NULL)
1116 			reg = of_get_flat_dt_prop(node, "reg", &l);
1117 		if (reg == NULL)
1118 			continue;
1119 
1120 		endp = reg + (l / sizeof(__be32));
1121 		hotpluggable = of_get_flat_dt_prop(node, "hotpluggable", NULL);
1122 
1123 		pr_debug("memory scan node %s, reg size %d,\n",
1124 			 fdt_get_name(fdt, node, NULL), l);
1125 
1126 		while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
1127 			u64 base, size;
1128 
1129 			base = dt_mem_next_cell(dt_root_addr_cells, &reg);
1130 			size = dt_mem_next_cell(dt_root_size_cells, &reg);
1131 
1132 			if (size == 0)
1133 				continue;
1134 			pr_debug(" - %llx, %llx\n", base, size);
1135 
1136 			early_init_dt_add_memory_arch(base, size);
1137 
1138 			found_memory = 1;
1139 
1140 			if (!hotpluggable)
1141 				continue;
1142 
1143 			if (memblock_mark_hotplug(base, size))
1144 				pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n",
1145 					base, base + size);
1146 		}
1147 	}
1148 	return found_memory;
1149 }
1150 
1151 /*
1152  * Convert configs to something easy to use in C code
1153  */
1154 #if defined(CONFIG_CMDLINE_FORCE)
1155 static const int overwrite_incoming_cmdline = 1;
1156 static const int read_dt_cmdline;
1157 static const int concat_cmdline;
1158 #elif defined(CONFIG_CMDLINE_EXTEND)
1159 static const int overwrite_incoming_cmdline;
1160 static const int read_dt_cmdline = 1;
1161 static const int concat_cmdline = 1;
1162 #else /* CMDLINE_FROM_BOOTLOADER */
1163 static const int overwrite_incoming_cmdline;
1164 static const int read_dt_cmdline = 1;
1165 static const int concat_cmdline;
1166 #endif
1167 #ifdef CONFIG_CMDLINE
1168 static const char *config_cmdline = CONFIG_CMDLINE;
1169 #else
1170 static const char *config_cmdline = "";
1171 #endif
1172 
early_init_dt_scan_chosen(char * cmdline)1173 int __init early_init_dt_scan_chosen(char *cmdline)
1174 {
1175 	int l = 0, node;
1176 	const char *p = NULL;
1177 	const void *rng_seed;
1178 	const void *fdt = initial_boot_params;
1179 
1180 	node = fdt_path_offset(fdt, "/chosen");
1181 	if (node < 0)
1182 		node = fdt_path_offset(fdt, "/chosen@0");
1183 	if (node < 0)
1184 		/* Handle the cmdline config options even if no /chosen node */
1185 		goto handle_cmdline;
1186 
1187 	chosen_node_offset = node;
1188 
1189 	early_init_dt_check_for_initrd(node);
1190 	early_init_dt_check_for_elfcorehdr(node);
1191 
1192 	rng_seed = of_get_flat_dt_prop(node, "rng-seed", &l);
1193 	if (rng_seed && l > 0) {
1194 		add_bootloader_randomness(rng_seed, l);
1195 
1196 		/* try to clear seed so it won't be found. */
1197 		fdt_nop_property(initial_boot_params, node, "rng-seed");
1198 
1199 		/* update CRC check value */
1200 		of_fdt_crc32 = crc32_be(~0, initial_boot_params,
1201 				fdt_totalsize(initial_boot_params));
1202 	}
1203 
1204 	/* Put CONFIG_CMDLINE in if forced or if data had nothing in it to start */
1205 	if (overwrite_incoming_cmdline || !cmdline[0])
1206 		strscpy(cmdline, config_cmdline, COMMAND_LINE_SIZE);
1207 
1208 	/* Retrieve command line unless forcing */
1209 	if (read_dt_cmdline)
1210 		p = of_get_flat_dt_prop(node, "bootargs", &l);
1211 	if (p != NULL && l > 0) {
1212 		if (concat_cmdline) {
1213 			int cmdline_len;
1214 			int copy_len;
1215 			strlcat(cmdline, " ", COMMAND_LINE_SIZE);
1216 			cmdline_len = strlen(cmdline);
1217 			copy_len = COMMAND_LINE_SIZE - cmdline_len - 1;
1218 			copy_len = min((int)l, copy_len);
1219 			strncpy(cmdline + cmdline_len, p, copy_len);
1220 			cmdline[cmdline_len + copy_len] = '\0';
1221 		} else {
1222 			strscpy(cmdline, p, min(l, COMMAND_LINE_SIZE));
1223 		}
1224 	}
1225 
1226 handle_cmdline:
1227 	pr_debug("Command line is: %s\n", (char *)cmdline);
1228 
1229 	return 0;
1230 }
1231 
1232 #ifndef MIN_MEMBLOCK_ADDR
1233 #define MIN_MEMBLOCK_ADDR	__pa(PAGE_OFFSET)
1234 #endif
1235 #ifndef MAX_MEMBLOCK_ADDR
1236 #define MAX_MEMBLOCK_ADDR	((phys_addr_t)~0)
1237 #endif
1238 
early_init_dt_add_memory_arch(u64 base,u64 size)1239 void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
1240 {
1241 	const u64 phys_offset = MIN_MEMBLOCK_ADDR;
1242 
1243 	if (size < PAGE_SIZE - (base & ~PAGE_MASK)) {
1244 		pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1245 			base, base + size);
1246 		return;
1247 	}
1248 
1249 	if (!PAGE_ALIGNED(base)) {
1250 		size -= PAGE_SIZE - (base & ~PAGE_MASK);
1251 		base = PAGE_ALIGN(base);
1252 	}
1253 	size &= PAGE_MASK;
1254 
1255 	if (base > MAX_MEMBLOCK_ADDR) {
1256 		pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1257 			base, base + size);
1258 		return;
1259 	}
1260 
1261 	if (base + size - 1 > MAX_MEMBLOCK_ADDR) {
1262 		pr_warn("Ignoring memory range 0x%llx - 0x%llx\n",
1263 			((u64)MAX_MEMBLOCK_ADDR) + 1, base + size);
1264 		size = MAX_MEMBLOCK_ADDR - base + 1;
1265 	}
1266 
1267 	if (base + size < phys_offset) {
1268 		pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1269 			base, base + size);
1270 		return;
1271 	}
1272 	if (base < phys_offset) {
1273 		pr_warn("Ignoring memory range 0x%llx - 0x%llx\n",
1274 			base, phys_offset);
1275 		size -= phys_offset - base;
1276 		base = phys_offset;
1277 	}
1278 	memblock_add(base, size);
1279 }
1280 
early_init_dt_alloc_memory_arch(u64 size,u64 align)1281 static void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
1282 {
1283 	void *ptr = memblock_alloc(size, align);
1284 
1285 	if (!ptr)
1286 		panic("%s: Failed to allocate %llu bytes align=0x%llx\n",
1287 		      __func__, size, align);
1288 
1289 	return ptr;
1290 }
1291 
early_init_dt_verify(void * params)1292 bool __init early_init_dt_verify(void *params)
1293 {
1294 	if (!params)
1295 		return false;
1296 
1297 	/* check device tree validity */
1298 	if (fdt_check_header(params))
1299 		return false;
1300 
1301 	/* Setup flat device-tree pointer */
1302 	initial_boot_params = params;
1303 	of_fdt_crc32 = crc32_be(~0, initial_boot_params,
1304 				fdt_totalsize(initial_boot_params));
1305 	return true;
1306 }
1307 
1308 
early_init_dt_scan_nodes(void)1309 void __init early_init_dt_scan_nodes(void)
1310 {
1311 	int rc;
1312 
1313 	/* Initialize {size,address}-cells info */
1314 	early_init_dt_scan_root();
1315 
1316 	/* Retrieve various information from the /chosen node */
1317 	rc = early_init_dt_scan_chosen(boot_command_line);
1318 	if (rc)
1319 		pr_warn("No chosen node found, continuing without\n");
1320 
1321 	/* Setup memory, calling early_init_dt_add_memory_arch */
1322 	early_init_dt_scan_memory();
1323 
1324 	/* Handle linux,usable-memory-range property */
1325 	early_init_dt_check_for_usable_mem_range();
1326 }
1327 
early_init_dt_scan(void * params)1328 bool __init early_init_dt_scan(void *params)
1329 {
1330 	bool status;
1331 
1332 	status = early_init_dt_verify(params);
1333 	if (!status)
1334 		return false;
1335 
1336 	early_init_dt_scan_nodes();
1337 	return true;
1338 }
1339 
1340 /**
1341  * unflatten_device_tree - create tree of device_nodes from flat blob
1342  *
1343  * unflattens the device-tree passed by the firmware, creating the
1344  * tree of struct device_node. It also fills the "name" and "type"
1345  * pointers of the nodes so the normal device-tree walking functions
1346  * can be used.
1347  */
unflatten_device_tree(void)1348 void __init unflatten_device_tree(void)
1349 {
1350 	__unflatten_device_tree(initial_boot_params, NULL, &of_root,
1351 				early_init_dt_alloc_memory_arch, false);
1352 
1353 	/* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1354 	of_alias_scan(early_init_dt_alloc_memory_arch);
1355 
1356 	unittest_unflatten_overlay_base();
1357 }
1358 
1359 /**
1360  * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1361  *
1362  * Copies and unflattens the device-tree passed by the firmware, creating the
1363  * tree of struct device_node. It also fills the "name" and "type"
1364  * pointers of the nodes so the normal device-tree walking functions
1365  * can be used. This should only be used when the FDT memory has not been
1366  * reserved such is the case when the FDT is built-in to the kernel init
1367  * section. If the FDT memory is reserved already then unflatten_device_tree
1368  * should be used instead.
1369  */
unflatten_and_copy_device_tree(void)1370 void __init unflatten_and_copy_device_tree(void)
1371 {
1372 	int size;
1373 	void *dt;
1374 
1375 	if (!initial_boot_params) {
1376 		pr_warn("No valid device tree found, continuing without\n");
1377 		return;
1378 	}
1379 
1380 	size = fdt_totalsize(initial_boot_params);
1381 	dt = early_init_dt_alloc_memory_arch(size,
1382 					     roundup_pow_of_two(FDT_V17_SIZE));
1383 
1384 	if (dt) {
1385 		memcpy(dt, initial_boot_params, size);
1386 		initial_boot_params = dt;
1387 	}
1388 	unflatten_device_tree();
1389 }
1390 
1391 #ifdef CONFIG_SYSFS
of_fdt_raw_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)1392 static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj,
1393 			       struct bin_attribute *bin_attr,
1394 			       char *buf, loff_t off, size_t count)
1395 {
1396 	memcpy(buf, initial_boot_params + off, count);
1397 	return count;
1398 }
1399 
of_fdt_raw_init(void)1400 static int __init of_fdt_raw_init(void)
1401 {
1402 	static struct bin_attribute of_fdt_raw_attr =
1403 		__BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0);
1404 
1405 	if (!initial_boot_params)
1406 		return 0;
1407 
1408 	if (of_fdt_crc32 != crc32_be(~0, initial_boot_params,
1409 				     fdt_totalsize(initial_boot_params))) {
1410 		pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n");
1411 		return 0;
1412 	}
1413 	of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params);
1414 	return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr);
1415 }
1416 late_initcall(of_fdt_raw_init);
1417 #endif
1418 
1419 #endif /* CONFIG_OF_EARLY_FLATTREE */
1420