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/module.h>
16 #include <linux/of_fdt.h>
17 #include <linux/string.h>
18 #include <linux/errno.h>
19 #include <linux/slab.h>
21 #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
23 #include <asm/machdep.h>
24 #endif /* CONFIG_PPC */
28 char *of_fdt_get_string(struct boot_param_header
*blob
, u32 offset
)
30 return ((char *)blob
) +
31 be32_to_cpu(blob
->off_dt_strings
) + offset
;
35 * of_fdt_get_property - Given a node in the given flat blob, return
38 void *of_fdt_get_property(struct boot_param_header
*blob
,
39 unsigned long node
, const char *name
,
42 unsigned long p
= node
;
45 u32 tag
= be32_to_cpup((__be32
*)p
);
52 if (tag
!= OF_DT_PROP
)
55 sz
= be32_to_cpup((__be32
*)p
);
56 noff
= be32_to_cpup((__be32
*)(p
+ 4));
58 if (be32_to_cpu(blob
->version
) < 0x10)
59 p
= ALIGN(p
, sz
>= 8 ? 8 : 4);
61 nstr
= of_fdt_get_string(blob
, noff
);
63 pr_warning("Can't find property index name !\n");
66 if (strcmp(name
, nstr
) == 0) {
77 * of_fdt_is_compatible - Return true if given node from the given blob has
78 * compat in its compatible list
79 * @blob: A device tree blob
81 * @compat: compatible string to compare with compatible list.
83 * On match, returns a non-zero value with smaller values returned for more
84 * specific compatible values.
86 int of_fdt_is_compatible(struct boot_param_header
*blob
,
87 unsigned long node
, const char *compat
)
90 unsigned long cplen
, l
, score
= 0;
92 cp
= of_fdt_get_property(blob
, node
, "compatible", &cplen
);
97 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0)
108 * of_fdt_match - Return true if node matches a list of compatible values
110 int of_fdt_match(struct boot_param_header
*blob
, unsigned long node
,
111 const char *const *compat
)
113 unsigned int tmp
, score
= 0;
119 tmp
= of_fdt_is_compatible(blob
, node
, *compat
);
120 if (tmp
&& (score
== 0 || (tmp
< score
)))
128 static void *unflatten_dt_alloc(unsigned long *mem
, unsigned long size
,
133 *mem
= ALIGN(*mem
, align
);
141 * unflatten_dt_node - Alloc and populate a device_node from the flat tree
142 * @blob: The parent device tree blob
143 * @mem: Memory chunk to use for allocating device nodes and properties
144 * @p: pointer to node in flat tree
145 * @dad: Parent struct device_node
146 * @allnextpp: pointer to ->allnext from last allocated device_node
147 * @fpsize: Size of the node path up at the current depth.
149 static unsigned long unflatten_dt_node(struct boot_param_header
*blob
,
152 struct device_node
*dad
,
153 struct device_node
***allnextpp
,
154 unsigned long fpsize
)
156 struct device_node
*np
;
157 struct property
*pp
, **prev_pp
= NULL
;
160 unsigned int l
, allocl
;
164 tag
= be32_to_cpup((__be32
*)(*p
));
165 if (tag
!= OF_DT_BEGIN_NODE
) {
166 pr_err("Weird tag at start of node: %x\n", tag
);
171 l
= allocl
= strlen(pathp
) + 1;
172 *p
= ALIGN(*p
+ l
, 4);
174 /* version 0x10 has a more compact unit name here instead of the full
175 * path. we accumulate the full path size using "fpsize", we'll rebuild
176 * it later. We detect this because the first character of the name is
179 if ((*pathp
) != '/') {
182 /* root node: special case. fpsize accounts for path
183 * plus terminating zero. root node only has '/', so
184 * fpsize should be 2, but we want to avoid the first
185 * level nodes to have two '/' so we use fpsize 1 here
192 /* account for '/' and path size minus terminal 0
200 np
= unflatten_dt_alloc(&mem
, sizeof(struct device_node
) + allocl
,
201 __alignof__(struct device_node
));
204 memset(np
, 0, sizeof(*np
));
205 np
->full_name
= fn
= ((char *)np
) + sizeof(*np
);
207 /* rebuild full path for new format */
208 if (dad
&& dad
->parent
) {
209 strcpy(fn
, dad
->full_name
);
211 if ((strlen(fn
) + l
+ 1) != allocl
) {
212 pr_debug("%s: p: %d, l: %d, a: %d\n",
213 pathp
, (int)strlen(fn
),
221 memcpy(fn
, pathp
, l
);
223 prev_pp
= &np
->properties
;
225 *allnextpp
= &np
->allnext
;
228 /* we temporarily use the next field as `last_child'*/
229 if (dad
->next
== NULL
)
232 dad
->next
->sibling
= np
;
235 kref_init(&np
->kref
);
237 /* process properties */
242 tag
= be32_to_cpup((__be32
*)(*p
));
243 if (tag
== OF_DT_NOP
) {
247 if (tag
!= OF_DT_PROP
)
250 sz
= be32_to_cpup((__be32
*)(*p
));
251 noff
= be32_to_cpup((__be32
*)((*p
) + 4));
253 if (be32_to_cpu(blob
->version
) < 0x10)
254 *p
= ALIGN(*p
, sz
>= 8 ? 8 : 4);
256 pname
= of_fdt_get_string(blob
, noff
);
258 pr_info("Can't find property name in list !\n");
261 if (strcmp(pname
, "name") == 0)
263 l
= strlen(pname
) + 1;
264 pp
= unflatten_dt_alloc(&mem
, sizeof(struct property
),
265 __alignof__(struct property
));
267 /* We accept flattened tree phandles either in
268 * ePAPR-style "phandle" properties, or the
269 * legacy "linux,phandle" properties. If both
270 * appear and have different values, things
271 * will get weird. Don't do that. */
272 if ((strcmp(pname
, "phandle") == 0) ||
273 (strcmp(pname
, "linux,phandle") == 0)) {
274 if (np
->phandle
== 0)
275 np
->phandle
= be32_to_cpup((__be32
*)*p
);
277 /* And we process the "ibm,phandle" property
278 * used in pSeries dynamic device tree
280 if (strcmp(pname
, "ibm,phandle") == 0)
281 np
->phandle
= be32_to_cpup((__be32
*)*p
);
284 pp
->value
= (void *)*p
;
288 *p
= ALIGN((*p
) + sz
, 4);
290 /* with version 0x10 we may not have the name property, recreate
291 * it here from the unit name if absent
294 char *p1
= pathp
, *ps
= pathp
, *pa
= NULL
;
307 pp
= unflatten_dt_alloc(&mem
, sizeof(struct property
) + sz
,
308 __alignof__(struct property
));
315 memcpy(pp
->value
, ps
, sz
- 1);
316 ((char *)pp
->value
)[sz
- 1] = 0;
317 pr_debug("fixed up name for %s -> %s\n", pathp
,
323 np
->name
= of_get_property(np
, "name", NULL
);
324 np
->type
= of_get_property(np
, "device_type", NULL
);
331 while (tag
== OF_DT_BEGIN_NODE
|| tag
== OF_DT_NOP
) {
332 if (tag
== OF_DT_NOP
)
335 mem
= unflatten_dt_node(blob
, mem
, p
, np
, allnextpp
,
337 tag
= be32_to_cpup((__be32
*)(*p
));
339 if (tag
!= OF_DT_END_NODE
) {
340 pr_err("Weird tag at end of node: %x\n", tag
);
348 * __unflatten_device_tree - create tree of device_nodes from flat blob
350 * unflattens a device-tree, creating the
351 * tree of struct device_node. It also fills the "name" and "type"
352 * pointers of the nodes so the normal device-tree walking functions
354 * @blob: The blob to expand
355 * @mynodes: The device_node tree created by the call
356 * @dt_alloc: An allocator that provides a virtual address to memory
357 * for the resulting tree
359 static void __unflatten_device_tree(struct boot_param_header
*blob
,
360 struct device_node
**mynodes
,
361 void * (*dt_alloc
)(u64 size
, u64 align
))
363 unsigned long start
, mem
, size
;
364 struct device_node
**allnextp
= mynodes
;
366 pr_debug(" -> unflatten_device_tree()\n");
369 pr_debug("No device tree pointer\n");
373 pr_debug("Unflattening device tree:\n");
374 pr_debug("magic: %08x\n", be32_to_cpu(blob
->magic
));
375 pr_debug("size: %08x\n", be32_to_cpu(blob
->totalsize
));
376 pr_debug("version: %08x\n", be32_to_cpu(blob
->version
));
378 if (be32_to_cpu(blob
->magic
) != OF_DT_HEADER
) {
379 pr_err("Invalid device tree blob header\n");
383 /* First pass, scan for size */
384 start
= ((unsigned long)blob
) +
385 be32_to_cpu(blob
->off_dt_struct
);
386 size
= unflatten_dt_node(blob
, 0, &start
, NULL
, NULL
, 0);
387 size
= (size
| 3) + 1;
389 pr_debug(" size is %lx, allocating...\n", size
);
391 /* Allocate memory for the expanded device tree */
392 mem
= (unsigned long)
393 dt_alloc(size
+ 4, __alignof__(struct device_node
));
395 memset((void *)mem
, 0, size
);
397 ((__be32
*)mem
)[size
/ 4] = cpu_to_be32(0xdeadbeef);
399 pr_debug(" unflattening %lx...\n", mem
);
401 /* Second pass, do actual unflattening */
402 start
= ((unsigned long)blob
) +
403 be32_to_cpu(blob
->off_dt_struct
);
404 unflatten_dt_node(blob
, mem
, &start
, NULL
, &allnextp
, 0);
405 if (be32_to_cpup((__be32
*)start
) != OF_DT_END
)
406 pr_warning("Weird tag at end of tree: %08x\n", *((u32
*)start
));
407 if (be32_to_cpu(((__be32
*)mem
)[size
/ 4]) != 0xdeadbeef)
408 pr_warning("End of tree marker overwritten: %08x\n",
409 be32_to_cpu(((__be32
*)mem
)[size
/ 4]));
412 pr_debug(" <- unflatten_device_tree()\n");
415 static void *kernel_tree_alloc(u64 size
, u64 align
)
417 return kzalloc(size
, GFP_KERNEL
);
421 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
423 * unflattens the device-tree passed by the firmware, creating the
424 * tree of struct device_node. It also fills the "name" and "type"
425 * pointers of the nodes so the normal device-tree walking functions
428 void of_fdt_unflatten_tree(unsigned long *blob
,
429 struct device_node
**mynodes
)
431 struct boot_param_header
*device_tree
=
432 (struct boot_param_header
*)blob
;
433 __unflatten_device_tree(device_tree
, mynodes
, &kernel_tree_alloc
);
435 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree
);
437 /* Everything below here references initial_boot_params directly. */
438 int __initdata dt_root_addr_cells
;
439 int __initdata dt_root_size_cells
;
441 struct boot_param_header
*initial_boot_params
;
443 #ifdef CONFIG_OF_EARLY_FLATTREE
446 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
447 * @it: callback function
448 * @data: context data pointer
450 * This function is used to scan the flattened device-tree, it is
451 * used to extract the memory information at boot before we can
454 int __init
of_scan_flat_dt(int (*it
)(unsigned long node
,
455 const char *uname
, int depth
,
459 unsigned long p
= ((unsigned long)initial_boot_params
) +
460 be32_to_cpu(initial_boot_params
->off_dt_struct
);
465 u32 tag
= be32_to_cpup((__be32
*)p
);
469 if (tag
== OF_DT_END_NODE
) {
473 if (tag
== OF_DT_NOP
)
475 if (tag
== OF_DT_END
)
477 if (tag
== OF_DT_PROP
) {
478 u32 sz
= be32_to_cpup((__be32
*)p
);
480 if (be32_to_cpu(initial_boot_params
->version
) < 0x10)
481 p
= ALIGN(p
, sz
>= 8 ? 8 : 4);
486 if (tag
!= OF_DT_BEGIN_NODE
) {
487 pr_err("Invalid tag %x in flat device tree!\n", tag
);
492 p
= ALIGN(p
+ strlen(pathp
) + 1, 4);
494 pathp
= kbasename(pathp
);
495 rc
= it(p
, pathp
, depth
, data
);
504 * of_get_flat_dt_root - find the root node in the flat blob
506 unsigned long __init
of_get_flat_dt_root(void)
508 unsigned long p
= ((unsigned long)initial_boot_params
) +
509 be32_to_cpu(initial_boot_params
->off_dt_struct
);
511 while (be32_to_cpup((__be32
*)p
) == OF_DT_NOP
)
513 BUG_ON(be32_to_cpup((__be32
*)p
) != OF_DT_BEGIN_NODE
);
515 return ALIGN(p
+ strlen((char *)p
) + 1, 4);
519 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
521 * This function can be used within scan_flattened_dt callback to get
522 * access to properties
524 void *__init
of_get_flat_dt_prop(unsigned long node
, const char *name
,
527 return of_fdt_get_property(initial_boot_params
, node
, name
, size
);
531 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
532 * @node: node to test
533 * @compat: compatible string to compare with compatible list.
535 int __init
of_flat_dt_is_compatible(unsigned long node
, const char *compat
)
537 return of_fdt_is_compatible(initial_boot_params
, node
, compat
);
541 * of_flat_dt_match - Return true if node matches a list of compatible values
543 int __init
of_flat_dt_match(unsigned long node
, const char *const *compat
)
545 return of_fdt_match(initial_boot_params
, node
, compat
);
548 #ifdef CONFIG_BLK_DEV_INITRD
550 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
551 * @node: reference to node containing initrd location ('chosen')
553 void __init
early_init_dt_check_for_initrd(unsigned long node
)
555 unsigned long start
, end
, len
;
558 pr_debug("Looking for initrd properties... ");
560 prop
= of_get_flat_dt_prop(node
, "linux,initrd-start", &len
);
563 start
= of_read_ulong(prop
, len
/4);
565 prop
= of_get_flat_dt_prop(node
, "linux,initrd-end", &len
);
568 end
= of_read_ulong(prop
, len
/4);
570 early_init_dt_setup_initrd_arch(start
, end
);
571 pr_debug("initrd_start=0x%lx initrd_end=0x%lx\n", start
, end
);
574 inline void early_init_dt_check_for_initrd(unsigned long node
)
577 #endif /* CONFIG_BLK_DEV_INITRD */
580 * early_init_dt_scan_root - fetch the top level address and size cells
582 int __init
early_init_dt_scan_root(unsigned long node
, const char *uname
,
583 int depth
, void *data
)
590 dt_root_size_cells
= OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
591 dt_root_addr_cells
= OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
593 prop
= of_get_flat_dt_prop(node
, "#size-cells", NULL
);
595 dt_root_size_cells
= be32_to_cpup(prop
);
596 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells
);
598 prop
= of_get_flat_dt_prop(node
, "#address-cells", NULL
);
600 dt_root_addr_cells
= be32_to_cpup(prop
);
601 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells
);
607 u64 __init
dt_mem_next_cell(int s
, __be32
**cellp
)
612 return of_read_number(p
, s
);
616 * early_init_dt_scan_memory - Look for an parse memory nodes
618 int __init
early_init_dt_scan_memory(unsigned long node
, const char *uname
,
619 int depth
, void *data
)
621 char *type
= of_get_flat_dt_prop(node
, "device_type", NULL
);
625 /* We are scanning "memory" nodes only */
628 * The longtrail doesn't have a device_type on the
629 * /memory node, so look for the node called /memory@0.
631 if (depth
!= 1 || strcmp(uname
, "memory@0") != 0)
633 } else if (strcmp(type
, "memory") != 0)
636 reg
= of_get_flat_dt_prop(node
, "linux,usable-memory", &l
);
638 reg
= of_get_flat_dt_prop(node
, "reg", &l
);
642 endp
= reg
+ (l
/ sizeof(__be32
));
644 pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
645 uname
, l
, reg
[0], reg
[1], reg
[2], reg
[3]);
647 while ((endp
- reg
) >= (dt_root_addr_cells
+ dt_root_size_cells
)) {
650 base
= dt_mem_next_cell(dt_root_addr_cells
, ®
);
651 size
= dt_mem_next_cell(dt_root_size_cells
, ®
);
655 pr_debug(" - %llx , %llx\n", (unsigned long long)base
,
656 (unsigned long long)size
);
658 early_init_dt_add_memory_arch(base
, size
);
664 int __init
early_init_dt_scan_chosen(unsigned long node
, const char *uname
,
665 int depth
, void *data
)
670 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth
, uname
);
672 if (depth
!= 1 || !data
||
673 (strcmp(uname
, "chosen") != 0 && strcmp(uname
, "chosen@0") != 0))
676 early_init_dt_check_for_initrd(node
);
678 /* Retrieve command line */
679 p
= of_get_flat_dt_prop(node
, "bootargs", &l
);
680 if (p
!= NULL
&& l
> 0)
681 strlcpy(data
, p
, min((int)l
, COMMAND_LINE_SIZE
));
684 * CONFIG_CMDLINE is meant to be a default in case nothing else
685 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
686 * is set in which case we override whatever was found earlier.
688 #ifdef CONFIG_CMDLINE
689 #ifndef CONFIG_CMDLINE_FORCE
690 if (!((char *)data
)[0])
692 strlcpy(data
, CONFIG_CMDLINE
, COMMAND_LINE_SIZE
);
693 #endif /* CONFIG_CMDLINE */
695 pr_debug("Command line is: %s\n", (char*)data
);
702 * unflatten_device_tree - create tree of device_nodes from flat blob
704 * unflattens the device-tree passed by the firmware, creating the
705 * tree of struct device_node. It also fills the "name" and "type"
706 * pointers of the nodes so the normal device-tree walking functions
709 void __init
unflatten_device_tree(void)
711 __unflatten_device_tree(initial_boot_params
, &of_allnodes
,
712 early_init_dt_alloc_memory_arch
);
714 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
715 of_alias_scan(early_init_dt_alloc_memory_arch
);
718 #endif /* CONFIG_OF_EARLY_FLATTREE */