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
);
325 static void reverse_nodes(struct device_node
*parent
)
327 struct device_node
*child
, *next
;
330 child
= parent
->child
;
332 reverse_nodes(child
);
334 child
= child
->sibling
;
337 /* Reverse the nodes in the child list */
338 child
= parent
->child
;
339 parent
->child
= NULL
;
341 next
= child
->sibling
;
343 child
->sibling
= parent
->child
;
344 parent
->child
= child
;
350 * unflatten_dt_nodes - Alloc and populate a device_node from the flat tree
351 * @blob: The parent device tree blob
352 * @mem: Memory chunk to use for allocating device nodes and properties
353 * @dad: Parent struct device_node
354 * @nodepp: The device_node tree created by the call
356 * It returns the size of unflattened device tree or error code
358 static int unflatten_dt_nodes(const void *blob
,
360 struct device_node
*dad
,
361 struct device_node
**nodepp
)
363 struct device_node
*root
;
364 int offset
= 0, depth
= 0, initial_depth
= 0;
365 #define FDT_MAX_DEPTH 64
366 struct device_node
*nps
[FDT_MAX_DEPTH
];
374 * We're unflattening device sub-tree if @dad is valid. There are
375 * possibly multiple nodes in the first level of depth. We need
376 * set @depth to 1 to make fdt_next_node() happy as it bails
377 * immediately when negative @depth is found. Otherwise, the device
378 * nodes except the first one won't be unflattened successfully.
381 depth
= initial_depth
= 1;
387 offset
>= 0 && depth
>= initial_depth
;
388 offset
= fdt_next_node(blob
, offset
, &depth
)) {
389 if (WARN_ON_ONCE(depth
>= FDT_MAX_DEPTH
))
392 if (!IS_ENABLED(CONFIG_OF_KOBJ
) &&
393 !of_fdt_device_is_available(blob
, offset
))
396 if (!populate_node(blob
, offset
, &mem
, nps
[depth
],
397 &nps
[depth
+1], dryrun
))
400 if (!dryrun
&& nodepp
&& !*nodepp
)
401 *nodepp
= nps
[depth
+1];
402 if (!dryrun
&& !root
)
406 if (offset
< 0 && offset
!= -FDT_ERR_NOTFOUND
) {
407 pr_err("Error %d processing FDT\n", offset
);
412 * Reverse the child list. Some drivers assumes node order matches .dts
422 * __unflatten_device_tree - create tree of device_nodes from flat blob
424 * unflattens a device-tree, creating the
425 * tree of struct device_node. It also fills the "name" and "type"
426 * pointers of the nodes so the normal device-tree walking functions
428 * @blob: The blob to expand
429 * @dad: Parent device node
430 * @mynodes: The device_node tree created by the call
431 * @dt_alloc: An allocator that provides a virtual address to memory
432 * for the resulting tree
433 * @detached: if true set OF_DETACHED on @mynodes
435 * Returns NULL on failure or the memory chunk containing the unflattened
436 * device tree on success.
438 void *__unflatten_device_tree(const void *blob
,
439 struct device_node
*dad
,
440 struct device_node
**mynodes
,
441 void *(*dt_alloc
)(u64 size
, u64 align
),
447 pr_debug(" -> unflatten_device_tree()\n");
450 pr_debug("No device tree pointer\n");
454 pr_debug("Unflattening device tree:\n");
455 pr_debug("magic: %08x\n", fdt_magic(blob
));
456 pr_debug("size: %08x\n", fdt_totalsize(blob
));
457 pr_debug("version: %08x\n", fdt_version(blob
));
459 if (fdt_check_header(blob
)) {
460 pr_err("Invalid device tree blob header\n");
464 /* First pass, scan for size */
465 size
= unflatten_dt_nodes(blob
, NULL
, dad
, NULL
);
469 size
= ALIGN(size
, 4);
470 pr_debug(" size is %d, allocating...\n", size
);
472 /* Allocate memory for the expanded device tree */
473 mem
= dt_alloc(size
+ 4, __alignof__(struct device_node
));
477 memset(mem
, 0, size
);
479 *(__be32
*)(mem
+ size
) = cpu_to_be32(0xdeadbeef);
481 pr_debug(" unflattening %p...\n", mem
);
483 /* Second pass, do actual unflattening */
484 unflatten_dt_nodes(blob
, mem
, dad
, mynodes
);
485 if (be32_to_cpup(mem
+ size
) != 0xdeadbeef)
486 pr_warning("End of tree marker overwritten: %08x\n",
487 be32_to_cpup(mem
+ size
));
489 if (detached
&& mynodes
) {
490 of_node_set_flag(*mynodes
, OF_DETACHED
);
491 pr_debug("unflattened tree is detached\n");
494 pr_debug(" <- unflatten_device_tree()\n");
498 static void *kernel_tree_alloc(u64 size
, u64 align
)
500 return kzalloc(size
, GFP_KERNEL
);
503 static DEFINE_MUTEX(of_fdt_unflatten_mutex
);
506 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
507 * @blob: Flat device tree blob
508 * @dad: Parent device node
509 * @mynodes: The device tree created by the call
511 * unflattens the device-tree passed by the firmware, creating the
512 * tree of struct device_node. It also fills the "name" and "type"
513 * pointers of the nodes so the normal device-tree walking functions
516 * Returns NULL on failure or the memory chunk containing the unflattened
517 * device tree on success.
519 void *of_fdt_unflatten_tree(const unsigned long *blob
,
520 struct device_node
*dad
,
521 struct device_node
**mynodes
)
525 mutex_lock(&of_fdt_unflatten_mutex
);
526 mem
= __unflatten_device_tree(blob
, dad
, mynodes
, &kernel_tree_alloc
,
528 mutex_unlock(&of_fdt_unflatten_mutex
);
532 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree
);
534 /* Everything below here references initial_boot_params directly. */
535 int __initdata dt_root_addr_cells
;
536 int __initdata dt_root_size_cells
;
538 void *initial_boot_params
;
540 #ifdef CONFIG_OF_EARLY_FLATTREE
542 static u32 of_fdt_crc32
;
545 * res_mem_reserve_reg() - reserve all memory described in 'reg' property
547 static int __init
__reserved_mem_reserve_reg(unsigned long node
,
550 int t_len
= (dt_root_addr_cells
+ dt_root_size_cells
) * sizeof(__be32
);
551 phys_addr_t base
, size
;
554 int nomap
, first
= 1;
556 prop
= of_get_flat_dt_prop(node
, "reg", &len
);
560 if (len
&& len
% t_len
!= 0) {
561 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
566 nomap
= of_get_flat_dt_prop(node
, "no-map", NULL
) != NULL
;
568 while (len
>= t_len
) {
569 base
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
570 size
= dt_mem_next_cell(dt_root_size_cells
, &prop
);
573 early_init_dt_reserve_memory_arch(base
, size
, nomap
) == 0)
574 pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
575 uname
, &base
, (unsigned long)size
/ SZ_1M
);
577 pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
578 uname
, &base
, (unsigned long)size
/ SZ_1M
);
582 fdt_reserved_mem_save_node(node
, uname
, base
, size
);
590 * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
591 * in /reserved-memory matches the values supported by the current implementation,
592 * also check if ranges property has been provided
594 static int __init
__reserved_mem_check_root(unsigned long node
)
598 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
599 if (!prop
|| be32_to_cpup(prop
) != dt_root_size_cells
)
602 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
603 if (!prop
|| be32_to_cpup(prop
) != dt_root_addr_cells
)
606 prop
= of_get_flat_dt_prop(node
, "ranges", NULL
);
613 * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
615 static int __init
__fdt_scan_reserved_mem(unsigned long node
, const char *uname
,
616 int depth
, void *data
)
621 if (!found
&& depth
== 1 && strcmp(uname
, "reserved-memory") == 0) {
622 if (__reserved_mem_check_root(node
) != 0) {
623 pr_err("Reserved memory: unsupported node format, ignoring\n");
633 } else if (found
&& depth
< 2) {
634 /* scanning of /reserved-memory has been finished */
638 if (!of_fdt_device_is_available(initial_boot_params
, node
))
641 err
= __reserved_mem_reserve_reg(node
, uname
);
642 if (err
== -ENOENT
&& of_get_flat_dt_prop(node
, "size", NULL
))
643 fdt_reserved_mem_save_node(node
, uname
, 0, 0);
650 * early_init_fdt_scan_reserved_mem() - create reserved memory regions
652 * This function grabs memory from early allocator for device exclusive use
653 * defined in device tree structures. It should be called by arch specific code
654 * once the early allocator (i.e. memblock) has been fully activated.
656 void __init
early_init_fdt_scan_reserved_mem(void)
661 if (!initial_boot_params
)
664 /* Process header /memreserve/ fields */
666 fdt_get_mem_rsv(initial_boot_params
, n
, &base
, &size
);
669 early_init_dt_reserve_memory_arch(base
, size
, 0);
672 of_scan_flat_dt(__fdt_scan_reserved_mem
, NULL
);
673 fdt_init_reserved_mem();
677 * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob
679 void __init
early_init_fdt_reserve_self(void)
681 if (!initial_boot_params
)
684 /* Reserve the dtb region */
685 early_init_dt_reserve_memory_arch(__pa(initial_boot_params
),
686 fdt_totalsize(initial_boot_params
),
691 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
692 * @it: callback function
693 * @data: context data pointer
695 * This function is used to scan the flattened device-tree, it is
696 * used to extract the memory information at boot before we can
699 int __init
of_scan_flat_dt(int (*it
)(unsigned long node
,
700 const char *uname
, int depth
,
704 const void *blob
= initial_boot_params
;
706 int offset
, rc
= 0, depth
= -1;
711 for (offset
= fdt_next_node(blob
, -1, &depth
);
712 offset
>= 0 && depth
>= 0 && !rc
;
713 offset
= fdt_next_node(blob
, offset
, &depth
)) {
715 pathp
= fdt_get_name(blob
, offset
, NULL
);
717 pathp
= kbasename(pathp
);
718 rc
= it(offset
, pathp
, depth
, data
);
724 * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each.
725 * @it: callback function
726 * @data: context data pointer
728 * This function is used to scan sub-nodes of a node.
730 int __init
of_scan_flat_dt_subnodes(unsigned long parent
,
731 int (*it
)(unsigned long node
,
736 const void *blob
= initial_boot_params
;
739 fdt_for_each_subnode(node
, blob
, parent
) {
743 pathp
= fdt_get_name(blob
, node
, NULL
);
745 pathp
= kbasename(pathp
);
746 rc
= it(node
, pathp
, data
);
754 * of_get_flat_dt_subnode_by_name - get the subnode by given name
756 * @node: the parent node
757 * @uname: the name of subnode
758 * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none
761 int of_get_flat_dt_subnode_by_name(unsigned long node
, const char *uname
)
763 return fdt_subnode_offset(initial_boot_params
, node
, uname
);
767 * of_get_flat_dt_root - find the root node in the flat blob
769 unsigned long __init
of_get_flat_dt_root(void)
775 * of_get_flat_dt_size - Return the total size of the FDT
777 int __init
of_get_flat_dt_size(void)
779 return fdt_totalsize(initial_boot_params
);
783 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
785 * This function can be used within scan_flattened_dt callback to get
786 * access to properties
788 const void *__init
of_get_flat_dt_prop(unsigned long node
, const char *name
,
791 return fdt_getprop(initial_boot_params
, node
, name
, size
);
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 int __init
of_flat_dt_match(unsigned long node
, const char *const *compat
)
809 return of_fdt_match(initial_boot_params
, node
, compat
);
813 * of_get_flat_dt_prop - Given a node in the flat blob, return the phandle
815 uint32_t __init
of_get_flat_dt_phandle(unsigned long node
)
817 return fdt_get_phandle(initial_boot_params
, node
);
820 struct fdt_scan_status
{
825 int (*iterator
)(unsigned long node
, const char *uname
, int depth
, void *data
);
829 const char * __init
of_flat_dt_get_machine_name(void)
832 unsigned long dt_root
= of_get_flat_dt_root();
834 name
= of_get_flat_dt_prop(dt_root
, "model", NULL
);
836 name
= of_get_flat_dt_prop(dt_root
, "compatible", NULL
);
841 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
843 * @default_match: A machine specific ptr to return in case of no match.
844 * @get_next_compat: callback function to return next compatible match table.
846 * Iterate through machine match tables to find the best match for the machine
847 * compatible string in the FDT.
849 const void * __init
of_flat_dt_match_machine(const void *default_match
,
850 const void * (*get_next_compat
)(const char * const**))
852 const void *data
= NULL
;
853 const void *best_data
= default_match
;
854 const char *const *compat
;
855 unsigned long dt_root
;
856 unsigned int best_score
= ~1, score
= 0;
858 dt_root
= of_get_flat_dt_root();
859 while ((data
= get_next_compat(&compat
))) {
860 score
= of_flat_dt_match(dt_root
, compat
);
861 if (score
> 0 && score
< best_score
) {
870 pr_err("\n unrecognized device tree list:\n[ ");
872 prop
= of_get_flat_dt_prop(dt_root
, "compatible", &size
);
875 printk("'%s' ", prop
);
876 size
-= strlen(prop
) + 1;
877 prop
+= strlen(prop
) + 1;
884 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
889 #ifdef CONFIG_BLK_DEV_INITRD
890 static void __early_init_dt_declare_initrd(unsigned long start
,
893 /* ARM64 would cause a BUG to occur here when CONFIG_DEBUG_VM is
894 * enabled since __va() is called too early. ARM64 does make use
895 * of phys_initrd_start/phys_initrd_size so we can skip this
898 if (!IS_ENABLED(CONFIG_ARM64
)) {
899 initrd_start
= (unsigned long)__va(start
);
900 initrd_end
= (unsigned long)__va(end
);
901 initrd_below_start_ok
= 1;
906 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
907 * @node: reference to node containing initrd location ('chosen')
909 static void __init
early_init_dt_check_for_initrd(unsigned long node
)
915 pr_debug("Looking for initrd properties... ");
917 prop
= of_get_flat_dt_prop(node
, "linux,initrd-start", &len
);
920 start
= of_read_number(prop
, len
/4);
922 prop
= of_get_flat_dt_prop(node
, "linux,initrd-end", &len
);
925 end
= of_read_number(prop
, len
/4);
927 __early_init_dt_declare_initrd(start
, end
);
928 phys_initrd_start
= start
;
929 phys_initrd_size
= end
- start
;
931 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
932 (unsigned long long)start
, (unsigned long long)end
);
935 static inline void early_init_dt_check_for_initrd(unsigned long node
)
938 #endif /* CONFIG_BLK_DEV_INITRD */
940 #ifdef CONFIG_SERIAL_EARLYCON
942 int __init
early_init_dt_scan_chosen_stdout(void)
945 const char *p
, *q
, *options
= NULL
;
947 const struct earlycon_id
**p_match
;
948 const void *fdt
= initial_boot_params
;
950 offset
= fdt_path_offset(fdt
, "/chosen");
952 offset
= fdt_path_offset(fdt
, "/chosen@0");
956 p
= fdt_getprop(fdt
, offset
, "stdout-path", &l
);
958 p
= fdt_getprop(fdt
, offset
, "linux,stdout-path", &l
);
962 q
= strchrnul(p
, ':');
967 /* Get the node specified by stdout-path */
968 offset
= fdt_path_offset_namelen(fdt
, p
, l
);
970 pr_warn("earlycon: stdout-path %.*s not found\n", l
, p
);
974 for (p_match
= __earlycon_table
; p_match
< __earlycon_table_end
;
976 const struct earlycon_id
*match
= *p_match
;
978 if (!match
->compatible
[0])
981 if (fdt_node_check_compatible(fdt
, offset
, match
->compatible
))
984 of_setup_earlycon(match
, offset
, options
);
992 * early_init_dt_scan_root - fetch the top level address and size cells
994 int __init
early_init_dt_scan_root(unsigned long node
, const char *uname
,
995 int depth
, void *data
)
1002 dt_root_size_cells
= OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
1003 dt_root_addr_cells
= OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
1005 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
1007 dt_root_size_cells
= be32_to_cpup(prop
);
1008 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells
);
1010 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
1012 dt_root_addr_cells
= be32_to_cpup(prop
);
1013 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells
);
1019 u64 __init
dt_mem_next_cell(int s
, const __be32
**cellp
)
1021 const __be32
*p
= *cellp
;
1024 return of_read_number(p
, s
);
1028 * early_init_dt_scan_memory - Look for and parse memory nodes
1030 int __init
early_init_dt_scan_memory(unsigned long node
, const char *uname
,
1031 int depth
, void *data
)
1033 const char *type
= of_get_flat_dt_prop(node
, "device_type", NULL
);
1034 const __be32
*reg
, *endp
;
1038 /* We are scanning "memory" nodes only */
1039 if (type
== NULL
|| strcmp(type
, "memory") != 0)
1042 reg
= of_get_flat_dt_prop(node
, "linux,usable-memory", &l
);
1044 reg
= of_get_flat_dt_prop(node
, "reg", &l
);
1048 endp
= reg
+ (l
/ sizeof(__be32
));
1049 hotpluggable
= of_get_flat_dt_prop(node
, "hotpluggable", NULL
);
1051 pr_debug("memory scan node %s, reg size %d,\n", uname
, l
);
1053 while ((endp
- reg
) >= (dt_root_addr_cells
+ dt_root_size_cells
)) {
1056 base
= dt_mem_next_cell(dt_root_addr_cells
, ®
);
1057 size
= dt_mem_next_cell(dt_root_size_cells
, ®
);
1061 pr_debug(" - %llx , %llx\n", (unsigned long long)base
,
1062 (unsigned long long)size
);
1064 early_init_dt_add_memory_arch(base
, size
);
1069 if (early_init_dt_mark_hotplug_memory_arch(base
, size
))
1070 pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n",
1077 int __init
early_init_dt_scan_chosen(unsigned long node
, const char *uname
,
1078 int depth
, void *data
)
1083 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth
, uname
);
1085 if (depth
!= 1 || !data
||
1086 (strcmp(uname
, "chosen") != 0 && strcmp(uname
, "chosen@0") != 0))
1089 early_init_dt_check_for_initrd(node
);
1091 /* Retrieve command line */
1092 p
= of_get_flat_dt_prop(node
, "bootargs", &l
);
1093 if (p
!= NULL
&& l
> 0)
1094 strlcpy(data
, p
, min((int)l
, COMMAND_LINE_SIZE
));
1097 * CONFIG_CMDLINE is meant to be a default in case nothing else
1098 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
1099 * is set in which case we override whatever was found earlier.
1101 #ifdef CONFIG_CMDLINE
1102 #if defined(CONFIG_CMDLINE_EXTEND)
1103 strlcat(data
, " ", COMMAND_LINE_SIZE
);
1104 strlcat(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1105 #elif defined(CONFIG_CMDLINE_FORCE)
1106 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1108 /* No arguments from boot loader, use kernel's cmdl*/
1109 if (!((char *)data
)[0])
1110 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
1112 #endif /* CONFIG_CMDLINE */
1114 pr_debug("Command line is: %s\n", (char*)data
);
1120 #ifndef MIN_MEMBLOCK_ADDR
1121 #define MIN_MEMBLOCK_ADDR __pa(PAGE_OFFSET)
1123 #ifndef MAX_MEMBLOCK_ADDR
1124 #define MAX_MEMBLOCK_ADDR ((phys_addr_t)~0)
1127 void __init __weak
early_init_dt_add_memory_arch(u64 base
, u64 size
)
1129 const u64 phys_offset
= MIN_MEMBLOCK_ADDR
;
1131 if (size
< PAGE_SIZE
- (base
& ~PAGE_MASK
)) {
1132 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
1137 if (!PAGE_ALIGNED(base
)) {
1138 size
-= PAGE_SIZE
- (base
& ~PAGE_MASK
);
1139 base
= PAGE_ALIGN(base
);
1143 if (base
> MAX_MEMBLOCK_ADDR
) {
1144 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
1149 if (base
+ size
- 1 > MAX_MEMBLOCK_ADDR
) {
1150 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
1151 ((u64
)MAX_MEMBLOCK_ADDR
) + 1, base
+ size
);
1152 size
= MAX_MEMBLOCK_ADDR
- base
+ 1;
1155 if (base
+ size
< phys_offset
) {
1156 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
1160 if (base
< phys_offset
) {
1161 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
1163 size
-= phys_offset
- base
;
1166 memblock_add(base
, size
);
1169 int __init __weak
early_init_dt_mark_hotplug_memory_arch(u64 base
, u64 size
)
1171 return memblock_mark_hotplug(base
, size
);
1174 int __init __weak
early_init_dt_reserve_memory_arch(phys_addr_t base
,
1175 phys_addr_t size
, bool nomap
)
1178 return memblock_remove(base
, size
);
1179 return memblock_reserve(base
, size
);
1182 static void * __init
early_init_dt_alloc_memory_arch(u64 size
, u64 align
)
1184 return memblock_alloc(size
, align
);
1187 bool __init
early_init_dt_verify(void *params
)
1192 /* check device tree validity */
1193 if (fdt_check_header(params
))
1196 /* Setup flat device-tree pointer */
1197 initial_boot_params
= params
;
1198 of_fdt_crc32
= crc32_be(~0, initial_boot_params
,
1199 fdt_totalsize(initial_boot_params
));
1204 void __init
early_init_dt_scan_nodes(void)
1208 /* Retrieve various information from the /chosen node */
1209 rc
= of_scan_flat_dt(early_init_dt_scan_chosen
, boot_command_line
);
1211 pr_warn("No chosen node found, continuing without\n");
1213 /* Initialize {size,address}-cells info */
1214 of_scan_flat_dt(early_init_dt_scan_root
, NULL
);
1216 /* Setup memory, calling early_init_dt_add_memory_arch */
1217 of_scan_flat_dt(early_init_dt_scan_memory
, NULL
);
1220 bool __init
early_init_dt_scan(void *params
)
1224 status
= early_init_dt_verify(params
);
1228 early_init_dt_scan_nodes();
1233 * unflatten_device_tree - create tree of device_nodes from flat blob
1235 * unflattens the device-tree passed by the firmware, creating the
1236 * tree of struct device_node. It also fills the "name" and "type"
1237 * pointers of the nodes so the normal device-tree walking functions
1240 void __init
unflatten_device_tree(void)
1242 __unflatten_device_tree(initial_boot_params
, NULL
, &of_root
,
1243 early_init_dt_alloc_memory_arch
, false);
1245 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1246 of_alias_scan(early_init_dt_alloc_memory_arch
);
1248 unittest_unflatten_overlay_base();
1252 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1254 * Copies and unflattens the device-tree passed by the firmware, creating the
1255 * tree of struct device_node. It also fills the "name" and "type"
1256 * pointers of the nodes so the normal device-tree walking functions
1257 * can be used. This should only be used when the FDT memory has not been
1258 * reserved such is the case when the FDT is built-in to the kernel init
1259 * section. If the FDT memory is reserved already then unflatten_device_tree
1260 * should be used instead.
1262 void __init
unflatten_and_copy_device_tree(void)
1267 if (!initial_boot_params
) {
1268 pr_warn("No valid device tree found, continuing without\n");
1272 size
= fdt_totalsize(initial_boot_params
);
1273 dt
= early_init_dt_alloc_memory_arch(size
,
1274 roundup_pow_of_two(FDT_V17_SIZE
));
1277 memcpy(dt
, initial_boot_params
, size
);
1278 initial_boot_params
= dt
;
1280 unflatten_device_tree();
1284 static ssize_t
of_fdt_raw_read(struct file
*filp
, struct kobject
*kobj
,
1285 struct bin_attribute
*bin_attr
,
1286 char *buf
, loff_t off
, size_t count
)
1288 memcpy(buf
, initial_boot_params
+ off
, count
);
1292 static int __init
of_fdt_raw_init(void)
1294 static struct bin_attribute of_fdt_raw_attr
=
1295 __BIN_ATTR(fdt
, S_IRUSR
, of_fdt_raw_read
, NULL
, 0);
1297 if (!initial_boot_params
)
1300 if (of_fdt_crc32
!= crc32_be(~0, initial_boot_params
,
1301 fdt_totalsize(initial_boot_params
))) {
1302 pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n");
1305 of_fdt_raw_attr
.size
= fdt_totalsize(initial_boot_params
);
1306 return sysfs_create_bin_file(firmware_kobj
, &of_fdt_raw_attr
);
1308 late_initcall(of_fdt_raw_init
);
1311 #endif /* CONFIG_OF_EARLY_FLATTREE */