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;
236 /* process properties */
241 tag = be32_to_cpup(*p);
242 if (tag == OF_DT_NOP) {
246 if (tag != OF_DT_PROP)
249 sz = be32_to_cpup(*p);
250 noff = be32_to_cpup(*p + 4);
252 if (be32_to_cpu(blob->version) < 0x10)
253 *p = PTR_ALIGN(*p, sz >= 8 ? 8 : 4);
255 pname = of_fdt_get_string(blob, noff);
257 pr_info("Can't find property name in list !\n");
260 if (strcmp(pname, "name") == 0)
262 l = strlen(pname) + 1;
263 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
264 __alignof__(struct property));
266 /* We accept flattened tree phandles either in
267 * ePAPR-style "phandle" properties, or the
268 * legacy "linux,phandle" properties. If both
269 * appear and have different values, things
270 * will get weird. Don't do that. */
271 if ((strcmp(pname, "phandle") == 0) ||
272 (strcmp(pname, "linux,phandle") == 0)) {
273 if (np->phandle == 0)
274 np->phandle = be32_to_cpup((__be32*)*p);
276 /* And we process the "ibm,phandle" property
277 * used in pSeries dynamic device tree
279 if (strcmp(pname, "ibm,phandle") == 0)
280 np->phandle = be32_to_cpup((__be32 *)*p);
287 *p = PTR_ALIGN((*p) + sz, 4);
289 /* with version 0x10 we may not have the name property, recreate
290 * it here from the unit name if absent
293 char *p1 = pathp, *ps = pathp, *pa = NULL;
306 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
307 __alignof__(struct property));
314 memcpy(pp->value, ps, sz - 1);
315 ((char *)pp->value)[sz - 1] = 0;
316 pr_debug("fixed up name for %s -> %s\n", pathp,
322 np->name = of_get_property(np, "name", NULL);
323 np->type = of_get_property(np, "device_type", NULL);
332 while (tag == OF_DT_BEGIN_NODE || tag == OF_DT_NOP) {
333 if (tag == OF_DT_NOP)
336 mem = unflatten_dt_node(blob, mem, p, np, allnextpp,
338 tag = be32_to_cpup(*p);
340 if (tag != OF_DT_END_NODE) {
341 pr_err("Weird tag at end of node: %x\n", tag);
349 * __unflatten_device_tree - create tree of device_nodes from flat blob
351 * unflattens a device-tree, creating the
352 * tree of struct device_node. It also fills the "name" and "type"
353 * pointers of the nodes so the normal device-tree walking functions
355 * @blob: The blob to expand
356 * @mynodes: The device_node tree created by the call
357 * @dt_alloc: An allocator that provides a virtual address to memory
358 * for the resulting tree
360 static void __unflatten_device_tree(struct boot_param_header *blob,
361 struct device_node **mynodes,
362 void * (*dt_alloc)(u64 size, u64 align))
366 struct device_node **allnextp = mynodes;
368 pr_debug(" -> unflatten_device_tree()\n");
371 pr_debug("No device tree pointer\n");
375 pr_debug("Unflattening device tree:\n");
376 pr_debug("magic: %08x\n", be32_to_cpu(blob->magic));
377 pr_debug("size: %08x\n", be32_to_cpu(blob->totalsize));
378 pr_debug("version: %08x\n", be32_to_cpu(blob->version));
380 if (be32_to_cpu(blob->magic) != OF_DT_HEADER) {
381 pr_err("Invalid device tree blob header\n");
385 /* First pass, scan for size */
386 start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
387 size = (unsigned long)unflatten_dt_node(blob, 0, &start, NULL, NULL, 0);
388 size = ALIGN(size, 4);
390 pr_debug(" size is %lx, allocating...\n", size);
392 /* Allocate memory for the expanded device tree */
393 mem = dt_alloc(size + 4, __alignof__(struct device_node));
394 memset(mem, 0, size);
396 *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
398 pr_debug(" unflattening %p...\n", mem);
400 /* Second pass, do actual unflattening */
401 start = ((void *)blob) + be32_to_cpu(blob->off_dt_struct);
402 unflatten_dt_node(blob, mem, &start, NULL, &allnextp, 0);
403 if (be32_to_cpup(start) != OF_DT_END)
404 pr_warning("Weird tag at end of tree: %08x\n", be32_to_cpup(start));
405 if (be32_to_cpup(mem + size) != 0xdeadbeef)
406 pr_warning("End of tree marker overwritten: %08x\n",
407 be32_to_cpup(mem + size));
410 pr_debug(" <- unflatten_device_tree()\n");
413 static void *kernel_tree_alloc(u64 size, u64 align)
415 return kzalloc(size, GFP_KERNEL);
419 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
421 * unflattens the device-tree passed by the firmware, creating the
422 * tree of struct device_node. It also fills the "name" and "type"
423 * pointers of the nodes so the normal device-tree walking functions
426 void of_fdt_unflatten_tree(unsigned long *blob,
427 struct device_node **mynodes)
429 struct boot_param_header *device_tree =
430 (struct boot_param_header *)blob;
431 __unflatten_device_tree(device_tree, mynodes, &kernel_tree_alloc);
433 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
435 /* Everything below here references initial_boot_params directly. */
436 int __initdata dt_root_addr_cells;
437 int __initdata dt_root_size_cells;
439 struct boot_param_header *initial_boot_params;
441 #ifdef CONFIG_OF_EARLY_FLATTREE
444 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
445 * @it: callback function
446 * @data: context data pointer
448 * This function is used to scan the flattened device-tree, it is
449 * used to extract the memory information at boot before we can
452 int __init of_scan_flat_dt(int (*it)(unsigned long node,
453 const char *uname, int depth,
457 unsigned long p = ((unsigned long)initial_boot_params) +
458 be32_to_cpu(initial_boot_params->off_dt_struct);
463 u32 tag = be32_to_cpup((__be32 *)p);
467 if (tag == OF_DT_END_NODE) {
471 if (tag == OF_DT_NOP)
473 if (tag == OF_DT_END)
475 if (tag == OF_DT_PROP) {
476 u32 sz = be32_to_cpup((__be32 *)p);
478 if (be32_to_cpu(initial_boot_params->version) < 0x10)
479 p = ALIGN(p, sz >= 8 ? 8 : 4);
484 if (tag != OF_DT_BEGIN_NODE) {
485 pr_err("Invalid tag %x in flat device tree!\n", tag);
490 p = ALIGN(p + strlen(pathp) + 1, 4);
492 pathp = kbasename(pathp);
493 rc = it(p, pathp, depth, data);
502 * of_get_flat_dt_root - find the root node in the flat blob
504 unsigned long __init of_get_flat_dt_root(void)
506 unsigned long p = ((unsigned long)initial_boot_params) +
507 be32_to_cpu(initial_boot_params->off_dt_struct);
509 while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)
511 BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);
513 return ALIGN(p + strlen((char *)p) + 1, 4);
517 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
519 * This function can be used within scan_flattened_dt callback to get
520 * access to properties
522 void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
525 return of_fdt_get_property(initial_boot_params, node, name, size);
529 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
530 * @node: node to test
531 * @compat: compatible string to compare with compatible list.
533 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
535 return of_fdt_is_compatible(initial_boot_params, node, compat);
539 * of_flat_dt_match - Return true if node matches a list of compatible values
541 int __init of_flat_dt_match(unsigned long node, const char *const *compat)
543 return of_fdt_match(initial_boot_params, node, compat);
546 struct fdt_scan_status {
551 int (*iterator)(unsigned long node, const char *uname, int depth, void *data);
556 * fdt_scan_node_by_path - iterator for of_scan_flat_dt_by_path function
558 static int __init fdt_scan_node_by_path(unsigned long node, const char *uname,
559 int depth, void *data)
561 struct fdt_scan_status *st = data;
564 * if scan at the requested fdt node has been completed,
565 * return -ENXIO to abort further scanning
567 if (depth <= st->depth)
570 /* requested fdt node has been found, so call iterator function */
572 return st->iterator(node, uname, depth, st->data);
574 /* check if scanning automata is entering next level of fdt nodes */
575 if (depth == st->depth + 1 &&
576 strncmp(st->name, uname, st->namelen) == 0 &&
577 uname[st->namelen] == 0) {
579 if (st->name[st->namelen] == 0) {
582 const char *next = st->name + st->namelen + 1;
584 st->namelen = strcspn(next, "/");
589 /* scan next fdt node */
594 * of_scan_flat_dt_by_path - scan flattened tree blob and call callback on each
595 * child of the given path.
596 * @path: path to start searching for children
597 * @it: callback function
598 * @data: context data pointer
600 * This function is used to scan the flattened device-tree starting from the
601 * node given by path. It is used to extract information (like reserved
602 * memory), which is required on ealy boot before we can unflatten the tree.
604 int __init of_scan_flat_dt_by_path(const char *path,
605 int (*it)(unsigned long node, const char *name, int depth, void *data),
608 struct fdt_scan_status st = {path, 0, -1, 0, it, data};
611 if (initial_boot_params)
612 ret = of_scan_flat_dt(fdt_scan_node_by_path, &st);
616 else if (ret == -ENXIO) /* scan has been completed */
622 const char * __init of_flat_dt_get_machine_name(void)
625 unsigned long dt_root = of_get_flat_dt_root();
627 name = of_get_flat_dt_prop(dt_root, "model", NULL);
629 name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
634 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
636 * @default_match: A machine specific ptr to return in case of no match.
637 * @get_next_compat: callback function to return next compatible match table.
639 * Iterate through machine match tables to find the best match for the machine
640 * compatible string in the FDT.
642 const void * __init of_flat_dt_match_machine(const void *default_match,
643 const void * (*get_next_compat)(const char * const**))
645 const void *data = NULL;
646 const void *best_data = default_match;
647 const char *const *compat;
648 unsigned long dt_root;
649 unsigned int best_score = ~1, score = 0;
651 dt_root = of_get_flat_dt_root();
652 while ((data = get_next_compat(&compat))) {
653 score = of_flat_dt_match(dt_root, compat);
654 if (score > 0 && score < best_score) {
663 pr_err("\n unrecognized device tree list:\n[ ");
665 prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
668 printk("'%s' ", prop);
669 size -= strlen(prop) + 1;
670 prop += strlen(prop) + 1;
677 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
682 #ifdef CONFIG_BLK_DEV_INITRD
684 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
685 * @node: reference to node containing initrd location ('chosen')
687 static void __init early_init_dt_check_for_initrd(unsigned long node)
693 pr_debug("Looking for initrd properties... ");
695 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
698 start = of_read_number(prop, len/4);
700 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
703 end = of_read_number(prop, len/4);
705 initrd_start = (unsigned long)__va(start);
706 initrd_end = (unsigned long)__va(end);
707 initrd_below_start_ok = 1;
709 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
710 (unsigned long long)start, (unsigned long long)end);
713 static inline void early_init_dt_check_for_initrd(unsigned long node)
716 #endif /* CONFIG_BLK_DEV_INITRD */
719 * early_init_dt_scan_root - fetch the top level address and size cells
721 int __init early_init_dt_scan_root(unsigned long node, const char *uname,
722 int depth, void *data)
729 dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
730 dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
732 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
734 dt_root_size_cells = be32_to_cpup(prop);
735 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
737 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
739 dt_root_addr_cells = be32_to_cpup(prop);
740 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
746 u64 __init dt_mem_next_cell(int s, __be32 **cellp)
751 return of_read_number(p, s);
755 * early_init_dt_scan_memory - Look for an parse memory nodes
757 int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
758 int depth, void *data)
760 char *type = of_get_flat_dt_prop(node, "device_type", NULL);
764 /* We are scanning "memory" nodes only */
767 * The longtrail doesn't have a device_type on the
768 * /memory node, so look for the node called /memory@0.
770 if (depth != 1 || strcmp(uname, "memory@0") != 0)
772 } else if (strcmp(type, "memory") != 0)
775 reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
777 reg = of_get_flat_dt_prop(node, "reg", &l);
781 endp = reg + (l / sizeof(__be32));
783 pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
784 uname, l, reg[0], reg[1], reg[2], reg[3]);
786 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
789 base = dt_mem_next_cell(dt_root_addr_cells, ®);
790 size = dt_mem_next_cell(dt_root_size_cells, ®);
794 pr_debug(" - %llx , %llx\n", (unsigned long long)base,
795 (unsigned long long)size);
797 early_init_dt_add_memory_arch(base, size);
803 int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
804 int depth, void *data)
809 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
811 if (depth != 1 || !data ||
812 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
815 early_init_dt_check_for_initrd(node);
817 /* Retrieve command line */
818 p = of_get_flat_dt_prop(node, "bootargs", &l);
819 if (p != NULL && l > 0)
820 strlcpy(data, p, min((int)l, COMMAND_LINE_SIZE));
823 * CONFIG_CMDLINE is meant to be a default in case nothing else
824 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
825 * is set in which case we override whatever was found earlier.
827 #ifdef CONFIG_CMDLINE
828 #ifndef CONFIG_CMDLINE_FORCE
829 if (!((char *)data)[0])
831 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
832 #endif /* CONFIG_CMDLINE */
834 pr_debug("Command line is: %s\n", (char*)data);
840 #ifdef CONFIG_HAVE_MEMBLOCK
841 void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
843 const u64 phys_offset = __pa(PAGE_OFFSET);
846 if (base + size < phys_offset) {
847 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
851 if (base < phys_offset) {
852 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
854 size -= phys_offset - base;
857 memblock_add(base, size);
861 * called from unflatten_device_tree() to bootstrap devicetree itself
862 * Architectures can override this definition if memblock isn't used
864 void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align)
866 return __va(memblock_alloc(size, align));
870 bool __init early_init_dt_scan(void *params)
875 /* Setup flat device-tree pointer */
876 initial_boot_params = params;
878 /* check device tree validity */
879 if (be32_to_cpu(initial_boot_params->magic) != OF_DT_HEADER) {
880 initial_boot_params = NULL;
884 /* Retrieve various information from the /chosen node */
885 of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
887 /* Initialize {size,address}-cells info */
888 of_scan_flat_dt(early_init_dt_scan_root, NULL);
890 /* Setup memory, calling early_init_dt_add_memory_arch */
891 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
897 * unflatten_device_tree - create tree of device_nodes from flat blob
899 * unflattens the device-tree passed by the firmware, creating the
900 * tree of struct device_node. It also fills the "name" and "type"
901 * pointers of the nodes so the normal device-tree walking functions
904 void __init unflatten_device_tree(void)
906 __unflatten_device_tree(initial_boot_params, &of_allnodes,
907 early_init_dt_alloc_memory_arch);
909 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
910 of_alias_scan(early_init_dt_alloc_memory_arch);
914 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
916 * Copies and unflattens the device-tree passed by the firmware, creating the
917 * tree of struct device_node. It also fills the "name" and "type"
918 * pointers of the nodes so the normal device-tree walking functions
919 * can be used. This should only be used when the FDT memory has not been
920 * reserved such is the case when the FDT is built-in to the kernel init
921 * section. If the FDT memory is reserved already then unflatten_device_tree
922 * should be used instead.
924 void __init unflatten_and_copy_device_tree(void)
929 if (!initial_boot_params) {
930 pr_warn("No valid device tree found, continuing without\n");
934 size = __be32_to_cpu(initial_boot_params->totalsize);
935 dt = early_init_dt_alloc_memory_arch(size,
936 __alignof__(struct boot_param_header));
939 memcpy(dt, initial_boot_params, size);
940 initial_boot_params = dt;
942 unflatten_device_tree();
945 #endif /* CONFIG_OF_EARLY_FLATTREE */