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/crc32.h>
12 #include <linux/kernel.h>
13 #include <linux/initrd.h>
14 #include <linux/memblock.h>
15 #include <linux/mutex.h>
17 #include <linux/of_fdt.h>
18 #include <linux/of_reserved_mem.h>
19 #include <linux/sizes.h>
20 #include <linux/string.h>
21 #include <linux/errno.h>
22 #include <linux/slab.h>
23 #include <linux/libfdt.h>
24 #include <linux/debugfs.h>
25 #include <linux/serial_core.h>
26 #include <linux/sysfs.h>
28 #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
31 #include "of_private.h"
34 * of_fdt_limit_memory - limit the number of regions in the /memory node
35 * @limit: maximum entries
37 * Adjust the flattened device tree to have at most 'limit' number of
38 * memory entries in the /memory node. This function may be called
39 * any time after initial_boot_param is set.
41 void of_fdt_limit_memory(int limit
)
46 int nr_address_cells
= OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
47 int nr_size_cells
= OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
48 const __be32
*addr_prop
;
49 const __be32
*size_prop
;
53 root_offset
= fdt_path_offset(initial_boot_params
, "/");
57 addr_prop
= fdt_getprop(initial_boot_params
, root_offset
,
58 "#address-cells", NULL
);
60 nr_address_cells
= fdt32_to_cpu(*addr_prop
);
62 size_prop
= fdt_getprop(initial_boot_params
, root_offset
,
65 nr_size_cells
= fdt32_to_cpu(*size_prop
);
67 cell_size
= sizeof(uint32_t)*(nr_address_cells
+ nr_size_cells
);
69 memory
= fdt_path_offset(initial_boot_params
, "/memory");
71 val
= fdt_getprop(initial_boot_params
, memory
, "reg", &len
);
72 if (len
> limit
*cell_size
) {
73 len
= limit
*cell_size
;
74 pr_debug("Limiting number of entries to %d\n", limit
);
75 fdt_setprop(initial_boot_params
, memory
, "reg", val
,
82 * of_fdt_is_compatible - Return true if given node from the given blob has
83 * compat in its compatible list
84 * @blob: A device tree blob
86 * @compat: compatible string to compare with compatible list.
88 * On match, returns a non-zero value with smaller values returned for more
89 * specific compatible values.
91 static int of_fdt_is_compatible(const void *blob
,
92 unsigned long node
, const char *compat
)
96 unsigned long l
, score
= 0;
98 cp
= fdt_getprop(blob
, node
, "compatible", &cplen
);
103 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0)
114 * of_fdt_is_big_endian - Return true if given node needs BE MMIO accesses
115 * @blob: A device tree blob
116 * @node: node to test
118 * Returns true if the node has a "big-endian" property, or if the kernel
119 * was compiled for BE *and* the node has a "native-endian" property.
120 * Returns false otherwise.
122 bool of_fdt_is_big_endian(const void *blob
, unsigned long node
)
124 if (fdt_getprop(blob
, node
, "big-endian", NULL
))
126 if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN
) &&
127 fdt_getprop(blob
, node
, "native-endian", NULL
))
132 static bool of_fdt_device_is_available(const void *blob
, unsigned long node
)
134 const char *status
= fdt_getprop(blob
, node
, "status", NULL
);
139 if (!strcmp(status
, "ok") || !strcmp(status
, "okay"))
146 * of_fdt_match - Return true if node matches a list of compatible values
148 int of_fdt_match(const void *blob
, unsigned long node
,
149 const char *const *compat
)
151 unsigned int tmp
, score
= 0;
157 tmp
= of_fdt_is_compatible(blob
, node
, *compat
);
158 if (tmp
&& (score
== 0 || (tmp
< score
)))
166 static void *unflatten_dt_alloc(void **mem
, unsigned long size
,
171 *mem
= PTR_ALIGN(*mem
, align
);
178 static void populate_properties(const void *blob
,
181 struct device_node
*np
,
182 const char *nodename
,
185 struct property
*pp
, **pprev
= NULL
;
187 bool has_name
= false;
189 pprev
= &np
->properties
;
190 for (cur
= fdt_first_property_offset(blob
, offset
);
192 cur
= fdt_next_property_offset(blob
, cur
)) {
197 val
= fdt_getprop_by_offset(blob
, cur
, &pname
, &sz
);
199 pr_warn("Cannot locate property at 0x%x\n", cur
);
204 pr_warn("Cannot find property name at 0x%x\n", cur
);
208 if (!strcmp(pname
, "name"))
211 pp
= unflatten_dt_alloc(mem
, sizeof(struct property
),
212 __alignof__(struct property
));
216 /* We accept flattened tree phandles either in
217 * ePAPR-style "phandle" properties, or the
218 * legacy "linux,phandle" properties. If both
219 * appear and have different values, things
220 * will get weird. Don't do that.
222 if (!strcmp(pname
, "phandle") ||
223 !strcmp(pname
, "linux,phandle")) {
225 np
->phandle
= be32_to_cpup(val
);
228 /* And we process the "ibm,phandle" property
229 * used in pSeries dynamic device tree
232 if (!strcmp(pname
, "ibm,phandle"))
233 np
->phandle
= be32_to_cpup(val
);
235 pp
->name
= (char *)pname
;
237 pp
->value
= (__be32
*)val
;
242 /* With version 0x10 we may not have the name property,
243 * recreate it here from the unit name if absent
246 const char *p
= nodename
, *ps
= p
, *pa
= NULL
;
252 else if ((*p
) == '/')
260 pp
= unflatten_dt_alloc(mem
, sizeof(struct property
) + len
,
261 __alignof__(struct property
));
268 memcpy(pp
->value
, ps
, len
- 1);
269 ((char *)pp
->value
)[len
- 1] = 0;
270 pr_debug("fixed up name for %s -> %s\n",
271 nodename
, (char *)pp
->value
);
279 static bool populate_node(const void *blob
,
282 struct device_node
*dad
,
283 struct device_node
**pnp
,
286 struct device_node
*np
;
288 unsigned int l
, allocl
;
290 pathp
= fdt_get_name(blob
, offset
, &l
);
298 np
= unflatten_dt_alloc(mem
, sizeof(struct device_node
) + allocl
,
299 __alignof__(struct device_node
));
303 np
->full_name
= fn
= ((char *)np
) + sizeof(*np
);
305 memcpy(fn
, pathp
, l
);
309 np
->sibling
= dad
->child
;
314 populate_properties(blob
, offset
, mem
, np
, pathp
, dryrun
);
316 np
->name
= of_get_property(np
, "name", NULL
);
317 np
->type
= of_get_property(np
, "device_type", NULL
);
329 static void reverse_nodes(struct device_node
*parent
)
331 struct device_node
*child
, *next
;
334 child
= parent
->child
;
336 reverse_nodes(child
);
338 child
= child
->sibling
;
341 /* Reverse the nodes in the child list */
342 child
= parent
->child
;
343 parent
->child
= NULL
;
345 next
= child
->sibling
;
347 child
->sibling
= parent
->child
;
348 parent
->child
= child
;
354 * unflatten_dt_nodes - Alloc and populate a device_node from the flat tree
355 * @blob: The parent device tree blob
356 * @mem: Memory chunk to use for allocating device nodes and properties
357 * @dad: Parent struct device_node
358 * @nodepp: The device_node tree created by the call
360 * It returns the size of unflattened device tree or error code
362 static int unflatten_dt_nodes(const void *blob
,
364 struct device_node
*dad
,
365 struct device_node
**nodepp
)
367 struct device_node
*root
;
368 int offset
= 0, depth
= 0, initial_depth
= 0;
369 #define FDT_MAX_DEPTH 64
370 struct device_node
*nps
[FDT_MAX_DEPTH
];
378 * We're unflattening device sub-tree if @dad is valid. There are
379 * possibly multiple nodes in the first level of depth. We need
380 * set @depth to 1 to make fdt_next_node() happy as it bails
381 * immediately when negative @depth is found. Otherwise, the device
382 * nodes except the first one won't be unflattened successfully.
385 depth
= initial_depth
= 1;
391 offset
>= 0 && depth
>= initial_depth
;
392 offset
= fdt_next_node(blob
, offset
, &depth
)) {
393 if (WARN_ON_ONCE(depth
>= FDT_MAX_DEPTH
))
396 if (!IS_ENABLED(CONFIG_OF_KOBJ
) &&
397 !of_fdt_device_is_available(blob
, offset
))
400 if (!populate_node(blob
, offset
, &mem
, nps
[depth
],
401 &nps
[depth
+1], dryrun
))
404 if (!dryrun
&& nodepp
&& !*nodepp
)
405 *nodepp
= nps
[depth
+1];
406 if (!dryrun
&& !root
)
410 if (offset
< 0 && offset
!= -FDT_ERR_NOTFOUND
) {
411 pr_err("Error %d processing FDT\n", offset
);
416 * Reverse the child list. Some drivers assumes node order matches .dts
426 * __unflatten_device_tree - create tree of device_nodes from flat blob
428 * unflattens a device-tree, creating the
429 * tree of struct device_node. It also fills the "name" and "type"
430 * pointers of the nodes so the normal device-tree walking functions
432 * @blob: The blob to expand
433 * @dad: Parent device node
434 * @mynodes: The device_node tree created by the call
435 * @dt_alloc: An allocator that provides a virtual address to memory
436 * for the resulting tree
437 * @detached: if true set OF_DETACHED on @mynodes
439 * Returns NULL on failure or the memory chunk containing the unflattened
440 * device tree on success.
442 void *__unflatten_device_tree(const void *blob
,
443 struct device_node
*dad
,
444 struct device_node
**mynodes
,
445 void *(*dt_alloc
)(u64 size
, u64 align
),
451 pr_debug(" -> unflatten_device_tree()\n");
454 pr_debug("No device tree pointer\n");
458 pr_debug("Unflattening device tree:\n");
459 pr_debug("magic: %08x\n", fdt_magic(blob
));
460 pr_debug("size: %08x\n", fdt_totalsize(blob
));
461 pr_debug("version: %08x\n", fdt_version(blob
));
463 if (fdt_check_header(blob
)) {
464 pr_err("Invalid device tree blob header\n");
468 /* First pass, scan for size */
469 size
= unflatten_dt_nodes(blob
, NULL
, dad
, NULL
);
473 size
= ALIGN(size
, 4);
474 pr_debug(" size is %d, allocating...\n", size
);
476 /* Allocate memory for the expanded device tree */
477 mem
= dt_alloc(size
+ 4, __alignof__(struct device_node
));
481 memset(mem
, 0, size
);
483 *(__be32
*)(mem
+ size
) = cpu_to_be32(0xdeadbeef);
485 pr_debug(" unflattening %p...\n", mem
);
487 /* Second pass, do actual unflattening */
488 unflatten_dt_nodes(blob
, mem
, dad
, mynodes
);
489 if (be32_to_cpup(mem
+ size
) != 0xdeadbeef)
490 pr_warning("End of tree marker overwritten: %08x\n",
491 be32_to_cpup(mem
+ size
));
493 if (detached
&& mynodes
) {
494 of_node_set_flag(*mynodes
, OF_DETACHED
);
495 pr_debug("unflattened tree is detached\n");
498 pr_debug(" <- unflatten_device_tree()\n");
502 static void *kernel_tree_alloc(u64 size
, u64 align
)
504 return kzalloc(size
, GFP_KERNEL
);
507 static DEFINE_MUTEX(of_fdt_unflatten_mutex
);
510 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
511 * @blob: Flat device tree blob
512 * @dad: Parent device node
513 * @mynodes: The device tree created by the call
515 * unflattens the device-tree passed by the firmware, creating the
516 * tree of struct device_node. It also fills the "name" and "type"
517 * pointers of the nodes so the normal device-tree walking functions
520 * Returns NULL on failure or the memory chunk containing the unflattened
521 * device tree on success.
523 void *of_fdt_unflatten_tree(const unsigned long *blob
,
524 struct device_node
*dad
,
525 struct device_node
**mynodes
)
529 mutex_lock(&of_fdt_unflatten_mutex
);
530 mem
= __unflatten_device_tree(blob
, dad
, mynodes
, &kernel_tree_alloc
,
532 mutex_unlock(&of_fdt_unflatten_mutex
);
536 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree
);
538 /* Everything below here references initial_boot_params directly. */
539 int __initdata dt_root_addr_cells
;
540 int __initdata dt_root_size_cells
;
542 void *initial_boot_params
;
544 #ifdef CONFIG_OF_EARLY_FLATTREE
546 static u32 of_fdt_crc32
;
549 * res_mem_reserve_reg() - reserve all memory described in 'reg' property
551 static int __init
__reserved_mem_reserve_reg(unsigned long node
,
554 int t_len
= (dt_root_addr_cells
+ dt_root_size_cells
) * sizeof(__be32
);
555 phys_addr_t base
, size
;
558 int nomap
, first
= 1;
560 prop
= of_get_flat_dt_prop(node
, "reg", &len
);
564 if (len
&& len
% t_len
!= 0) {
565 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
570 nomap
= of_get_flat_dt_prop(node
, "no-map", NULL
) != NULL
;
572 while (len
>= t_len
) {
573 base
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
574 size
= dt_mem_next_cell(dt_root_size_cells
, &prop
);
577 early_init_dt_reserve_memory_arch(base
, size
, nomap
) == 0)
578 pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
579 uname
, &base
, (unsigned long)size
/ SZ_1M
);
581 pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
582 uname
, &base
, (unsigned long)size
/ SZ_1M
);
586 fdt_reserved_mem_save_node(node
, uname
, base
, size
);
594 * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
595 * in /reserved-memory matches the values supported by the current implementation,
596 * also check if ranges property has been provided
598 static int __init
__reserved_mem_check_root(unsigned long node
)
602 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
603 if (!prop
|| be32_to_cpup(prop
) != dt_root_size_cells
)
606 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
607 if (!prop
|| be32_to_cpup(prop
) != dt_root_addr_cells
)
610 prop
= of_get_flat_dt_prop(node
, "ranges", NULL
);
617 * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
619 static int __init
__fdt_scan_reserved_mem(unsigned long node
, const char *uname
,
620 int depth
, void *data
)
625 if (!found
&& depth
== 1 && strcmp(uname
, "reserved-memory") == 0) {
626 if (__reserved_mem_check_root(node
) != 0) {
627 pr_err("Reserved memory: unsupported node format, ignoring\n");
637 } else if (found
&& depth
< 2) {
638 /* scanning of /reserved-memory has been finished */
642 if (!of_fdt_device_is_available(initial_boot_params
, node
))
645 err
= __reserved_mem_reserve_reg(node
, uname
);
646 if (err
== -ENOENT
&& of_get_flat_dt_prop(node
, "size", NULL
))
647 fdt_reserved_mem_save_node(node
, uname
, 0, 0);
654 * early_init_fdt_scan_reserved_mem() - create reserved memory regions
656 * This function grabs memory from early allocator for device exclusive use
657 * defined in device tree structures. It should be called by arch specific code
658 * once the early allocator (i.e. memblock) has been fully activated.
660 void __init
early_init_fdt_scan_reserved_mem(void)
665 if (!initial_boot_params
)
668 /* Process header /memreserve/ fields */
670 fdt_get_mem_rsv(initial_boot_params
, n
, &base
, &size
);
673 early_init_dt_reserve_memory_arch(base
, size
, 0);
676 of_scan_flat_dt(__fdt_scan_reserved_mem
, NULL
);
677 fdt_init_reserved_mem();
681 * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob
683 void __init
early_init_fdt_reserve_self(void)
685 if (!initial_boot_params
)
688 /* Reserve the dtb region */
689 early_init_dt_reserve_memory_arch(__pa(initial_boot_params
),
690 fdt_totalsize(initial_boot_params
),
695 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
696 * @it: callback function
697 * @data: context data pointer
699 * This function is used to scan the flattened device-tree, it is
700 * used to extract the memory information at boot before we can
703 int __init
of_scan_flat_dt(int (*it
)(unsigned long node
,
704 const char *uname
, int depth
,
708 const void *blob
= initial_boot_params
;
710 int offset
, rc
= 0, depth
= -1;
715 for (offset
= fdt_next_node(blob
, -1, &depth
);
716 offset
>= 0 && depth
>= 0 && !rc
;
717 offset
= fdt_next_node(blob
, offset
, &depth
)) {
719 pathp
= fdt_get_name(blob
, offset
, NULL
);
721 pathp
= kbasename(pathp
);
722 rc
= it(offset
, pathp
, depth
, data
);
728 * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each.
729 * @it: callback function
730 * @data: context data pointer
732 * This function is used to scan sub-nodes of a node.
734 int __init
of_scan_flat_dt_subnodes(unsigned long parent
,
735 int (*it
)(unsigned long node
,
740 const void *blob
= initial_boot_params
;
743 fdt_for_each_subnode(node
, blob
, parent
) {
747 pathp
= fdt_get_name(blob
, node
, NULL
);
749 pathp
= kbasename(pathp
);
750 rc
= it(node
, pathp
, data
);
758 * of_get_flat_dt_subnode_by_name - get the subnode by given name
760 * @node: the parent node
761 * @uname: the name of subnode
762 * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none
765 int of_get_flat_dt_subnode_by_name(unsigned long node
, const char *uname
)
767 return fdt_subnode_offset(initial_boot_params
, node
, uname
);
771 * of_get_flat_dt_root - find the root node in the flat blob
773 unsigned long __init
of_get_flat_dt_root(void)
779 * of_get_flat_dt_size - Return the total size of the FDT
781 int __init
of_get_flat_dt_size(void)
783 return fdt_totalsize(initial_boot_params
);
787 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
789 * This function can be used within scan_flattened_dt callback to get
790 * access to properties
792 const void *__init
of_get_flat_dt_prop(unsigned long node
, const char *name
,
795 return fdt_getprop(initial_boot_params
, node
, name
, size
);
799 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
800 * @node: node to test
801 * @compat: compatible string to compare with compatible list.
803 int __init
of_flat_dt_is_compatible(unsigned long node
, const char *compat
)
805 return of_fdt_is_compatible(initial_boot_params
, node
, compat
);
809 * of_flat_dt_match - Return true if node matches a list of compatible values
811 int __init
of_flat_dt_match(unsigned long node
, const char *const *compat
)
813 return of_fdt_match(initial_boot_params
, node
, compat
);
817 * of_get_flat_dt_prop - Given a node in the flat blob, return the phandle
819 uint32_t __init
of_get_flat_dt_phandle(unsigned long node
)
821 return fdt_get_phandle(initial_boot_params
, node
);
824 struct fdt_scan_status
{
829 int (*iterator
)(unsigned long node
, const char *uname
, int depth
, void *data
);
833 const char * __init
of_flat_dt_get_machine_name(void)
836 unsigned long dt_root
= of_get_flat_dt_root();
838 name
= of_get_flat_dt_prop(dt_root
, "model", NULL
);
840 name
= of_get_flat_dt_prop(dt_root
, "compatible", NULL
);
845 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
847 * @default_match: A machine specific ptr to return in case of no match.
848 * @get_next_compat: callback function to return next compatible match table.
850 * Iterate through machine match tables to find the best match for the machine
851 * compatible string in the FDT.
853 const void * __init
of_flat_dt_match_machine(const void *default_match
,
854 const void * (*get_next_compat
)(const char * const**))
856 const void *data
= NULL
;
857 const void *best_data
= default_match
;
858 const char *const *compat
;
859 unsigned long dt_root
;
860 unsigned int best_score
= ~1, score
= 0;
862 dt_root
= of_get_flat_dt_root();
863 while ((data
= get_next_compat(&compat
))) {
864 score
= of_flat_dt_match(dt_root
, compat
);
865 if (score
> 0 && score
< best_score
) {
874 pr_err("\n unrecognized device tree list:\n[ ");
876 prop
= of_get_flat_dt_prop(dt_root
, "compatible", &size
);
879 printk("'%s' ", prop
);
880 size
-= strlen(prop
) + 1;
881 prop
+= strlen(prop
) + 1;
888 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
893 #ifdef CONFIG_BLK_DEV_INITRD
894 static void __early_init_dt_declare_initrd(unsigned long start
,
897 /* ARM64 would cause a BUG to occur here when CONFIG_DEBUG_VM is
898 * enabled since __va() is called too early. ARM64 does make use
899 * of phys_initrd_start/phys_initrd_size so we can skip this
902 if (!IS_ENABLED(CONFIG_ARM64
)) {
903 initrd_start
= (unsigned long)__va(start
);
904 initrd_end
= (unsigned long)__va(end
);
905 initrd_below_start_ok
= 1;
910 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
911 * @node: reference to node containing initrd location ('chosen')
913 static void __init
early_init_dt_check_for_initrd(unsigned long node
)
919 pr_debug("Looking for initrd properties... ");
921 prop
= of_get_flat_dt_prop(node
, "linux,initrd-start", &len
);
924 start
= of_read_number(prop
, len
/4);
926 prop
= of_get_flat_dt_prop(node
, "linux,initrd-end", &len
);
929 end
= of_read_number(prop
, len
/4);
931 __early_init_dt_declare_initrd(start
, end
);
932 phys_initrd_start
= start
;
933 phys_initrd_size
= end
- start
;
935 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
936 (unsigned long long)start
, (unsigned long long)end
);
939 static inline void early_init_dt_check_for_initrd(unsigned long node
)
942 #endif /* CONFIG_BLK_DEV_INITRD */
944 #ifdef CONFIG_SERIAL_EARLYCON
946 int __init
early_init_dt_scan_chosen_stdout(void)
949 const char *p
, *q
, *options
= NULL
;
951 const struct earlycon_id
**p_match
;
952 const void *fdt
= initial_boot_params
;
954 offset
= fdt_path_offset(fdt
, "/chosen");
956 offset
= fdt_path_offset(fdt
, "/chosen@0");
960 p
= fdt_getprop(fdt
, offset
, "stdout-path", &l
);
962 p
= fdt_getprop(fdt
, offset
, "linux,stdout-path", &l
);
966 q
= strchrnul(p
, ':');
971 /* Get the node specified by stdout-path */
972 offset
= fdt_path_offset_namelen(fdt
, p
, l
);
974 pr_warn("earlycon: stdout-path %.*s not found\n", l
, p
);
978 for (p_match
= __earlycon_table
; p_match
< __earlycon_table_end
;
980 const struct earlycon_id
*match
= *p_match
;
982 if (!match
->compatible
[0])
985 if (fdt_node_check_compatible(fdt
, offset
, match
->compatible
))
988 of_setup_earlycon(match
, offset
, options
);
996 * early_init_dt_scan_root - fetch the top level address and size cells
998 int __init
early_init_dt_scan_root(unsigned long node
, const char *uname
,
999 int depth
, void *data
)
1006 dt_root_size_cells
= OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
1007 dt_root_addr_cells
= OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
1009 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
1011 dt_root_size_cells
= be32_to_cpup(prop
);
1012 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells
);
1014 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
1016 dt_root_addr_cells
= be32_to_cpup(prop
);
1017 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells
);
1023 u64 __init
dt_mem_next_cell(int s
, const __be32
**cellp
)
1025 const __be32
*p
= *cellp
;
1028 return of_read_number(p
, s
);
1032 * early_init_dt_scan_memory - Look for and parse memory nodes
1034 int __init
early_init_dt_scan_memory(unsigned long node
, const char *uname
,
1035 int depth
, void *data
)
1037 const char *type
= of_get_flat_dt_prop(node
, "device_type", NULL
);
1038 const __be32
*reg
, *endp
;
1042 /* We are scanning "memory" nodes only */
1043 if (type
== NULL
|| strcmp(type
, "memory") != 0)
1046 reg
= of_get_flat_dt_prop(node
, "linux,usable-memory", &l
);
1048 reg
= of_get_flat_dt_prop(node
, "reg", &l
);
1052 endp
= reg
+ (l
/ sizeof(__be32
));
1053 hotpluggable
= of_get_flat_dt_prop(node
, "hotpluggable", NULL
);
1055 pr_debug("memory scan node %s, reg size %d,\n", uname
, l
);
1057 while ((endp
- reg
) >= (dt_root_addr_cells
+ dt_root_size_cells
)) {
1060 base
= dt_mem_next_cell(dt_root_addr_cells
, ®
);
1061 size
= dt_mem_next_cell(dt_root_size_cells
, ®
);
1065 pr_debug(" - %llx , %llx\n", (unsigned long long)base
,
1066 (unsigned long long)size
);
1068 early_init_dt_add_memory_arch(base
, size
);
1073 if (early_init_dt_mark_hotplug_memory_arch(base
, size
))
1074 pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n",
1081 int __init
early_init_dt_scan_chosen(unsigned long node
, const char *uname
,
1082 int depth
, void *data
)
1087 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth
, uname
);
1089 if (depth
!= 1 || !data
||
1090 (strcmp(uname
, "chosen") != 0 && strcmp(uname
, "chosen@0") != 0))
1093 early_init_dt_check_for_initrd(node
);
1095 /* Retrieve command line */
1096 p
= of_get_flat_dt_prop(node
, "bootargs", &l
);
1097 if (p
!= NULL
&& l
> 0)
1098 strlcpy(data
, p
, min((int)l
, COMMAND_LINE_SIZE
));
1101 * CONFIG_CMDLINE is meant to be a default in case nothing else
1102 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
1103 * is set in which case we override whatever was found earlier.
1105 #ifdef CONFIG_CMDLINE
1106 #if defined(CONFIG_CMDLINE_EXTEND)
1107 strlcat(data
, " ", COMMAND_LINE_SIZE
);
1108 strlcat(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1109 #elif defined(CONFIG_CMDLINE_FORCE)
1110 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1112 /* No arguments from boot loader, use kernel's cmdl*/
1113 if (!((char *)data
)[0])
1114 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1116 #endif /* CONFIG_CMDLINE */
1118 pr_debug("Command line is: %s\n", (char*)data
);
1124 #ifndef MIN_MEMBLOCK_ADDR
1125 #define MIN_MEMBLOCK_ADDR __pa(PAGE_OFFSET)
1127 #ifndef MAX_MEMBLOCK_ADDR
1128 #define MAX_MEMBLOCK_ADDR ((phys_addr_t)~0)
1131 void __init __weak
early_init_dt_add_memory_arch(u64 base
, u64 size
)
1133 const u64 phys_offset
= MIN_MEMBLOCK_ADDR
;
1135 if (size
< PAGE_SIZE
- (base
& ~PAGE_MASK
)) {
1136 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1141 if (!PAGE_ALIGNED(base
)) {
1142 size
-= PAGE_SIZE
- (base
& ~PAGE_MASK
);
1143 base
= PAGE_ALIGN(base
);
1147 if (base
> MAX_MEMBLOCK_ADDR
) {
1148 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
1153 if (base
+ size
- 1 > MAX_MEMBLOCK_ADDR
) {
1154 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
1155 ((u64
)MAX_MEMBLOCK_ADDR
) + 1, base
+ size
);
1156 size
= MAX_MEMBLOCK_ADDR
- base
+ 1;
1159 if (base
+ size
< phys_offset
) {
1160 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
1164 if (base
< phys_offset
) {
1165 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
1167 size
-= phys_offset
- base
;
1170 memblock_add(base
, size
);
1173 int __init __weak
early_init_dt_mark_hotplug_memory_arch(u64 base
, u64 size
)
1175 return memblock_mark_hotplug(base
, size
);
1178 int __init __weak
early_init_dt_reserve_memory_arch(phys_addr_t base
,
1179 phys_addr_t size
, bool nomap
)
1182 return memblock_remove(base
, size
);
1183 return memblock_reserve(base
, size
);
1186 static void * __init
early_init_dt_alloc_memory_arch(u64 size
, u64 align
)
1188 return memblock_alloc(size
, align
);
1191 bool __init
early_init_dt_verify(void *params
)
1196 /* check device tree validity */
1197 if (fdt_check_header(params
))
1200 /* Setup flat device-tree pointer */
1201 initial_boot_params
= params
;
1202 of_fdt_crc32
= crc32_be(~0, initial_boot_params
,
1203 fdt_totalsize(initial_boot_params
));
1208 void __init
early_init_dt_scan_nodes(void)
1212 /* Retrieve various information from the /chosen node */
1213 rc
= of_scan_flat_dt(early_init_dt_scan_chosen
, boot_command_line
);
1215 pr_warn("No chosen node found, continuing without\n");
1217 /* Initialize {size,address}-cells info */
1218 of_scan_flat_dt(early_init_dt_scan_root
, NULL
);
1220 /* Setup memory, calling early_init_dt_add_memory_arch */
1221 of_scan_flat_dt(early_init_dt_scan_memory
, NULL
);
1224 bool __init
early_init_dt_scan(void *params
)
1228 status
= early_init_dt_verify(params
);
1232 early_init_dt_scan_nodes();
1237 * unflatten_device_tree - create tree of device_nodes from flat blob
1239 * unflattens the device-tree passed by the firmware, creating the
1240 * tree of struct device_node. It also fills the "name" and "type"
1241 * pointers of the nodes so the normal device-tree walking functions
1244 void __init
unflatten_device_tree(void)
1246 __unflatten_device_tree(initial_boot_params
, NULL
, &of_root
,
1247 early_init_dt_alloc_memory_arch
, false);
1249 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1250 of_alias_scan(early_init_dt_alloc_memory_arch
);
1252 unittest_unflatten_overlay_base();
1256 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1258 * Copies and unflattens the device-tree passed by the firmware, creating the
1259 * tree of struct device_node. It also fills the "name" and "type"
1260 * pointers of the nodes so the normal device-tree walking functions
1261 * can be used. This should only be used when the FDT memory has not been
1262 * reserved such is the case when the FDT is built-in to the kernel init
1263 * section. If the FDT memory is reserved already then unflatten_device_tree
1264 * should be used instead.
1266 void __init
unflatten_and_copy_device_tree(void)
1271 if (!initial_boot_params
) {
1272 pr_warn("No valid device tree found, continuing without\n");
1276 size
= fdt_totalsize(initial_boot_params
);
1277 dt
= early_init_dt_alloc_memory_arch(size
,
1278 roundup_pow_of_two(FDT_V17_SIZE
));
1281 memcpy(dt
, initial_boot_params
, size
);
1282 initial_boot_params
= dt
;
1284 unflatten_device_tree();
1288 static ssize_t
of_fdt_raw_read(struct file
*filp
, struct kobject
*kobj
,
1289 struct bin_attribute
*bin_attr
,
1290 char *buf
, loff_t off
, size_t count
)
1292 memcpy(buf
, initial_boot_params
+ off
, count
);
1296 static int __init
of_fdt_raw_init(void)
1298 static struct bin_attribute of_fdt_raw_attr
=
1299 __BIN_ATTR(fdt
, S_IRUSR
, of_fdt_raw_read
, NULL
, 0);
1301 if (!initial_boot_params
)
1304 if (of_fdt_crc32
!= crc32_be(~0, initial_boot_params
,
1305 fdt_totalsize(initial_boot_params
))) {
1306 pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n");
1309 of_fdt_raw_attr
.size
= fdt_totalsize(initial_boot_params
);
1310 return sysfs_create_bin_file(firmware_kobj
, &of_fdt_raw_attr
);
1312 late_initcall(of_fdt_raw_init
);
1315 #endif /* CONFIG_OF_EARLY_FLATTREE */