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/string.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
22 #include <asm/setup.h> /* for COMMAND_LINE_SIZE */
24 #include <asm/machdep.h>
25 #endif /* CONFIG_PPC */
29 char *of_fdt_get_string(struct boot_param_header *blob, u32 offset)
31 return ((char *)blob) +
32 be32_to_cpu(blob->off_dt_strings) + offset;
36 * of_fdt_get_property - Given a node in the given flat blob, return
39 void *of_fdt_get_property(struct boot_param_header *blob,
40 unsigned long node, const char *name,
43 unsigned long p = node;
46 u32 tag = be32_to_cpup((__be32 *)p);
53 if (tag != OF_DT_PROP)
56 sz = be32_to_cpup((__be32 *)p);
57 noff = be32_to_cpup((__be32 *)(p + 4));
59 if (be32_to_cpu(blob->version) < 0x10)
60 p = ALIGN(p, sz >= 8 ? 8 : 4);
62 nstr = of_fdt_get_string(blob, noff);
64 pr_warning("Can't find property index name !\n");
67 if (strcmp(name, nstr) == 0) {
78 * of_fdt_is_compatible - Return true if given node from the given blob has
79 * compat in its compatible list
80 * @blob: A device tree blob
82 * @compat: compatible string to compare with compatible list.
84 * On match, returns a non-zero value with smaller values returned for more
85 * specific compatible values.
87 int of_fdt_is_compatible(struct boot_param_header *blob,
88 unsigned long node, const char *compat)
91 unsigned long cplen, l, score = 0;
93 cp = of_fdt_get_property(blob, node, "compatible", &cplen);
98 if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
109 * of_fdt_match - Return true if node matches a list of compatible values
111 int of_fdt_match(struct boot_param_header *blob, unsigned long node,
112 const char *const *compat)
114 unsigned int tmp, score = 0;
120 tmp = of_fdt_is_compatible(blob, node, *compat);
121 if (tmp && (score == 0 || (tmp < score)))
129 static void *unflatten_dt_alloc(void **mem, unsigned long size,
134 *mem = PTR_ALIGN(*mem, align);
142 * unflatten_dt_node - Alloc and populate a device_node from the flat tree
143 * @blob: The parent device tree blob
144 * @mem: Memory chunk to use for allocating device nodes and properties
145 * @p: pointer to node in flat tree
146 * @dad: Parent struct device_node
147 * @allnextpp: pointer to ->allnext from last allocated device_node
148 * @fpsize: Size of the node path up at the current depth.
150 static void * unflatten_dt_node(struct boot_param_header *blob,
153 struct device_node *dad,
154 struct device_node ***allnextpp,
155 unsigned long fpsize)
157 struct device_node *np;
158 struct property *pp, **prev_pp = NULL;
161 unsigned int l, allocl;
165 tag = be32_to_cpup(*p);
166 if (tag != OF_DT_BEGIN_NODE) {
167 pr_err("Weird tag at start of node: %x\n", tag);
172 l = allocl = strlen(pathp) + 1;
173 *p = PTR_ALIGN(*p + l, 4);
175 /* version 0x10 has a more compact unit name here instead of the full
176 * path. we accumulate the full path size using "fpsize", we'll rebuild
177 * it later. We detect this because the first character of the name is
180 if ((*pathp) != '/') {
183 /* root node: special case. fpsize accounts for path
184 * plus terminating zero. root node only has '/', so
185 * fpsize should be 2, but we want to avoid the first
186 * level nodes to have two '/' so we use fpsize 1 here
193 /* account for '/' and path size minus terminal 0
201 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
202 __alignof__(struct device_node));
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(*p);
243 if (tag == OF_DT_NOP) {
247 if (tag != OF_DT_PROP)
250 sz = be32_to_cpup(*p);
251 noff = be32_to_cpup(*p + 4);
253 if (be32_to_cpu(blob->version) < 0x10)
254 *p = PTR_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);
288 *p = PTR_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(*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))
365 struct device_node **allnextp = mynodes;
367 pr_debug(" -> unflatten_device_tree()\n");
370 pr_debug("No device tree pointer\n");
374 pr_debug("Unflattening device tree:\n");
375 pr_debug("magic: %08x\n", be32_to_cpu(blob->magic));
376 pr_debug("size: %08x\n", be32_to_cpu(blob->totalsize));
377 pr_debug("version: %08x\n", be32_to_cpu(blob->version));
379 if (be32_to_cpu(blob->magic) != OF_DT_HEADER) {
380 pr_err("Invalid device tree blob header\n");
384 /* First pass, scan for size */
385 start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
386 size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);
387 size = ALIGN(size, 4);
389 pr_debug(" size is %lx, allocating...\n", size);
391 /* Allocate memory for the expanded device tree */
392 mem = dt_alloc(size + 4, __alignof__(struct device_node));
393 memset(mem, 0, size);
395 *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
397 pr_debug(" unflattening %p...\n", mem);
399 /* Second pass, do actual unflattening */
400 start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
401 unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);
402 if (be32_to_cpup(start) != OF_DT_END)
403 pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start));
404 if (be32_to_cpup(mem + size) != 0xdeadbeef)
405 pr_warning("End of tree marker overwritten: %08x\n",
406 be32_to_cpup(mem + size));
409 pr_debug(" <- unflatten_device_tree()\n");
412 static void *kernel_tree_alloc(u64 size, u64 align)
414 return kzalloc(size, GFP_KERNEL);
418 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
420 * unflattens the device-tree passed by the firmware, creating the
421 * tree of struct device_node. It also fills the "name" and "type"
422 * pointers of the nodes so the normal device-tree walking functions
425 void of_fdt_unflatten_tree(unsigned long *blob,
426 struct device_node **mynodes)
428 struct boot_param_header *device_tree =
429 (struct boot_param_header *)blob;
430 __unflatten_device_tree(device_tree, mynodes, &kernel_tree_alloc);
432 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
434 /* Everything below here references initial_boot_params directly. */
435 int __initdata dt_root_addr_cells;
436 int __initdata dt_root_size_cells;
438 struct boot_param_header *initial_boot_params;
440 #ifdef CONFIG_OF_EARLY_FLATTREE
443 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
444 * @it: callback function
445 * @data: context data pointer
447 * This function is used to scan the flattened device-tree, it is
448 * used to extract the memory information at boot before we can
451 int __init of_scan_flat_dt(int (*it)(unsigned long node,
452 const char *uname, int depth,
456 unsigned long p = ((unsigned long)initial_boot_params) +
457 be32_to_cpu(initial_boot_params->off_dt_struct);
462 u32 tag = be32_to_cpup((__be32 *)p);
466 if (tag == OF_DT_END_NODE) {
470 if (tag == OF_DT_NOP)
472 if (tag == OF_DT_END)
474 if (tag == OF_DT_PROP) {
475 u32 sz = be32_to_cpup((__be32 *)p);
477 if (be32_to_cpu(initial_boot_params->version) < 0x10)
478 p = ALIGN(p, sz >= 8 ? 8 : 4);
483 if (tag != OF_DT_BEGIN_NODE) {
484 pr_err("Invalid tag %x in flat device tree!\n", tag);
489 p = ALIGN(p + strlen(pathp) + 1, 4);
491 pathp = kbasename(pathp);
492 rc = it(p, pathp, depth, data);
501 * of_get_flat_dt_root - find the root node in the flat blob
503 unsigned long __init of_get_flat_dt_root(void)
505 unsigned long p = ((unsigned long)initial_boot_params) +
506 be32_to_cpu(initial_boot_params->off_dt_struct);
508 while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)
510 BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);
512 return ALIGN(p + strlen((char *)p) + 1, 4);
516 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
518 * This function can be used within scan_flattened_dt callback to get
519 * access to properties
521 void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
524 return of_fdt_get_property(initial_boot_params, node, name, size);
528 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
529 * @node: node to test
530 * @compat: compatible string to compare with compatible list.
532 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
534 return of_fdt_is_compatible(initial_boot_params, node, compat);
538 * of_flat_dt_match - Return true if node matches a list of compatible values
540 int __init of_flat_dt_match(unsigned long node, const char *const *compat)
542 return of_fdt_match(initial_boot_params, node, compat);
545 struct fdt_scan_status {
550 int (*iterator)(unsigned long node, const char *uname, int depth, void *data);
555 * fdt_scan_node_by_path - iterator for of_scan_flat_dt_by_path function
557 static int __init fdt_scan_node_by_path(unsigned long node, const char *uname,
558 int depth, void *data)
560 struct fdt_scan_status *st = data;
563 * if scan at the requested fdt node has been completed,
564 * return -ENXIO to abort further scanning
566 if (depth <= st->depth)
569 /* requested fdt node has been found, so call iterator function */
571 return st->iterator(node, uname, depth, st->data);
573 /* check if scanning automata is entering next level of fdt nodes */
574 if (depth == st->depth + 1 &&
575 strncmp(st->name, uname, st->namelen) == 0 &&
576 uname[st->namelen] == 0) {
578 if (st->name[st->namelen] == 0) {
581 const char *next = st->name + st->namelen + 1;
583 st->namelen = strcspn(next, "/");
588 /* scan next fdt node */
593 * of_scan_flat_dt_by_path - scan flattened tree blob and call callback on each
594 * child of the given path.
595 * @path: path to start searching for children
596 * @it: callback function
597 * @data: context data pointer
599 * This function is used to scan the flattened device-tree starting from the
600 * node given by path. It is used to extract information (like reserved
601 * memory), which is required on ealy boot before we can unflatten the tree.
603 int __init of_scan_flat_dt_by_path(const char *path,
604 int (*it)(unsigned long node, const char *name, int depth, void *data),
607 struct fdt_scan_status st = {path, 0, -1, 0, it, data};
610 if (initial_boot_params)
611 ret = of_scan_flat_dt(fdt_scan_node_by_path, &st);
615 else if (ret == -ENXIO) /* scan has been completed */
621 #ifdef CONFIG_BLK_DEV_INITRD
623 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
624 * @node: reference to node containing initrd location ('chosen')
626 void __init early_init_dt_check_for_initrd(unsigned long node)
632 pr_debug("Looking for initrd properties... ");
634 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
637 start = of_read_number(prop, len/4);
639 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
642 end = of_read_number(prop, len/4);
644 early_init_dt_setup_initrd_arch(start, end);
645 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
646 (unsigned long long)start, (unsigned long long)end);
649 inline void early_init_dt_check_for_initrd(unsigned long node)
652 #endif /* CONFIG_BLK_DEV_INITRD */
655 * early_init_dt_scan_root - fetch the top level address and size cells
657 int __init early_init_dt_scan_root(unsigned long node, const char *uname,
658 int depth, void *data)
665 dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
666 dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
668 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
670 dt_root_size_cells = be32_to_cpup(prop);
671 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
673 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
675 dt_root_addr_cells = be32_to_cpup(prop);
676 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
682 u64 __init dt_mem_next_cell(int s, __be32 **cellp)
687 return of_read_number(p, s);
691 * early_init_dt_scan_memory - Look for an parse memory nodes
693 int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
694 int depth, void *data)
696 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
700 /* We are scanning "memory" nodes only */
703 * The longtrail doesn't have a device_type on the
704 * /memory node, so look for the node called /memory@0.
706 if (depth != 1 || strcmp(uname, "memory@0") != 0)
708 } else if (strcmp(type, "memory") != 0)
711 reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
713 reg = of_get_flat_dt_prop(node, "reg", &l);
717 endp = reg + (l / sizeof(__be32));
719 pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
720 uname, l, reg[0], reg[1], reg[2], reg[3]);
722 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
725 base = dt_mem_next_cell(dt_root_addr_cells, ®);
726 size = dt_mem_next_cell(dt_root_size_cells, ®);
730 pr_debug(" - %llx , %llx\n", (unsigned long long)base,
731 (unsigned long long)size);
733 early_init_dt_add_memory_arch(base, size);
739 int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
740 int depth, void *data)
745 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
747 if (depth != 1 || !data ||
748 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
751 early_init_dt_check_for_initrd(node);
753 /* Retrieve command line */
754 p = of_get_flat_dt_prop(node, "bootargs", &l);
755 if (p != NULL && l > 0)
756 strlcpy(data, p, min((int)l, COMMAND_LINE_SIZE));
759 * CONFIG_CMDLINE is meant to be a default in case nothing else
760 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
761 * is set in which case we override whatever was found earlier.
763 #ifdef CONFIG_CMDLINE
764 #ifndef CONFIG_CMDLINE_FORCE
765 if (!((char *)data)[0])
767 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
768 #endif /* CONFIG_CMDLINE */
770 pr_debug("Command line is: %s\n", (char*)data);
776 #ifdef CONFIG_HAVE_MEMBLOCK
778 * called from unflatten_device_tree() to bootstrap devicetree itself
779 * Architectures can override this definition if memblock isn't used
781 void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align)
783 return __va(memblock_alloc(size, align));
788 * unflatten_device_tree - create tree of device_nodes from flat blob
790 * unflattens the device-tree passed by the firmware, creating the
791 * tree of struct device_node. It also fills the "name" and "type"
792 * pointers of the nodes so the normal device-tree walking functions
795 void __init unflatten_device_tree(void)
797 __unflatten_device_tree(initial_boot_params, &of_allnodes,
798 early_init_dt_alloc_memory_arch);
800 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
801 of_alias_scan(early_init_dt_alloc_memory_arch);
804 #endif /* CONFIG_OF_EARLY_FLATTREE */