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/crc32.h>
13 #include <linux/kernel.h>
14 #include <linux/initrd.h>
15 #include <linux/memblock.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 */
32 * of_fdt_limit_memory - limit the number of regions in the /memory node
33 * @limit: maximum entries
35 * Adjust the flattened device tree to have at most 'limit' number of
36 * memory entries in the /memory node. This function may be called
37 * any time after initial_boot_param is set.
39 void of_fdt_limit_memory(int limit)
44 int nr_address_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
45 int nr_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
46 const uint32_t *addr_prop;
47 const uint32_t *size_prop;
51 root_offset = fdt_path_offset(initial_boot_params, "/");
55 addr_prop = fdt_getprop(initial_boot_params, root_offset,
56 "#address-cells", NULL);
58 nr_address_cells = fdt32_to_cpu(*addr_prop);
60 size_prop = fdt_getprop(initial_boot_params, root_offset,
63 nr_size_cells = fdt32_to_cpu(*size_prop);
65 cell_size = sizeof(uint32_t)*(nr_address_cells + nr_size_cells);
67 memory = fdt_path_offset(initial_boot_params, "/memory");
69 val = fdt_getprop(initial_boot_params, memory, "reg", &len);
70 if (len > limit*cell_size) {
71 len = limit*cell_size;
72 pr_debug("Limiting number of entries to %d\n", limit);
73 fdt_setprop(initial_boot_params, memory, "reg", val,
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(const void *blob,
90 unsigned long node, const char *compat)
94 unsigned long l, score = 0;
96 cp = fdt_getprop(blob, node, "compatible", &cplen);
101 if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
112 * of_fdt_is_big_endian - Return true if given node needs BE MMIO accesses
113 * @blob: A device tree blob
114 * @node: node to test
116 * Returns true if the node has a "big-endian" property, or if the kernel
117 * was compiled for BE *and* the node has a "native-endian" property.
118 * Returns false otherwise.
120 bool of_fdt_is_big_endian(const void *blob, unsigned long node)
122 if (fdt_getprop(blob, node, "big-endian", NULL))
124 if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
125 fdt_getprop(blob, node, "native-endian", NULL))
131 * of_fdt_match - Return true if node matches a list of compatible values
133 int of_fdt_match(const void *blob, unsigned long node,
134 const char *const *compat)
136 unsigned int tmp, score = 0;
142 tmp = of_fdt_is_compatible(blob, node, *compat);
143 if (tmp && (score == 0 || (tmp < score)))
151 static void *unflatten_dt_alloc(void **mem, unsigned long size,
156 *mem = PTR_ALIGN(*mem, align);
164 * unflatten_dt_node - Alloc and populate a device_node from the flat tree
165 * @blob: The parent device tree blob
166 * @mem: Memory chunk to use for allocating device nodes and properties
167 * @poffset: pointer to node in flat tree
168 * @dad: Parent struct device_node
169 * @nodepp: The device_node tree created by the call
170 * @fpsize: Size of the node path up at the current depth.
171 * @dryrun: If true, do not allocate device nodes but still calculate needed
174 static void * unflatten_dt_node(const void *blob,
177 struct device_node *dad,
178 struct device_node **nodepp,
179 unsigned long fpsize,
183 struct device_node *np;
184 struct property *pp, **prev_pp = NULL;
186 unsigned int l, allocl;
187 static int depth = 0;
193 pathp = fdt_get_name(blob, *poffset, &l);
199 /* version 0x10 has a more compact unit name here instead of the full
200 * path. we accumulate the full path size using "fpsize", we'll rebuild
201 * it later. We detect this because the first character of the name is
204 if ((*pathp) != '/') {
207 /* root node: special case. fpsize accounts for path
208 * plus terminating zero. root node only has '/', so
209 * fpsize should be 2, but we want to avoid the first
210 * level nodes to have two '/' so we use fpsize 1 here
217 /* account for '/' and path size minus terminal 0
225 np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
226 __alignof__(struct device_node));
230 np->full_name = fn = ((char *)np) + sizeof(*np);
232 /* rebuild full path for new format */
233 if (dad && dad->parent) {
234 strcpy(fn, dad->full_name);
236 if ((strlen(fn) + l + 1) != allocl) {
237 pr_debug("%s: p: %d, l: %d, a: %d\n",
238 pathp, (int)strlen(fn),
246 memcpy(fn, pathp, l);
248 prev_pp = &np->properties;
251 np->sibling = dad->child;
255 /* process properties */
256 for (offset = fdt_first_property_offset(blob, *poffset);
258 (offset = fdt_next_property_offset(blob, offset))) {
262 if (!(p = fdt_getprop_by_offset(blob, offset, &pname, &sz))) {
263 offset = -FDT_ERR_INTERNAL;
268 pr_info("Can't find property name in list !\n");
271 if (strcmp(pname, "name") == 0)
273 pp = unflatten_dt_alloc(&mem, sizeof(struct property),
274 __alignof__(struct property));
276 /* We accept flattened tree phandles either in
277 * ePAPR-style "phandle" properties, or the
278 * legacy "linux,phandle" properties. If both
279 * appear and have different values, things
280 * will get weird. Don't do that. */
281 if ((strcmp(pname, "phandle") == 0) ||
282 (strcmp(pname, "linux,phandle") == 0)) {
283 if (np->phandle == 0)
284 np->phandle = be32_to_cpup(p);
286 /* And we process the "ibm,phandle" property
287 * used in pSeries dynamic device tree
289 if (strcmp(pname, "ibm,phandle") == 0)
290 np->phandle = be32_to_cpup(p);
291 pp->name = (char *)pname;
293 pp->value = (__be32 *)p;
298 /* with version 0x10 we may not have the name property, recreate
299 * it here from the unit name if absent
302 const char *p1 = pathp, *ps = pathp, *pa = NULL;
315 pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
316 __alignof__(struct property));
323 memcpy(pp->value, ps, sz - 1);
324 ((char *)pp->value)[sz - 1] = 0;
325 pr_debug("fixed up name for %s -> %s\n", pathp,
331 np->name = of_get_property(np, "name", NULL);
332 np->type = of_get_property(np, "device_type", NULL);
341 *poffset = fdt_next_node(blob, *poffset, &depth);
344 while (*poffset > 0 && depth > old_depth)
345 mem = unflatten_dt_node(blob, mem, poffset, np, NULL,
348 if (*poffset < 0 && *poffset != -FDT_ERR_NOTFOUND)
349 pr_err("unflatten: error %d processing FDT\n", *poffset);
352 * Reverse the child list. Some drivers assumes node order matches .dts
355 if (!dryrun && np->child) {
356 struct device_node *child = np->child;
359 struct device_node *next = child->sibling;
360 child->sibling = np->child;
373 * __unflatten_device_tree - create tree of device_nodes from flat blob
375 * unflattens a device-tree, creating the
376 * tree of struct device_node. It also fills the "name" and "type"
377 * pointers of the nodes so the normal device-tree walking functions
379 * @blob: The blob to expand
380 * @mynodes: The device_node tree created by the call
381 * @dt_alloc: An allocator that provides a virtual address to memory
382 * for the resulting tree
384 static void __unflatten_device_tree(const void *blob,
385 struct device_node **mynodes,
386 void * (*dt_alloc)(u64 size, u64 align))
392 pr_debug(" -> unflatten_device_tree()\n");
395 pr_debug("No device tree pointer\n");
399 pr_debug("Unflattening device tree:\n");
400 pr_debug("magic: %08x\n", fdt_magic(blob));
401 pr_debug("size: %08x\n", fdt_totalsize(blob));
402 pr_debug("version: %08x\n", fdt_version(blob));
404 if (fdt_check_header(blob)) {
405 pr_err("Invalid device tree blob header\n");
409 /* First pass, scan for size */
411 size = (unsigned long)unflatten_dt_node(blob, NULL, &start, NULL, NULL, 0, true);
412 size = ALIGN(size, 4);
414 pr_debug(" size is %lx, allocating...\n", size);
416 /* Allocate memory for the expanded device tree */
417 mem = dt_alloc(size + 4, __alignof__(struct device_node));
418 memset(mem, 0, size);
420 *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef);
422 pr_debug(" unflattening %p...\n", mem);
424 /* Second pass, do actual unflattening */
426 unflatten_dt_node(blob, mem, &start, NULL, mynodes, 0, false);
427 if (be32_to_cpup(mem + size) != 0xdeadbeef)
428 pr_warning("End of tree marker overwritten: %08x\n",
429 be32_to_cpup(mem + size));
431 pr_debug(" <- unflatten_device_tree()\n");
434 static void *kernel_tree_alloc(u64 size, u64 align)
436 return kzalloc(size, GFP_KERNEL);
440 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob
442 * unflattens the device-tree passed by the firmware, creating the
443 * tree of struct device_node. It also fills the "name" and "type"
444 * pointers of the nodes so the normal device-tree walking functions
447 void of_fdt_unflatten_tree(const unsigned long *blob,
448 struct device_node **mynodes)
450 __unflatten_device_tree(blob, mynodes, &kernel_tree_alloc);
452 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree);
454 /* Everything below here references initial_boot_params directly. */
455 int __initdata dt_root_addr_cells;
456 int __initdata dt_root_size_cells;
458 void *initial_boot_params;
460 #ifdef CONFIG_OF_EARLY_FLATTREE
462 static u32 of_fdt_crc32;
465 * res_mem_reserve_reg() - reserve all memory described in 'reg' property
467 static int __init __reserved_mem_reserve_reg(unsigned long node,
470 int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
471 phys_addr_t base, size;
474 int nomap, first = 1;
476 prop = of_get_flat_dt_prop(node, "reg", &len);
480 if (len && len % t_len != 0) {
481 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n",
486 nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
488 while (len >= t_len) {
489 base = dt_mem_next_cell(dt_root_addr_cells, &prop);
490 size = dt_mem_next_cell(dt_root_size_cells, &prop);
493 early_init_dt_reserve_memory_arch(base, size, nomap) == 0)
494 pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n",
495 uname, &base, (unsigned long)size / SZ_1M);
497 pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n",
498 uname, &base, (unsigned long)size / SZ_1M);
502 fdt_reserved_mem_save_node(node, uname, base, size);
510 * __reserved_mem_check_root() - check if #size-cells, #address-cells provided
511 * in /reserved-memory matches the values supported by the current implementation,
512 * also check if ranges property has been provided
514 static int __init __reserved_mem_check_root(unsigned long node)
518 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
519 if (!prop || be32_to_cpup(prop) != dt_root_size_cells)
522 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
523 if (!prop || be32_to_cpup(prop) != dt_root_addr_cells)
526 prop = of_get_flat_dt_prop(node, "ranges", NULL);
533 * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory
535 static int __init __fdt_scan_reserved_mem(unsigned long node, const char *uname,
536 int depth, void *data)
542 if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) {
543 if (__reserved_mem_check_root(node) != 0) {
544 pr_err("Reserved memory: unsupported node format, ignoring\n");
554 } else if (found && depth < 2) {
555 /* scanning of /reserved-memory has been finished */
559 status = of_get_flat_dt_prop(node, "status", NULL);
560 if (status && strcmp(status, "okay") != 0 && strcmp(status, "ok") != 0)
563 err = __reserved_mem_reserve_reg(node, uname);
564 if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL))
565 fdt_reserved_mem_save_node(node, uname, 0, 0);
572 * early_init_fdt_scan_reserved_mem() - create reserved memory regions
574 * This function grabs memory from early allocator for device exclusive use
575 * defined in device tree structures. It should be called by arch specific code
576 * once the early allocator (i.e. memblock) has been fully activated.
578 void __init early_init_fdt_scan_reserved_mem(void)
583 if (!initial_boot_params)
586 /* Reserve the dtb region */
587 early_init_dt_reserve_memory_arch(__pa(initial_boot_params),
588 fdt_totalsize(initial_boot_params),
591 /* Process header /memreserve/ fields */
593 fdt_get_mem_rsv(initial_boot_params, n, &base, &size);
596 early_init_dt_reserve_memory_arch(base, size, 0);
599 of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
600 fdt_init_reserved_mem();
604 * of_scan_flat_dt - scan flattened tree blob and call callback on each.
605 * @it: callback function
606 * @data: context data pointer
608 * This function is used to scan the flattened device-tree, it is
609 * used to extract the memory information at boot before we can
612 int __init of_scan_flat_dt(int (*it)(unsigned long node,
613 const char *uname, int depth,
617 const void *blob = initial_boot_params;
619 int offset, rc = 0, depth = -1;
621 for (offset = fdt_next_node(blob, -1, &depth);
622 offset >= 0 && depth >= 0 && !rc;
623 offset = fdt_next_node(blob, offset, &depth)) {
625 pathp = fdt_get_name(blob, offset, NULL);
627 pathp = kbasename(pathp);
628 rc = it(offset, pathp, depth, data);
634 * of_get_flat_dt_root - find the root node in the flat blob
636 unsigned long __init of_get_flat_dt_root(void)
642 * of_get_flat_dt_size - Return the total size of the FDT
644 int __init of_get_flat_dt_size(void)
646 return fdt_totalsize(initial_boot_params);
650 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
652 * This function can be used within scan_flattened_dt callback to get
653 * access to properties
655 const void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
658 return fdt_getprop(initial_boot_params, node, name, size);
662 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
663 * @node: node to test
664 * @compat: compatible string to compare with compatible list.
666 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
668 return of_fdt_is_compatible(initial_boot_params, node, compat);
672 * of_flat_dt_match - Return true if node matches a list of compatible values
674 int __init of_flat_dt_match(unsigned long node, const char *const *compat)
676 return of_fdt_match(initial_boot_params, node, compat);
679 struct fdt_scan_status {
684 int (*iterator)(unsigned long node, const char *uname, int depth, void *data);
688 const char * __init of_flat_dt_get_machine_name(void)
691 unsigned long dt_root = of_get_flat_dt_root();
693 name = of_get_flat_dt_prop(dt_root, "model", NULL);
695 name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
700 * of_flat_dt_match_machine - Iterate match tables to find matching machine.
702 * @default_match: A machine specific ptr to return in case of no match.
703 * @get_next_compat: callback function to return next compatible match table.
705 * Iterate through machine match tables to find the best match for the machine
706 * compatible string in the FDT.
708 const void * __init of_flat_dt_match_machine(const void *default_match,
709 const void * (*get_next_compat)(const char * const**))
711 const void *data = NULL;
712 const void *best_data = default_match;
713 const char *const *compat;
714 unsigned long dt_root;
715 unsigned int best_score = ~1, score = 0;
717 dt_root = of_get_flat_dt_root();
718 while ((data = get_next_compat(&compat))) {
719 score = of_flat_dt_match(dt_root, compat);
720 if (score > 0 && score < best_score) {
729 pr_err("\n unrecognized device tree list:\n[ ");
731 prop = of_get_flat_dt_prop(dt_root, "compatible", &size);
734 printk("'%s' ", prop);
735 size -= strlen(prop) + 1;
736 prop += strlen(prop) + 1;
743 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name());
748 #ifdef CONFIG_BLK_DEV_INITRD
750 * early_init_dt_check_for_initrd - Decode initrd location from flat tree
751 * @node: reference to node containing initrd location ('chosen')
753 static void __init early_init_dt_check_for_initrd(unsigned long node)
759 pr_debug("Looking for initrd properties... ");
761 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
764 start = of_read_number(prop, len/4);
766 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
769 end = of_read_number(prop, len/4);
771 initrd_start = (unsigned long)__va(start);
772 initrd_end = (unsigned long)__va(end);
773 initrd_below_start_ok = 1;
775 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n",
776 (unsigned long long)start, (unsigned long long)end);
779 static inline void early_init_dt_check_for_initrd(unsigned long node)
782 #endif /* CONFIG_BLK_DEV_INITRD */
784 #ifdef CONFIG_SERIAL_EARLYCON
785 extern struct of_device_id __earlycon_of_table[];
787 static int __init early_init_dt_scan_chosen_serial(void)
792 const struct of_device_id *match = __earlycon_of_table;
793 const void *fdt = initial_boot_params;
795 offset = fdt_path_offset(fdt, "/chosen");
797 offset = fdt_path_offset(fdt, "/chosen@0");
801 p = fdt_getprop(fdt, offset, "stdout-path", &l);
803 p = fdt_getprop(fdt, offset, "linux,stdout-path", &l);
807 /* Get the node specified by stdout-path */
808 offset = fdt_path_offset(fdt, p);
812 while (match->compatible[0]) {
814 if (fdt_node_check_compatible(fdt, offset, match->compatible)) {
819 addr = fdt_translate_address(fdt, offset);
823 of_setup_earlycon(addr, match->data);
829 static int __init setup_of_earlycon(char *buf)
834 return early_init_dt_scan_chosen_serial();
836 early_param("earlycon", setup_of_earlycon);
840 * early_init_dt_scan_root - fetch the top level address and size cells
842 int __init early_init_dt_scan_root(unsigned long node, const char *uname,
843 int depth, void *data)
850 dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
851 dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
853 prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
855 dt_root_size_cells = be32_to_cpup(prop);
856 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
858 prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
860 dt_root_addr_cells = be32_to_cpup(prop);
861 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
867 u64 __init dt_mem_next_cell(int s, const __be32 **cellp)
869 const __be32 *p = *cellp;
872 return of_read_number(p, s);
876 * early_init_dt_scan_memory - Look for an parse memory nodes
878 int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
879 int depth, void *data)
881 const char *type = of_get_flat_dt_prop(node, "device_type", NULL);
882 const __be32 *reg, *endp;
885 /* We are scanning "memory" nodes only */
888 * The longtrail doesn't have a device_type on the
889 * /memory node, so look for the node called /memory@0.
891 if (!IS_ENABLED(CONFIG_PPC32) || depth != 1 || strcmp(uname, "memory@0") != 0)
893 } else if (strcmp(type, "memory") != 0)
896 reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
898 reg = of_get_flat_dt_prop(node, "reg", &l);
902 endp = reg + (l / sizeof(__be32));
904 pr_debug("memory scan node %s, reg size %d,\n", uname, l);
906 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
909 base = dt_mem_next_cell(dt_root_addr_cells, ®);
910 size = dt_mem_next_cell(dt_root_size_cells, ®);
914 pr_debug(" - %llx , %llx\n", (unsigned long long)base,
915 (unsigned long long)size);
917 early_init_dt_add_memory_arch(base, size);
923 int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
924 int depth, void *data)
929 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
931 if (depth != 1 || !data ||
932 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
935 early_init_dt_check_for_initrd(node);
937 /* Retrieve command line */
938 p = of_get_flat_dt_prop(node, "bootargs", &l);
939 if (p != NULL && l > 0)
940 strlcpy(data, p, min((int)l, COMMAND_LINE_SIZE));
943 * CONFIG_CMDLINE is meant to be a default in case nothing else
944 * managed to set the command line, unless CONFIG_CMDLINE_FORCE
945 * is set in which case we override whatever was found earlier.
947 #ifdef CONFIG_CMDLINE
948 #ifndef CONFIG_CMDLINE_FORCE
949 if (!((char *)data)[0])
951 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
952 #endif /* CONFIG_CMDLINE */
954 pr_debug("Command line is: %s\n", (char*)data);
960 #ifdef CONFIG_HAVE_MEMBLOCK
961 #define MAX_PHYS_ADDR ((phys_addr_t)~0)
963 void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
965 const u64 phys_offset = __pa(PAGE_OFFSET);
967 if (!PAGE_ALIGNED(base)) {
968 if (size < PAGE_SIZE - (base & ~PAGE_MASK)) {
969 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n",
973 size -= PAGE_SIZE - (base & ~PAGE_MASK);
974 base = PAGE_ALIGN(base);
978 if (base > MAX_PHYS_ADDR) {
979 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
984 if (base + size - 1 > MAX_PHYS_ADDR) {
985 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
986 ((u64)MAX_PHYS_ADDR) + 1, base + size);
987 size = MAX_PHYS_ADDR - base + 1;
990 if (base + size < phys_offset) {
991 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
995 if (base < phys_offset) {
996 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
998 size -= phys_offset - base;
1001 memblock_add(base, size);
1004 int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base,
1005 phys_addr_t size, bool nomap)
1008 return memblock_remove(base, size);
1009 return memblock_reserve(base, size);
1013 * called from unflatten_device_tree() to bootstrap devicetree itself
1014 * Architectures can override this definition if memblock isn't used
1016 void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align)
1018 return __va(memblock_alloc(size, align));
1021 void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size)
1026 int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base,
1027 phys_addr_t size, bool nomap)
1029 pr_err("Reserved memory not supported, ignoring range 0x%pa - 0x%pa%s\n",
1030 &base, &size, nomap ? " (nomap)" : "");
1034 void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align)
1041 bool __init early_init_dt_verify(void *params)
1046 /* check device tree validity */
1047 if (fdt_check_header(params))
1050 /* Setup flat device-tree pointer */
1051 initial_boot_params = params;
1052 of_fdt_crc32 = crc32_be(~0, initial_boot_params,
1053 fdt_totalsize(initial_boot_params));
1058 void __init early_init_dt_scan_nodes(void)
1060 /* Retrieve various information from the /chosen node */
1061 of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
1063 /* Initialize {size,address}-cells info */
1064 of_scan_flat_dt(early_init_dt_scan_root, NULL);
1066 /* Setup memory, calling early_init_dt_add_memory_arch */
1067 of_scan_flat_dt(early_init_dt_scan_memory, NULL);
1070 bool __init early_init_dt_scan(void *params)
1074 status = early_init_dt_verify(params);
1078 early_init_dt_scan_nodes();
1083 * unflatten_device_tree - create tree of device_nodes from flat blob
1085 * unflattens the device-tree passed by the firmware, creating the
1086 * tree of struct device_node. It also fills the "name" and "type"
1087 * pointers of the nodes so the normal device-tree walking functions
1090 void __init unflatten_device_tree(void)
1092 __unflatten_device_tree(initial_boot_params, &of_root,
1093 early_init_dt_alloc_memory_arch);
1095 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
1096 of_alias_scan(early_init_dt_alloc_memory_arch);
1100 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob
1102 * Copies and unflattens the device-tree passed by the firmware, creating the
1103 * tree of struct device_node. It also fills the "name" and "type"
1104 * pointers of the nodes so the normal device-tree walking functions
1105 * can be used. This should only be used when the FDT memory has not been
1106 * reserved such is the case when the FDT is built-in to the kernel init
1107 * section. If the FDT memory is reserved already then unflatten_device_tree
1108 * should be used instead.
1110 void __init unflatten_and_copy_device_tree(void)
1115 if (!initial_boot_params) {
1116 pr_warn("No valid device tree found, continuing without\n");
1120 size = fdt_totalsize(initial_boot_params);
1121 dt = early_init_dt_alloc_memory_arch(size,
1122 roundup_pow_of_two(FDT_V17_SIZE));
1125 memcpy(dt, initial_boot_params, size);
1126 initial_boot_params = dt;
1128 unflatten_device_tree();
1132 static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj,
1133 struct bin_attribute *bin_attr,
1134 char *buf, loff_t off, size_t count)
1136 memcpy(buf, initial_boot_params + off, count);
1140 static int __init of_fdt_raw_init(void)
1142 static struct bin_attribute of_fdt_raw_attr =
1143 __BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0);
1145 if (!initial_boot_params)
1148 if (of_fdt_crc32 != crc32_be(~0, initial_boot_params,
1149 fdt_totalsize(initial_boot_params))) {
1150 pr_warn("fdt: not creating '/sys/firmware/fdt': CRC check failed\n");
1153 of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params);
1154 return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr);
1156 late_initcall(of_fdt_raw_init);
1159 #endif /* CONFIG_OF_EARLY_FLATTREE */