2 * Functions for working with the Flattened Device Tree data format
4 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
5 * benh@kernel.crashing.org
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 as published by the Free Software Foundation.
12 #include <linux/kernel.h>
13 #include <linux/initrd.h>
14 #include <linux/memblock.h>
15 #include <linux/module.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>
24 #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
26 #include <asm/machdep.h>
27 #endif /* CONFIG_PPC */
31 char *of_fdt_get_string(struct boot_param_header
*blob
, u32 offset
)
33 return ((char *)blob
) +
34 be32_to_cpu(blob
->off_dt_strings
) + offset
;
38 * of_fdt_get_property - Given a node in the given flat blob, return
41 void *of_fdt_get_property(struct boot_param_header
*blob
,
42 unsigned long node
, const char *name
,
45 unsigned long p
= node
;
48 u32 tag
= be32_to_cpup((__be32
*)p
);
55 if (tag
!= OF_DT_PROP
)
58 sz
= be32_to_cpup((__be32
*)p
);
59 noff
= be32_to_cpup((__be32
*)(p
+ 4));
61 if (be32_to_cpu(blob
->version
) < 0x10)
62 p
= ALIGN(p
, sz
>= 8 ? 8 : 4);
64 nstr
= of_fdt_get_string(blob
, noff
);
66 pr_warning("Can't find property index name !\n");
69 if (strcmp(name
, nstr
) == 0) {
80 * of_fdt_is_compatible - Return true if given node from the given blob has
81 * compat in its compatible list
82 * @blob: A device tree blob
84 * @compat: compatible string to compare with compatible list.
86 * On match, returns a non-zero value with smaller values returned for more
87 * specific compatible values.
89 int of_fdt_is_compatible(struct boot_param_header
*blob
,
90 unsigned long node
, const char *compat
)
93 unsigned long cplen
, l
, score
= 0;
95 cp
= of_fdt_get_property(blob
, node
, "compatible", &cplen
);
100 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0)
111 * of_fdt_match - Return true if node matches a list of compatible values
113 int of_fdt_match(struct boot_param_header
*blob
, unsigned long node
,
114 const char *const *compat
)
116 unsigned int tmp
, score
= 0;
122 tmp
= of_fdt_is_compatible(blob
, node
, *compat
);
123 if (tmp
&& (score
== 0 || (tmp
< score
)))
131 static void *unflatten_dt_alloc(void **mem
, unsigned long size
,
136 *mem
= PTR_ALIGN(*mem
, align
);
144 * unflatten_dt_node - Alloc and populate a device_node from the flat tree
145 * @blob: The parent device tree blob
146 * @mem: Memory chunk to use for allocating device nodes and properties
147 * @p: pointer to node in flat tree
148 * @dad: Parent struct device_node
149 * @allnextpp: pointer to ->allnext from last allocated device_node
150 * @fpsize: Size of the node path up at the current depth.
152 static void * unflatten_dt_node(struct boot_param_header
*blob
,
155 struct device_node
*dad
,
156 struct device_node
***allnextpp
,
157 unsigned long fpsize
)
159 struct device_node
*np
;
160 struct property
*pp
, **prev_pp
= NULL
;
163 unsigned int l
, allocl
;
167 tag
= be32_to_cpup(*p
);
168 if (tag
!= OF_DT_BEGIN_NODE
) {
169 pr_err("Weird tag at start of node: %x\n", tag
);
174 l
= allocl
= strlen(pathp
) + 1;
175 *p
= PTR_ALIGN(*p
+ l
, 4);
177 /* version 0x10 has a more compact unit name here instead of the full
178 * path. we accumulate the full path size using "fpsize", we'll rebuild
179 * it later. We detect this because the first character of the name is
182 if ((*pathp
) != '/') {
185 /* root node: special case. fpsize accounts for path
186 * plus terminating zero. root node only has '/', so
187 * fpsize should be 2, but we want to avoid the first
188 * level nodes to have two '/' so we use fpsize 1 here
195 /* account for '/' and path size minus terminal 0
203 np
= unflatten_dt_alloc(&mem
, sizeof(struct device_node
) + allocl
,
204 __alignof__(struct device_node
));
208 np
->full_name
= fn
= ((char *)np
) + sizeof(*np
);
210 /* rebuild full path for new format */
211 if (dad
&& dad
->parent
) {
212 strcpy(fn
, dad
->full_name
);
214 if ((strlen(fn
) + l
+ 1) != allocl
) {
215 pr_debug("%s: p: %d, l: %d, a: %d\n",
216 pathp
, (int)strlen(fn
),
224 memcpy(fn
, pathp
, l
);
226 prev_pp
= &np
->properties
;
228 *allnextpp
= &np
->allnext
;
231 /* we temporarily use the next field as `last_child'*/
232 if (dad
->next
== NULL
)
235 dad
->next
->sibling
= np
;
239 /* process properties */
244 tag
= be32_to_cpup(*p
);
245 if (tag
== OF_DT_NOP
) {
249 if (tag
!= OF_DT_PROP
)
252 sz
= be32_to_cpup(*p
);
253 noff
= be32_to_cpup(*p
+ 4);
255 if (be32_to_cpu(blob
->version
) < 0x10)
256 *p
= PTR_ALIGN(*p
, sz
>= 8 ? 8 : 4);
258 pname
= of_fdt_get_string(blob
, noff
);
260 pr_info("Can't find property name in list !\n");
263 if (strcmp(pname
, "name") == 0)
265 l
= strlen(pname
) + 1;
266 pp
= unflatten_dt_alloc(&mem
, sizeof(struct property
),
267 __alignof__(struct property
));
269 /* We accept flattened tree phandles either in
270 * ePAPR-style "phandle" properties, or the
271 * legacy "linux,phandle" properties. If both
272 * appear and have different values, things
273 * will get weird. Don't do that. */
274 if ((strcmp(pname
, "phandle") == 0) ||
275 (strcmp(pname
, "linux,phandle") == 0)) {
276 if (np
->phandle
== 0)
277 np
->phandle
= be32_to_cpup((__be32
*)*p
);
279 /* And we process the "ibm,phandle" property
280 * used in pSeries dynamic device tree
282 if (strcmp(pname
, "ibm,phandle") == 0)
283 np
->phandle
= be32_to_cpup((__be32
*)*p
);
290 *p
= PTR_ALIGN((*p
) + sz
, 4);
292 /* with version 0x10 we may not have the name property, recreate
293 * it here from the unit name if absent
296 char *p1
= pathp
, *ps
= pathp
, *pa
= NULL
;
309 pp
= unflatten_dt_alloc(&mem
, sizeof(struct property
) + sz
,
310 __alignof__(struct property
));
317 memcpy(pp
->value
, ps
, sz
- 1);
318 ((char *)pp
->value
)[sz
- 1] = 0;
319 pr_debug("fixed up name for %s -> %s\n", pathp
,
325 np
->name
= of_get_property(np
, "name", NULL
);
326 np
->type
= of_get_property(np
, "device_type", NULL
);
333 while (tag
== OF_DT_BEGIN_NODE
|| tag
== OF_DT_NOP
) {
334 if (tag
== OF_DT_NOP
)
337 mem
= unflatten_dt_node(blob
, mem
, p
, np
, allnextpp
,
339 tag
= be32_to_cpup(*p
);
341 if (tag
!= OF_DT_END_NODE
) {
342 pr_err("Weird tag at end of node: %x\n", tag
);
350 * __unflatten_device_tree - create tree of device_nodes from flat blob
352 * unflattens a device-tree, creating the
353 * tree of struct device_node. It also fills the "name" and "type"
354 * pointers of the nodes so the normal device-tree walking functions
356 * @blob: The blob to expand
357 * @mynodes: The device_node tree created by the call
358 * @dt_alloc: An allocator that provides a virtual address to memory
359 * for the resulting tree
361 static void __unflatten_device_tree(struct boot_param_header
*blob
,
362 struct device_node
**mynodes
,
363 void * (*dt_alloc
)(u64 size
, u64 align
))
367 struct device_node
**allnextp
= mynodes
;
369 pr_debug(" -> unflatten_device_tree()\n");
372 pr_debug("No device tree pointer\n");
376 pr_debug("Unflattening device tree:\n");
377 pr_debug("magic: %08x\n", be32_to_cpu(blob
->magic
));
378 pr_debug("size: %08x\n", be32_to_cpu(blob
->totalsize
));
379 pr_debug("version: %08x\n", be32_to_cpu(blob
->version
));
381 if (be32_to_cpu(blob
->magic
) != OF_DT_HEADER
) {
382 pr_err("Invalid device tree blob header\n");
386 /* First pass, scan for size */
387 start
= ((void *)blob
) + be32_to_cpu(blob
->off_dt_struct
);
388 size
= (unsigned long)unflatten_dt_node(blob
, 0, &start
, NULL
, NULL
, 0);
389 size
= ALIGN(size
, 4);
391 pr_debug(" size is %lx, allocating...\n", size
);
393 /* Allocate memory for the expanded device tree */
394 mem
= dt_alloc(size
+ 4, __alignof__(struct device_node
));
395 memset(mem
, 0, size
);
397 *(__be32
*)(mem
+ size
) = cpu_to_be32(0xdeadbeef);
399 pr_debug(" unflattening %p...\n", mem
);
401 /* Second pass, do actual unflattening */
402 start
= ((void *)blob
) + be32_to_cpu(blob
->off_dt_struct
);
403 unflatten_dt_node(blob
, mem
, &start
, NULL
, &allnextp
, 0);
404 if (be32_to_cpup(start
) != OF_DT_END
)
405 pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start
));
406 if (be32_to_cpup(mem
+ size
) != 0xdeadbeef)
407 pr_warning("End of tree marker overwritten: %08x\n",
408 be32_to_cpup(mem
+ size
));
411 pr_debug(" <- unflatten_device_tree()\n");
414 static void *kernel_tree_alloc(u64 size
, u64 align
)
416 return kzalloc(size
, GFP_KERNEL
);
420 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
422 * unflattens the device-tree passed by the firmware, creating the
423 * tree of struct device_node. It also fills the "name" and "type"
424 * pointers of the nodes so the normal device-tree walking functions
427 void of_fdt_unflatten_tree(unsigned long *blob
,
428 struct device_node
**mynodes
)
430 struct boot_param_header
*device_tree
=
431 (struct boot_param_header
*)blob
;
432 __unflatten_device_tree(device_tree
, mynodes
, &kernel_tree_alloc
);
434 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree
);
436 /* Everything below here references initial_boot_params directly. */
437 int __initdata dt_root_addr_cells
;
438 int __initdata dt_root_size_cells
;
440 struct boot_param_header
*initial_boot_params
;
442 #ifdef CONFIG_OF_EARLY_FLATTREE
445 * res_mem_reserve_reg() - reserve all memory described in 'reg' property
447 static int __init
__reserved_mem_reserve_reg(unsigned long node
,
450 int t_len
= (dt_root_addr_cells
+ dt_root_size_cells
) * sizeof(__be32
);
451 phys_addr_t base
, size
;
454 int nomap
, first
= 1;
456 prop
= of_get_flat_dt_prop(node
, "reg", &len
);
460 if (len
&& len
% t_len
!= 0) {
461 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
466 nomap
= of_get_flat_dt_prop(node
, "no-map", NULL
) != NULL
;
468 while (len
>= t_len
) {
469 base
= dt_mem_next_cell(dt_root_addr_cells
, &prop
);
470 size
= dt_mem_next_cell(dt_root_size_cells
, &prop
);
473 early_init_dt_reserve_memory_arch(base
, size
, nomap
) == 0)
474 pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
475 uname
, &base
, (unsigned long)size
/ SZ_1M
);
477 pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
478 uname
, &base
, (unsigned long)size
/ SZ_1M
);
482 fdt_reserved_mem_save_node(node
, uname
, base
, size
);
490 * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
491 * in /reserved-memory matches the values supported by the current implementation,
492 * also check if ranges property has been provided
494 static int __init
__reserved_mem_check_root(unsigned long node
)
498 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
499 if (!prop
|| be32_to_cpup(prop
) != dt_root_size_cells
)
502 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
503 if (!prop
|| be32_to_cpup(prop
) != dt_root_addr_cells
)
506 prop
= of_get_flat_dt_prop(node
, "ranges", NULL
);
513 * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
515 static int __init
__fdt_scan_reserved_mem(unsigned long node
, const char *uname
,
516 int depth
, void *data
)
522 if (!found
&& depth
== 1 && strcmp(uname
, "reserved-memory") == 0) {
523 if (__reserved_mem_check_root(node
) != 0) {
524 pr_err("Reserved memory: unsupported node format, ignoring\n");
534 } else if (found
&& depth
< 2) {
535 /* scanning of /reserved-memory has been finished */
539 status
= of_get_flat_dt_prop(node
, "status", NULL
);
540 if (status
&& strcmp(status
, "okay") != 0 && strcmp(status
, "ok") != 0)
543 err
= __reserved_mem_reserve_reg(node
, uname
);
544 if (err
== -ENOENT
&& of_get_flat_dt_prop(node
, "size", NULL
))
545 fdt_reserved_mem_save_node(node
, uname
, 0, 0);
552 * early_init_fdt_scan_reserved_mem() - create reserved memory regions
554 * This function grabs memory from early allocator for device exclusive use
555 * defined in device tree structures. It should be called by arch specific code
556 * once the early allocator (i.e. memblock) has been fully activated.
558 void __init
early_init_fdt_scan_reserved_mem(void)
560 if (!initial_boot_params
)
563 of_scan_flat_dt(__fdt_scan_reserved_mem
, NULL
);
564 fdt_init_reserved_mem();
568 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
569 * @it: callback function
570 * @data: context data pointer
572 * This function is used to scan the flattened device-tree, it is
573 * used to extract the memory information at boot before we can
576 int __init
of_scan_flat_dt(int (*it
)(unsigned long node
,
577 const char *uname
, int depth
,
581 unsigned long p
= ((unsigned long)initial_boot_params
) +
582 be32_to_cpu(initial_boot_params
->off_dt_struct
);
587 u32 tag
= be32_to_cpup((__be32
*)p
);
591 if (tag
== OF_DT_END_NODE
) {
595 if (tag
== OF_DT_NOP
)
597 if (tag
== OF_DT_END
)
599 if (tag
== OF_DT_PROP
) {
600 u32 sz
= be32_to_cpup((__be32
*)p
);
602 if (be32_to_cpu(initial_boot_params
->version
) < 0x10)
603 p
= ALIGN(p
, sz
>= 8 ? 8 : 4);
608 if (tag
!= OF_DT_BEGIN_NODE
) {
609 pr_err("Invalid tag %x in flat device tree!\n", tag
);
614 p
= ALIGN(p
+ strlen(pathp
) + 1, 4);
616 pathp
= kbasename(pathp
);
617 rc
= it(p
, pathp
, depth
, data
);
626 * of_get_flat_dt_root - find the root node in the flat blob
628 unsigned long __init
of_get_flat_dt_root(void)
630 unsigned long p
= ((unsigned long)initial_boot_params
) +
631 be32_to_cpu(initial_boot_params
->off_dt_struct
);
633 while (be32_to_cpup((__be32
*)p
) == OF_DT_NOP
)
635 BUG_ON(be32_to_cpup((__be32
*)p
) != OF_DT_BEGIN_NODE
);
637 return ALIGN(p
+ strlen((char *)p
) + 1, 4);
641 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
643 * This function can be used within scan_flattened_dt callback to get
644 * access to properties
646 void *__init
of_get_flat_dt_prop(unsigned long node
, const char *name
,
649 return of_fdt_get_property(initial_boot_params
, node
, name
, size
);
653 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
654 * @node: node to test
655 * @compat: compatible string to compare with compatible list.
657 int __init
of_flat_dt_is_compatible(unsigned long node
, const char *compat
)
659 return of_fdt_is_compatible(initial_boot_params
, node
, compat
);
663 * of_flat_dt_match - Return true if node matches a list of compatible values
665 int __init
of_flat_dt_match(unsigned long node
, const char *const *compat
)
667 return of_fdt_match(initial_boot_params
, node
, compat
);
670 struct fdt_scan_status
{
675 int (*iterator
)(unsigned long node
, const char *uname
, int depth
, void *data
);
680 * fdt_scan_node_by_path - iterator for of_scan_flat_dt_by_path function
682 static int __init
fdt_scan_node_by_path(unsigned long node
, const char *uname
,
683 int depth
, void *data
)
685 struct fdt_scan_status
*st
= data
;
688 * if scan at the requested fdt node has been completed,
689 * return -ENXIO to abort further scanning
691 if (depth
<= st
->depth
)
694 /* requested fdt node has been found, so call iterator function */
696 return st
->iterator(node
, uname
, depth
, st
->data
);
698 /* check if scanning automata is entering next level of fdt nodes */
699 if (depth
== st
->depth
+ 1 &&
700 strncmp(st
->name
, uname
, st
->namelen
) == 0 &&
701 uname
[st
->namelen
] == 0) {
703 if (st
->name
[st
->namelen
] == 0) {
706 const char *next
= st
->name
+ st
->namelen
+ 1;
708 st
->namelen
= strcspn(next
, "/");
713 /* scan next fdt node */
718 * of_scan_flat_dt_by_path - scan flattened tree blob and call callback on each
719 * child of the given path.
720 * @path: path to start searching for children
721 * @it: callback function
722 * @data: context data pointer
724 * This function is used to scan the flattened device-tree starting from the
725 * node given by path. It is used to extract information (like reserved
726 * memory), which is required on ealy boot before we can unflatten the tree.
728 int __init
of_scan_flat_dt_by_path(const char *path
,
729 int (*it
)(unsigned long node
, const char *name
, int depth
, void *data
),
732 struct fdt_scan_status st
= {path
, 0, -1, 0, it
, data
};
735 if (initial_boot_params
)
736 ret
= of_scan_flat_dt(fdt_scan_node_by_path
, &st
);
740 else if (ret
== -ENXIO
) /* scan has been completed */
746 const char * __init
of_flat_dt_get_machine_name(void)
749 unsigned long dt_root
= of_get_flat_dt_root();
751 name
= of_get_flat_dt_prop(dt_root
, "model", NULL
);
753 name
= of_get_flat_dt_prop(dt_root
, "compatible", NULL
);
758 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
760 * @default_match: A machine specific ptr to return in case of no match.
761 * @get_next_compat: callback function to return next compatible match table.
763 * Iterate through machine match tables to find the best match for the machine
764 * compatible string in the FDT.
766 const void * __init
of_flat_dt_match_machine(const void *default_match
,
767 const void * (*get_next_compat
)(const char * const**))
769 const void *data
= NULL
;
770 const void *best_data
= default_match
;
771 const char *const *compat
;
772 unsigned long dt_root
;
773 unsigned int best_score
= ~1, score
= 0;
775 dt_root
= of_get_flat_dt_root();
776 while ((data
= get_next_compat(&compat
))) {
777 score
= of_flat_dt_match(dt_root
, compat
);
778 if (score
> 0 && score
< best_score
) {
787 pr_err("\n unrecognized device tree list:\n[ ");
789 prop
= of_get_flat_dt_prop(dt_root
, "compatible", &size
);
792 printk("'%s' ", prop
);
793 size
-= strlen(prop
) + 1;
794 prop
+= strlen(prop
) + 1;
801 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
806 #ifdef CONFIG_BLK_DEV_INITRD
808 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
809 * @node: reference to node containing initrd location ('chosen')
811 static void __init
early_init_dt_check_for_initrd(unsigned long node
)
817 pr_debug("Looking for initrd properties... ");
819 prop
= of_get_flat_dt_prop(node
, "linux,initrd-start", &len
);
822 start
= of_read_number(prop
, len
/4);
824 prop
= of_get_flat_dt_prop(node
, "linux,initrd-end", &len
);
827 end
= of_read_number(prop
, len
/4);
829 initrd_start
= (unsigned long)__va(start
);
830 initrd_end
= (unsigned long)__va(end
);
831 initrd_below_start_ok
= 1;
833 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
834 (unsigned long long)start
, (unsigned long long)end
);
837 static inline void early_init_dt_check_for_initrd(unsigned long node
)
840 #endif /* CONFIG_BLK_DEV_INITRD */
843 * early_init_dt_scan_root - fetch the top level address and size cells
845 int __init
early_init_dt_scan_root(unsigned long node
, const char *uname
,
846 int depth
, void *data
)
853 dt_root_size_cells
= OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
854 dt_root_addr_cells
= OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
856 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
858 dt_root_size_cells
= be32_to_cpup(prop
);
859 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells
);
861 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
863 dt_root_addr_cells
= be32_to_cpup(prop
);
864 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells
);
870 u64 __init
dt_mem_next_cell(int s
, __be32
**cellp
)
875 return of_read_number(p
, s
);
879 * early_init_dt_scan_memory - Look for an parse memory nodes
881 int __init
early_init_dt_scan_memory(unsigned long node
, const char *uname
,
882 int depth
, void *data
)
884 char *type
= of_get_flat_dt_prop(node
, "device_type", NULL
);
888 /* We are scanning "memory" nodes only */
891 * The longtrail doesn't have a device_type on the
892 * /memory node, so look for the node called /memory@0.
894 if (depth
!= 1 || strcmp(uname
, "memory@0") != 0)
896 } else if (strcmp(type
, "memory") != 0)
899 reg
= of_get_flat_dt_prop(node
, "linux,usable-memory", &l
);
901 reg
= of_get_flat_dt_prop(node
, "reg", &l
);
905 endp
= reg
+ (l
/ sizeof(__be32
));
907 pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
908 uname
, l
, reg
[0], reg
[1], reg
[2], reg
[3]);
910 while ((endp
- reg
) >= (dt_root_addr_cells
+ dt_root_size_cells
)) {
913 base
= dt_mem_next_cell(dt_root_addr_cells
, ®
);
914 size
= dt_mem_next_cell(dt_root_size_cells
, ®
);
918 pr_debug(" - %llx , %llx\n", (unsigned long long)base
,
919 (unsigned long long)size
);
921 early_init_dt_add_memory_arch(base
, size
);
927 int __init
early_init_dt_scan_chosen(unsigned long node
, const char *uname
,
928 int depth
, void *data
)
933 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth
, uname
);
935 if (depth
!= 1 || !data
||
936 (strcmp(uname
, "chosen") != 0 && strcmp(uname
, "chosen@0") != 0))
939 early_init_dt_check_for_initrd(node
);
941 /* Retrieve command line */
942 p
= of_get_flat_dt_prop(node
, "bootargs", &l
);
943 if (p
!= NULL
&& l
> 0)
944 strlcpy(data
, p
, min((int)l
, COMMAND_LINE_SIZE
));
947 * CONFIG_CMDLINE is meant to be a default in case nothing else
948 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
949 * is set in which case we override whatever was found earlier.
951 #ifdef CONFIG_CMDLINE
952 #ifndef CONFIG_CMDLINE_FORCE
953 if (!((char *)data
)[0])
955 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
956 #endif /* CONFIG_CMDLINE */
958 pr_debug("Command line is: %s\n", (char*)data
);
964 #ifdef CONFIG_HAVE_MEMBLOCK
965 void __init __weak
early_init_dt_add_memory_arch(u64 base
, u64 size
)
967 const u64 phys_offset
= __pa(PAGE_OFFSET
);
970 if (base
+ size
< phys_offset
) {
971 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
975 if (base
< phys_offset
) {
976 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
978 size
-= phys_offset
- base
;
981 memblock_add(base
, size
);
984 int __init __weak
early_init_dt_reserve_memory_arch(phys_addr_t base
,
985 phys_addr_t size
, bool nomap
)
987 if (memblock_is_region_reserved(base
, size
))
990 return memblock_remove(base
, size
);
991 return memblock_reserve(base
, size
);
995 * called from unflatten_device_tree() to bootstrap devicetree itself
996 * Architectures can override this definition if memblock isn't used
998 void * __init __weak
early_init_dt_alloc_memory_arch(u64 size
, u64 align
)
1000 return __va(memblock_alloc(size
, align
));
1003 int __init __weak
early_init_dt_reserve_memory_arch(phys_addr_t base
,
1004 phys_addr_t size
, bool nomap
)
1006 pr_err("Reserved memory not supported, ignoring range 0x%llx - 0x%llx%s\n",
1007 base
, size
, nomap
? " (nomap)" : "");
1012 bool __init
early_init_dt_scan(void *params
)
1017 /* Setup flat device-tree pointer */
1018 initial_boot_params
= params
;
1020 /* check device tree validity */
1021 if (be32_to_cpu(initial_boot_params
->magic
) != OF_DT_HEADER
) {
1022 initial_boot_params
= NULL
;
1026 /* Retrieve various information from the /chosen node */
1027 of_scan_flat_dt(early_init_dt_scan_chosen
, boot_command_line
);
1029 /* Initialize {size,address}-cells info */
1030 of_scan_flat_dt(early_init_dt_scan_root
, NULL
);
1032 /* Setup memory, calling early_init_dt_add_memory_arch */
1033 of_scan_flat_dt(early_init_dt_scan_memory
, NULL
);
1039 * unflatten_device_tree - create tree of device_nodes from flat blob
1041 * unflattens the device-tree passed by the firmware, creating the
1042 * tree of struct device_node. It also fills the "name" and "type"
1043 * pointers of the nodes so the normal device-tree walking functions
1046 void __init
unflatten_device_tree(void)
1048 __unflatten_device_tree(initial_boot_params
, &of_allnodes
,
1049 early_init_dt_alloc_memory_arch
);
1051 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1052 of_alias_scan(early_init_dt_alloc_memory_arch
);
1056 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1058 * Copies and unflattens the device-tree passed by the firmware, creating the
1059 * tree of struct device_node. It also fills the "name" and "type"
1060 * pointers of the nodes so the normal device-tree walking functions
1061 * can be used. This should only be used when the FDT memory has not been
1062 * reserved such is the case when the FDT is built-in to the kernel init
1063 * section. If the FDT memory is reserved already then unflatten_device_tree
1064 * should be used instead.
1066 void __init
unflatten_and_copy_device_tree(void)
1071 if (!initial_boot_params
) {
1072 pr_warn("No valid device tree found, continuing without\n");
1076 size
= __be32_to_cpu(initial_boot_params
->totalsize
);
1077 dt
= early_init_dt_alloc_memory_arch(size
,
1078 __alignof__(struct boot_param_header
));
1081 memcpy(dt
, initial_boot_params
, size
);
1082 initial_boot_params
= dt
;
1084 unflatten_device_tree();
1087 #endif /* CONFIG_OF_EARLY_FLATTREE */