1 // SPDX-License-Identifier: GPL-2.0
3 * Functions for working with the Flattened Device Tree data format
5 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
6 * benh@kernel.crashing.org
9 #define pr_fmt(fmt) "OF: fdt: " fmt
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>
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>
30 #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
33 #include "of_private.h"
36 * of_fdt_limit_memory - limit the number of regions in the /memory node
37 * @limit: maximum entries
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.
43 void __init
of_fdt_limit_memory(int limit
)
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
;
55 root_offset
= fdt_path_offset(initial_boot_params
, "/");
59 addr_prop
= fdt_getprop(initial_boot_params
, root_offset
,
60 "#address-cells", NULL
);
62 nr_address_cells
= fdt32_to_cpu(*addr_prop
);
64 size_prop
= fdt_getprop(initial_boot_params
, root_offset
,
67 nr_size_cells
= fdt32_to_cpu(*size_prop
);
69 cell_size
= sizeof(uint32_t)*(nr_address_cells
+ nr_size_cells
);
71 memory
= fdt_path_offset(initial_boot_params
, "/memory");
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
,
83 static bool of_fdt_device_is_available(const void *blob
, unsigned long node
)
85 const char *status
= fdt_getprop(blob
, node
, "status", NULL
);
90 if (!strcmp(status
, "ok") || !strcmp(status
, "okay"))
96 static void *unflatten_dt_alloc(void **mem
, unsigned long size
,
101 *mem
= PTR_ALIGN(*mem
, align
);
108 static void populate_properties(const void *blob
,
111 struct device_node
*np
,
112 const char *nodename
,
115 struct property
*pp
, **pprev
= NULL
;
117 bool has_name
= false;
119 pprev
= &np
->properties
;
120 for (cur
= fdt_first_property_offset(blob
, offset
);
122 cur
= fdt_next_property_offset(blob
, cur
)) {
127 val
= fdt_getprop_by_offset(blob
, cur
, &pname
, &sz
);
129 pr_warn("Cannot locate property at 0x%x\n", cur
);
134 pr_warn("Cannot find property name at 0x%x\n", cur
);
138 if (!strcmp(pname
, "name"))
141 pp
= unflatten_dt_alloc(mem
, sizeof(struct property
),
142 __alignof__(struct property
));
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.
152 if (!strcmp(pname
, "phandle") ||
153 !strcmp(pname
, "linux,phandle")) {
155 np
->phandle
= be32_to_cpup(val
);
158 /* And we process the "ibm,phandle" property
159 * used in pSeries dynamic device tree
162 if (!strcmp(pname
, "ibm,phandle"))
163 np
->phandle
= be32_to_cpup(val
);
165 pp
->name
= (char *)pname
;
167 pp
->value
= (__be32
*)val
;
172 /* With version 0x10 we may not have the name property,
173 * recreate it here from the unit name if absent
176 const char *p
= nodename
, *ps
= p
, *pa
= NULL
;
182 else if ((*p
) == '/')
190 pp
= unflatten_dt_alloc(mem
, sizeof(struct property
) + len
,
191 __alignof__(struct property
));
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
);
205 static int populate_node(const void *blob
,
208 struct device_node
*dad
,
209 struct device_node
**pnp
,
212 struct device_node
*np
;
216 pathp
= fdt_get_name(blob
, offset
, &len
);
224 np
= unflatten_dt_alloc(mem
, sizeof(struct device_node
) + len
,
225 __alignof__(struct device_node
));
229 np
->full_name
= fn
= ((char *)np
) + sizeof(*np
);
231 memcpy(fn
, pathp
, len
);
235 np
->sibling
= dad
->child
;
240 populate_properties(blob
, offset
, mem
, np
, pathp
, dryrun
);
242 np
->name
= of_get_property(np
, "name", NULL
);
251 static void reverse_nodes(struct device_node
*parent
)
253 struct device_node
*child
, *next
;
256 child
= parent
->child
;
258 reverse_nodes(child
);
260 child
= child
->sibling
;
263 /* Reverse the nodes in the child list */
264 child
= parent
->child
;
265 parent
->child
= NULL
;
267 next
= child
->sibling
;
269 child
->sibling
= parent
->child
;
270 parent
->child
= child
;
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
282 * Return: The size of unflattened device tree or error code
284 static int unflatten_dt_nodes(const void *blob
,
286 struct device_node
*dad
,
287 struct device_node
**nodepp
)
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
];
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.
308 depth
= initial_depth
= 1;
314 offset
>= 0 && depth
>= initial_depth
;
315 offset
= fdt_next_node(blob
, offset
, &depth
)) {
316 if (WARN_ON_ONCE(depth
>= FDT_MAX_DEPTH
))
319 if (!IS_ENABLED(CONFIG_OF_KOBJ
) &&
320 !of_fdt_device_is_available(blob
, offset
))
323 ret
= populate_node(blob
, offset
, &mem
, nps
[depth
],
324 &nps
[depth
+1], dryrun
);
328 if (!dryrun
&& nodepp
&& !*nodepp
)
329 *nodepp
= nps
[depth
+1];
330 if (!dryrun
&& !root
)
334 if (offset
< 0 && offset
!= -FDT_ERR_NOTFOUND
) {
335 pr_err("Error %d processing FDT\n", offset
);
340 * Reverse the child list. Some drivers assumes node order matches .dts
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
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.
362 * Return: NULL on failure or the memory chunk containing the unflattened
363 * device tree on success.
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
),
378 pr_debug(" -> unflatten_device_tree()\n");
381 pr_debug("No device tree pointer\n");
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
));
390 if (fdt_check_header(blob
)) {
391 pr_err("Invalid device tree blob header\n");
395 /* First pass, scan for size */
396 size
= unflatten_dt_nodes(blob
, NULL
, dad
, NULL
);
400 size
= ALIGN(size
, 4);
401 pr_debug(" size is %d, allocating...\n", size
);
403 /* Allocate memory for the expanded device tree */
404 mem
= dt_alloc(size
+ 4, __alignof__(struct device_node
));
408 memset(mem
, 0, size
);
410 *(__be32
*)(mem
+ size
) = cpu_to_be32(0xdeadbeef);
412 pr_debug(" unflattening %p...\n", mem
);
414 /* Second pass, do actual unflattening */
415 ret
= unflatten_dt_nodes(blob
, mem
, dad
, mynodes
);
417 if (be32_to_cpup(mem
+ size
) != 0xdeadbeef)
418 pr_warn("End of tree marker overwritten: %08x\n",
419 be32_to_cpup(mem
+ size
));
424 if (detached
&& mynodes
&& *mynodes
) {
425 of_node_set_flag(*mynodes
, OF_DETACHED
);
426 pr_debug("unflattened tree is detached\n");
429 pr_debug(" <- unflatten_device_tree()\n");
433 static void *kernel_tree_alloc(u64 size
, u64 align
)
435 return kzalloc(size
, GFP_KERNEL
);
438 static DEFINE_MUTEX(of_fdt_unflatten_mutex
);
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
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
451 * Return: NULL on failure or the memory chunk containing the unflattened
452 * device tree on success.
454 void *of_fdt_unflatten_tree(const unsigned long *blob
,
455 struct device_node
*dad
,
456 struct device_node
**mynodes
)
460 mutex_lock(&of_fdt_unflatten_mutex
);
461 mem
= __unflatten_device_tree(blob
, dad
, mynodes
, &kernel_tree_alloc
,
463 mutex_unlock(&of_fdt_unflatten_mutex
);
467 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree
);
469 /* Everything below here references initial_boot_params directly. */
470 int __initdata dt_root_addr_cells
;
471 int __initdata dt_root_size_cells
;
473 void *initial_boot_params __ro_after_init
;
475 #ifdef CONFIG_OF_EARLY_FLATTREE
477 static u32 of_fdt_crc32
;
479 static int __init
early_init_dt_reserve_memory_arch(phys_addr_t base
,
480 phys_addr_t size
, bool nomap
)
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.
488 if (memblock_overlaps_region(&memblock
.memory
, base
, size
) &&
489 memblock_is_region_reserved(base
, size
))
492 return memblock_mark_nomap(base
, size
);
494 return memblock_reserve(base
, size
);
498 * __reserved_mem_reserve_reg() - reserve all memory described in 'reg' property
500 static int __init
__reserved_mem_reserve_reg(unsigned long node
,
503 int t_len
= (dt_root_addr_cells
+ dt_root_size_cells
) * sizeof(__be32
);
504 phys_addr_t base
, size
;
510 prop
= of_get_flat_dt_prop(node
, "reg", &len
);
514 if (len
&& len
% t_len
!= 0) {
515 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
520 nomap
= of_get_flat_dt_prop(node
, "no-map", NULL
) != NULL
;
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
);
527 early_init_dt_reserve_memory_arch(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
));
531 pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %lu MiB\n",
532 uname
, &base
, (unsigned long)(size
/ SZ_1M
));
536 fdt_reserved_mem_save_node(node
, uname
, base
, size
);
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
548 static int __init
__reserved_mem_check_root(unsigned long node
)
552 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
553 if (!prop
|| be32_to_cpup(prop
) != dt_root_size_cells
)
556 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
557 if (!prop
|| be32_to_cpup(prop
) != dt_root_addr_cells
)
560 prop
= of_get_flat_dt_prop(node
, "ranges", NULL
);
567 * __fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
569 static int __init
__fdt_scan_reserved_mem(unsigned long node
, const char *uname
,
570 int depth
, void *data
)
575 if (!found
&& depth
== 1 && strcmp(uname
, "reserved-memory") == 0) {
576 if (__reserved_mem_check_root(node
) != 0) {
577 pr_err("Reserved memory: unsupported node format, ignoring\n");
587 } else if (found
&& depth
< 2) {
588 /* scanning of /reserved-memory has been finished */
592 if (!of_fdt_device_is_available(initial_boot_params
, node
))
595 err
= __reserved_mem_reserve_reg(node
, uname
);
596 if (err
== -ENOENT
&& of_get_flat_dt_prop(node
, "size", NULL
))
597 fdt_reserved_mem_save_node(node
, uname
, 0, 0);
604 * fdt_reserve_elfcorehdr() - reserves memory for elf core header
606 * This function reserves the memory occupied by an elf core header
607 * described in the device tree. This region contains all the
608 * information about primary kernel's core image and is used by a dump
609 * capture kernel to access the system memory on primary kernel.
611 static void __init
fdt_reserve_elfcorehdr(void)
613 if (!IS_ENABLED(CONFIG_CRASH_DUMP
) || !elfcorehdr_size
)
616 if (memblock_is_region_reserved(elfcorehdr_addr
, elfcorehdr_size
)) {
617 pr_warn("elfcorehdr is overlapped\n");
621 memblock_reserve(elfcorehdr_addr
, elfcorehdr_size
);
623 pr_info("Reserving %llu KiB of memory at 0x%llx for elfcorehdr\n",
624 elfcorehdr_size
>> 10, elfcorehdr_addr
);
628 * early_init_fdt_scan_reserved_mem() - create reserved memory regions
630 * This function grabs memory from early allocator for device exclusive use
631 * defined in device tree structures. It should be called by arch specific code
632 * once the early allocator (i.e. memblock) has been fully activated.
634 void __init
early_init_fdt_scan_reserved_mem(void)
639 if (!initial_boot_params
)
642 /* Process header /memreserve/ fields */
644 fdt_get_mem_rsv(initial_boot_params
, n
, &base
, &size
);
647 early_init_dt_reserve_memory_arch(base
, size
, false);
650 of_scan_flat_dt(__fdt_scan_reserved_mem
, NULL
);
651 fdt_init_reserved_mem();
652 fdt_reserve_elfcorehdr();
656 * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob
658 void __init
early_init_fdt_reserve_self(void)
660 if (!initial_boot_params
)
663 /* Reserve the dtb region */
664 early_init_dt_reserve_memory_arch(__pa(initial_boot_params
),
665 fdt_totalsize(initial_boot_params
),
670 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
671 * @it: callback function
672 * @data: context data pointer
674 * This function is used to scan the flattened device-tree, it is
675 * used to extract the memory information at boot before we can
678 int __init
of_scan_flat_dt(int (*it
)(unsigned long node
,
679 const char *uname
, int depth
,
683 const void *blob
= initial_boot_params
;
685 int offset
, rc
= 0, depth
= -1;
690 for (offset
= fdt_next_node(blob
, -1, &depth
);
691 offset
>= 0 && depth
>= 0 && !rc
;
692 offset
= fdt_next_node(blob
, offset
, &depth
)) {
694 pathp
= fdt_get_name(blob
, offset
, NULL
);
695 rc
= it(offset
, pathp
, depth
, data
);
701 * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each.
702 * @parent: parent node
703 * @it: callback function
704 * @data: context data pointer
706 * This function is used to scan sub-nodes of a node.
708 int __init
of_scan_flat_dt_subnodes(unsigned long parent
,
709 int (*it
)(unsigned long node
,
714 const void *blob
= initial_boot_params
;
717 fdt_for_each_subnode(node
, blob
, parent
) {
721 pathp
= fdt_get_name(blob
, node
, NULL
);
722 rc
= it(node
, pathp
, data
);
730 * of_get_flat_dt_subnode_by_name - get the subnode by given name
732 * @node: the parent node
733 * @uname: the name of subnode
734 * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none
737 int __init
of_get_flat_dt_subnode_by_name(unsigned long node
, const char *uname
)
739 return fdt_subnode_offset(initial_boot_params
, node
, uname
);
743 * of_get_flat_dt_root - find the root node in the flat blob
745 unsigned long __init
of_get_flat_dt_root(void)
751 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
753 * This function can be used within scan_flattened_dt callback to get
754 * access to properties
756 const void *__init
of_get_flat_dt_prop(unsigned long node
, const char *name
,
759 return fdt_getprop(initial_boot_params
, node
, name
, size
);
763 * of_fdt_is_compatible - Return true if given node from the given blob has
764 * compat in its compatible list
765 * @blob: A device tree blob
766 * @node: node to test
767 * @compat: compatible string to compare with compatible list.
769 * Return: a non-zero value on match with smaller values returned for more
770 * specific compatible values.
772 static int of_fdt_is_compatible(const void *blob
,
773 unsigned long node
, const char *compat
)
777 unsigned long l
, score
= 0;
779 cp
= fdt_getprop(blob
, node
, "compatible", &cplen
);
784 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0)
795 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
796 * @node: node to test
797 * @compat: compatible string to compare with compatible list.
799 int __init
of_flat_dt_is_compatible(unsigned long node
, const char *compat
)
801 return of_fdt_is_compatible(initial_boot_params
, node
, compat
);
805 * of_flat_dt_match - Return true if node matches a list of compatible values
807 static int __init
of_flat_dt_match(unsigned long node
, const char *const *compat
)
809 unsigned int tmp
, score
= 0;
815 tmp
= of_fdt_is_compatible(initial_boot_params
, node
, *compat
);
816 if (tmp
&& (score
== 0 || (tmp
< score
)))
825 * of_get_flat_dt_phandle - Given a node in the flat blob, return the phandle
827 uint32_t __init
of_get_flat_dt_phandle(unsigned long node
)
829 return fdt_get_phandle(initial_boot_params
, node
);
832 struct fdt_scan_status
{
837 int (*iterator
)(unsigned long node
, const char *uname
, int depth
, void *data
);
841 const char * __init
of_flat_dt_get_machine_name(void)
844 unsigned long dt_root
= of_get_flat_dt_root();
846 name
= of_get_flat_dt_prop(dt_root
, "model", NULL
);
848 name
= of_get_flat_dt_prop(dt_root
, "compatible", NULL
);
853 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
855 * @default_match: A machine specific ptr to return in case of no match.
856 * @get_next_compat: callback function to return next compatible match table.
858 * Iterate through machine match tables to find the best match for the machine
859 * compatible string in the FDT.
861 const void * __init
of_flat_dt_match_machine(const void *default_match
,
862 const void * (*get_next_compat
)(const char * const**))
864 const void *data
= NULL
;
865 const void *best_data
= default_match
;
866 const char *const *compat
;
867 unsigned long dt_root
;
868 unsigned int best_score
= ~1, score
= 0;
870 dt_root
= of_get_flat_dt_root();
871 while ((data
= get_next_compat(&compat
))) {
872 score
= of_flat_dt_match(dt_root
, compat
);
873 if (score
> 0 && score
< best_score
) {
882 pr_err("\n unrecognized device tree list:\n[ ");
884 prop
= of_get_flat_dt_prop(dt_root
, "compatible", &size
);
887 printk("'%s' ", prop
);
888 size
-= strlen(prop
) + 1;
889 prop
+= strlen(prop
) + 1;
896 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
901 static void __early_init_dt_declare_initrd(unsigned long start
,
904 /* ARM64 would cause a BUG to occur here when CONFIG_DEBUG_VM is
905 * enabled since __va() is called too early. ARM64 does make use
906 * of phys_initrd_start/phys_initrd_size so we can skip this
909 if (!IS_ENABLED(CONFIG_ARM64
)) {
910 initrd_start
= (unsigned long)__va(start
);
911 initrd_end
= (unsigned long)__va(end
);
912 initrd_below_start_ok
= 1;
917 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
918 * @node: reference to node containing initrd location ('chosen')
920 static void __init
early_init_dt_check_for_initrd(unsigned long node
)
926 if (!IS_ENABLED(CONFIG_BLK_DEV_INITRD
))
929 pr_debug("Looking for initrd properties... ");
931 prop
= of_get_flat_dt_prop(node
, "linux,initrd-start", &len
);
934 start
= of_read_number(prop
, len
/4);
936 prop
= of_get_flat_dt_prop(node
, "linux,initrd-end", &len
);
939 end
= of_read_number(prop
, len
/4);
941 __early_init_dt_declare_initrd(start
, end
);
942 phys_initrd_start
= start
;
943 phys_initrd_size
= end
- start
;
945 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n", start
, end
);
949 * early_init_dt_check_for_elfcorehdr - Decode elfcorehdr location from flat
951 * @node: reference to node containing elfcorehdr location ('chosen')
953 static void __init
early_init_dt_check_for_elfcorehdr(unsigned long node
)
958 if (!IS_ENABLED(CONFIG_CRASH_DUMP
))
961 pr_debug("Looking for elfcorehdr property... ");
963 prop
= of_get_flat_dt_prop(node
, "linux,elfcorehdr", &len
);
964 if (!prop
|| (len
< (dt_root_addr_cells
+ dt_root_size_cells
)))
967 elfcorehdr_addr
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
968 elfcorehdr_size
= dt_mem_next_cell(dt_root_size_cells
, &prop
);
970 pr_debug("elfcorehdr_start=0x%llx elfcorehdr_size=0x%llx\n",
971 elfcorehdr_addr
, elfcorehdr_size
);
974 static unsigned long chosen_node_offset
= -FDT_ERR_NOTFOUND
;
977 * early_init_dt_check_for_usable_mem_range - Decode usable memory range
978 * location from flat tree
980 void __init
early_init_dt_check_for_usable_mem_range(void)
984 phys_addr_t cap_mem_addr
;
985 phys_addr_t cap_mem_size
;
986 unsigned long node
= chosen_node_offset
;
991 pr_debug("Looking for usable-memory-range property... ");
993 prop
= of_get_flat_dt_prop(node
, "linux,usable-memory-range", &len
);
994 if (!prop
|| (len
< (dt_root_addr_cells
+ dt_root_size_cells
)))
997 cap_mem_addr
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
998 cap_mem_size
= dt_mem_next_cell(dt_root_size_cells
, &prop
);
1000 pr_debug("cap_mem_start=%pa cap_mem_size=%pa\n", &cap_mem_addr
,
1003 memblock_cap_memory_range(cap_mem_addr
, cap_mem_size
);
1006 #ifdef CONFIG_SERIAL_EARLYCON
1008 int __init
early_init_dt_scan_chosen_stdout(void)
1011 const char *p
, *q
, *options
= NULL
;
1013 const struct earlycon_id
*match
;
1014 const void *fdt
= initial_boot_params
;
1016 offset
= fdt_path_offset(fdt
, "/chosen");
1018 offset
= fdt_path_offset(fdt
, "/chosen@0");
1022 p
= fdt_getprop(fdt
, offset
, "stdout-path", &l
);
1024 p
= fdt_getprop(fdt
, offset
, "linux,stdout-path", &l
);
1028 q
= strchrnul(p
, ':');
1033 /* Get the node specified by stdout-path */
1034 offset
= fdt_path_offset_namelen(fdt
, p
, l
);
1036 pr_warn("earlycon: stdout-path %.*s not found\n", l
, p
);
1040 for (match
= __earlycon_table
; match
< __earlycon_table_end
; match
++) {
1041 if (!match
->compatible
[0])
1044 if (fdt_node_check_compatible(fdt
, offset
, match
->compatible
))
1047 if (of_setup_earlycon(match
, offset
, options
) == 0)
1055 * early_init_dt_scan_root - fetch the top level address and size cells
1057 int __init
early_init_dt_scan_root(unsigned long node
, const char *uname
,
1058 int depth
, void *data
)
1065 dt_root_size_cells
= OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
1066 dt_root_addr_cells
= OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
1068 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
1070 dt_root_size_cells
= be32_to_cpup(prop
);
1071 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells
);
1073 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
1075 dt_root_addr_cells
= be32_to_cpup(prop
);
1076 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells
);
1082 u64 __init
dt_mem_next_cell(int s
, const __be32
**cellp
)
1084 const __be32
*p
= *cellp
;
1087 return of_read_number(p
, s
);
1091 * early_init_dt_scan_memory - Look for and parse memory nodes
1093 int __init
early_init_dt_scan_memory(unsigned long node
, const char *uname
,
1094 int depth
, void *data
)
1096 const char *type
= of_get_flat_dt_prop(node
, "device_type", NULL
);
1097 const __be32
*reg
, *endp
;
1101 /* We are scanning "memory" nodes only */
1102 if (type
== NULL
|| strcmp(type
, "memory") != 0)
1105 reg
= of_get_flat_dt_prop(node
, "linux,usable-memory", &l
);
1107 reg
= of_get_flat_dt_prop(node
, "reg", &l
);
1111 endp
= reg
+ (l
/ sizeof(__be32
));
1112 hotpluggable
= of_get_flat_dt_prop(node
, "hotpluggable", NULL
);
1114 pr_debug("memory scan node %s, reg size %d,\n", uname
, l
);
1116 while ((endp
- reg
) >= (dt_root_addr_cells
+ dt_root_size_cells
)) {
1119 base
= dt_mem_next_cell(dt_root_addr_cells
, ®
);
1120 size
= dt_mem_next_cell(dt_root_size_cells
, ®
);
1124 pr_debug(" - %llx, %llx\n", base
, size
);
1126 early_init_dt_add_memory_arch(base
, size
);
1131 if (memblock_mark_hotplug(base
, size
))
1132 pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n",
1139 int __init
early_init_dt_scan_chosen(unsigned long node
, const char *uname
,
1140 int depth
, void *data
)
1144 const void *rng_seed
;
1146 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth
, uname
);
1148 if (depth
!= 1 || !data
||
1149 (strcmp(uname
, "chosen") != 0 && strcmp(uname
, "chosen@0") != 0))
1152 chosen_node_offset
= node
;
1154 early_init_dt_check_for_initrd(node
);
1155 early_init_dt_check_for_elfcorehdr(node
);
1157 /* Retrieve command line */
1158 p
= of_get_flat_dt_prop(node
, "bootargs", &l
);
1159 if (p
!= NULL
&& l
> 0)
1160 strlcpy(data
, p
, min(l
, COMMAND_LINE_SIZE
));
1163 * CONFIG_CMDLINE is meant to be a default in case nothing else
1164 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
1165 * is set in which case we override whatever was found earlier.
1167 #ifdef CONFIG_CMDLINE
1168 #if defined(CONFIG_CMDLINE_EXTEND)
1169 strlcat(data
, " ", COMMAND_LINE_SIZE
);
1170 strlcat(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1171 #elif defined(CONFIG_CMDLINE_FORCE)
1172 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1174 /* No arguments from boot loader, use kernel's cmdl*/
1175 if (!((char *)data
)[0])
1176 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1178 #endif /* CONFIG_CMDLINE */
1180 pr_debug("Command line is: %s\n", (char *)data
);
1182 rng_seed
= of_get_flat_dt_prop(node
, "rng-seed", &l
);
1183 if (rng_seed
&& l
> 0) {
1184 add_bootloader_randomness(rng_seed
, l
);
1186 /* try to clear seed so it won't be found. */
1187 fdt_nop_property(initial_boot_params
, node
, "rng-seed");
1189 /* update CRC check value */
1190 of_fdt_crc32
= crc32_be(~0, initial_boot_params
,
1191 fdt_totalsize(initial_boot_params
));
1198 #ifndef MIN_MEMBLOCK_ADDR
1199 #define MIN_MEMBLOCK_ADDR __pa(PAGE_OFFSET)
1201 #ifndef MAX_MEMBLOCK_ADDR
1202 #define MAX_MEMBLOCK_ADDR ((phys_addr_t)~0)
1205 void __init __weak
early_init_dt_add_memory_arch(u64 base
, u64 size
)
1207 const u64 phys_offset
= MIN_MEMBLOCK_ADDR
;
1209 if (size
< PAGE_SIZE
- (base
& ~PAGE_MASK
)) {
1210 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1215 if (!PAGE_ALIGNED(base
)) {
1216 size
-= PAGE_SIZE
- (base
& ~PAGE_MASK
);
1217 base
= PAGE_ALIGN(base
);
1221 if (base
> MAX_MEMBLOCK_ADDR
) {
1222 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1227 if (base
+ size
- 1 > MAX_MEMBLOCK_ADDR
) {
1228 pr_warn("Ignoring memory range 0x%llx - 0x%llx\n",
1229 ((u64
)MAX_MEMBLOCK_ADDR
) + 1, base
+ size
);
1230 size
= MAX_MEMBLOCK_ADDR
- base
+ 1;
1233 if (base
+ size
< phys_offset
) {
1234 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1238 if (base
< phys_offset
) {
1239 pr_warn("Ignoring memory range 0x%llx - 0x%llx\n",
1241 size
-= phys_offset
- base
;
1244 memblock_add(base
, size
);
1247 static void * __init
early_init_dt_alloc_memory_arch(u64 size
, u64 align
)
1249 void *ptr
= memblock_alloc(size
, align
);
1252 panic("%s: Failed to allocate %llu bytes align=0x%llx\n",
1253 __func__
, size
, align
);
1258 bool __init
early_init_dt_verify(void *params
)
1263 /* check device tree validity */
1264 if (fdt_check_header(params
))
1267 /* Setup flat device-tree pointer */
1268 initial_boot_params
= params
;
1269 of_fdt_crc32
= crc32_be(~0, initial_boot_params
,
1270 fdt_totalsize(initial_boot_params
));
1275 void __init
early_init_dt_scan_nodes(void)
1279 /* Initialize {size,address}-cells info */
1280 of_scan_flat_dt(early_init_dt_scan_root
, NULL
);
1282 /* Retrieve various information from the /chosen node */
1283 rc
= of_scan_flat_dt(early_init_dt_scan_chosen
, boot_command_line
);
1285 pr_warn("No chosen node found, continuing without\n");
1287 /* Setup memory, calling early_init_dt_add_memory_arch */
1288 of_scan_flat_dt(early_init_dt_scan_memory
, NULL
);
1290 /* Handle linux,usable-memory-range property */
1291 early_init_dt_check_for_usable_mem_range();
1294 bool __init
early_init_dt_scan(void *params
)
1298 status
= early_init_dt_verify(params
);
1302 early_init_dt_scan_nodes();
1307 * unflatten_device_tree - create tree of device_nodes from flat blob
1309 * unflattens the device-tree passed by the firmware, creating the
1310 * tree of struct device_node. It also fills the "name" and "type"
1311 * pointers of the nodes so the normal device-tree walking functions
1314 void __init
unflatten_device_tree(void)
1316 __unflatten_device_tree(initial_boot_params
, NULL
, &of_root
,
1317 early_init_dt_alloc_memory_arch
, false);
1319 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1320 of_alias_scan(early_init_dt_alloc_memory_arch
);
1322 unittest_unflatten_overlay_base();
1326 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1328 * Copies and unflattens the device-tree passed by the firmware, creating the
1329 * tree of struct device_node. It also fills the "name" and "type"
1330 * pointers of the nodes so the normal device-tree walking functions
1331 * can be used. This should only be used when the FDT memory has not been
1332 * reserved such is the case when the FDT is built-in to the kernel init
1333 * section. If the FDT memory is reserved already then unflatten_device_tree
1334 * should be used instead.
1336 void __init
unflatten_and_copy_device_tree(void)
1341 if (!initial_boot_params
) {
1342 pr_warn("No valid device tree found, continuing without\n");
1346 size
= fdt_totalsize(initial_boot_params
);
1347 dt
= early_init_dt_alloc_memory_arch(size
,
1348 roundup_pow_of_two(FDT_V17_SIZE
));
1351 memcpy(dt
, initial_boot_params
, size
);
1352 initial_boot_params
= dt
;
1354 unflatten_device_tree();
1358 static ssize_t
of_fdt_raw_read(struct file
*filp
, struct kobject
*kobj
,
1359 struct bin_attribute
*bin_attr
,
1360 char *buf
, loff_t off
, size_t count
)
1362 memcpy(buf
, initial_boot_params
+ off
, count
);
1366 static int __init
of_fdt_raw_init(void)
1368 static struct bin_attribute of_fdt_raw_attr
=
1369 __BIN_ATTR(fdt
, S_IRUSR
, of_fdt_raw_read
, NULL
, 0);
1371 if (!initial_boot_params
)
1374 if (of_fdt_crc32
!= crc32_be(~0, initial_boot_params
,
1375 fdt_totalsize(initial_boot_params
))) {
1376 pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n");
1379 of_fdt_raw_attr
.size
= fdt_totalsize(initial_boot_params
);
1380 return sysfs_create_bin_file(firmware_kobj
, &of_fdt_raw_attr
);
1382 late_initcall(of_fdt_raw_init
);
1385 #endif /* CONFIG_OF_EARLY_FLATTREE */