1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Functions for working with the Flattened Device Tree data format 4 * 5 * Copyright 2009 Benjamin Herrenschmidt, IBM Corp 6 * benh@kernel.crashing.org 7 */ 8 9 #define pr_fmt(fmt) "OF: fdt: " fmt 10 11 #include <linux/crc32.h> 12 #include <linux/kernel.h> 13 #include <linux/initrd.h> 14 #include <linux/bootmem.h> 15 #include <linux/memblock.h> 16 #include <linux/mutex.h> 17 #include <linux/of.h> 18 #include <linux/of_fdt.h> 19 #include <linux/of_reserved_mem.h> 20 #include <linux/sizes.h> 21 #include <linux/string.h> 22 #include <linux/errno.h> 23 #include <linux/slab.h> 24 #include <linux/libfdt.h> 25 #include <linux/debugfs.h> 26 #include <linux/serial_core.h> 27 #include <linux/sysfs.h> 28 29 #include <asm/setup.h> /* for COMMAND_LINE_SIZE */ 30 #include <asm/page.h> 31 32 #include "of_private.h" 33 34 /* 35 * of_fdt_limit_memory - limit the number of regions in the /memory node 36 * @limit: maximum entries 37 * 38 * Adjust the flattened device tree to have at most 'limit' number of 39 * memory entries in the /memory node. This function may be called 40 * any time after initial_boot_param is set. 41 */ 42 void of_fdt_limit_memory(int limit) 43 { 44 int memory; 45 int len; 46 const void *val; 47 int nr_address_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT; 48 int nr_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT; 49 const __be32 *addr_prop; 50 const __be32 *size_prop; 51 int root_offset; 52 int cell_size; 53 54 root_offset = fdt_path_offset(initial_boot_params, "/"); 55 if (root_offset < 0) 56 return; 57 58 addr_prop = fdt_getprop(initial_boot_params, root_offset, 59 "#address-cells", NULL); 60 if (addr_prop) 61 nr_address_cells = fdt32_to_cpu(*addr_prop); 62 63 size_prop = fdt_getprop(initial_boot_params, root_offset, 64 "#size-cells", NULL); 65 if (size_prop) 66 nr_size_cells = fdt32_to_cpu(*size_prop); 67 68 cell_size = sizeof(uint32_t)*(nr_address_cells + nr_size_cells); 69 70 memory = fdt_path_offset(initial_boot_params, "/memory"); 71 if (memory > 0) { 72 val = fdt_getprop(initial_boot_params, memory, "reg", &len); 73 if (len > limit*cell_size) { 74 len = limit*cell_size; 75 pr_debug("Limiting number of entries to %d\n", limit); 76 fdt_setprop(initial_boot_params, memory, "reg", val, 77 len); 78 } 79 } 80 } 81 82 /** 83 * of_fdt_is_compatible - Return true if given node from the given blob has 84 * compat in its compatible list 85 * @blob: A device tree blob 86 * @node: node to test 87 * @compat: compatible string to compare with compatible list. 88 * 89 * On match, returns a non-zero value with smaller values returned for more 90 * specific compatible values. 91 */ 92 static int of_fdt_is_compatible(const void *blob, 93 unsigned long node, const char *compat) 94 { 95 const char *cp; 96 int cplen; 97 unsigned long l, score = 0; 98 99 cp = fdt_getprop(blob, node, "compatible", &cplen); 100 if (cp == NULL) 101 return 0; 102 while (cplen > 0) { 103 score++; 104 if (of_compat_cmp(cp, compat, strlen(compat)) == 0) 105 return score; 106 l = strlen(cp) + 1; 107 cp += l; 108 cplen -= l; 109 } 110 111 return 0; 112 } 113 114 /** 115 * of_fdt_is_big_endian - Return true if given node needs BE MMIO accesses 116 * @blob: A device tree blob 117 * @node: node to test 118 * 119 * Returns true if the node has a "big-endian" property, or if the kernel 120 * was compiled for BE *and* the node has a "native-endian" property. 121 * Returns false otherwise. 122 */ 123 bool of_fdt_is_big_endian(const void *blob, unsigned long node) 124 { 125 if (fdt_getprop(blob, node, "big-endian", NULL)) 126 return true; 127 if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) && 128 fdt_getprop(blob, node, "native-endian", NULL)) 129 return true; 130 return false; 131 } 132 133 static bool of_fdt_device_is_available(const void *blob, unsigned long node) 134 { 135 const char *status = fdt_getprop(blob, node, "status", NULL); 136 137 if (!status) 138 return true; 139 140 if (!strcmp(status, "ok") || !strcmp(status, "okay")) 141 return true; 142 143 return false; 144 } 145 146 /** 147 * of_fdt_match - Return true if node matches a list of compatible values 148 */ 149 int of_fdt_match(const void *blob, unsigned long node, 150 const char *const *compat) 151 { 152 unsigned int tmp, score = 0; 153 154 if (!compat) 155 return 0; 156 157 while (*compat) { 158 tmp = of_fdt_is_compatible(blob, node, *compat); 159 if (tmp && (score == 0 || (tmp < score))) 160 score = tmp; 161 compat++; 162 } 163 164 return score; 165 } 166 167 static void *unflatten_dt_alloc(void **mem, unsigned long size, 168 unsigned long align) 169 { 170 void *res; 171 172 *mem = PTR_ALIGN(*mem, align); 173 res = *mem; 174 *mem += size; 175 176 return res; 177 } 178 179 static void populate_properties(const void *blob, 180 int offset, 181 void **mem, 182 struct device_node *np, 183 const char *nodename, 184 bool dryrun) 185 { 186 struct property *pp, **pprev = NULL; 187 int cur; 188 bool has_name = false; 189 190 pprev = &np->properties; 191 for (cur = fdt_first_property_offset(blob, offset); 192 cur >= 0; 193 cur = fdt_next_property_offset(blob, cur)) { 194 const __be32 *val; 195 const char *pname; 196 u32 sz; 197 198 val = fdt_getprop_by_offset(blob, cur, &pname, &sz); 199 if (!val) { 200 pr_warn("Cannot locate property at 0x%x\n", cur); 201 continue; 202 } 203 204 if (!pname) { 205 pr_warn("Cannot find property name at 0x%x\n", cur); 206 continue; 207 } 208 209 if (!strcmp(pname, "name")) 210 has_name = true; 211 212 pp = unflatten_dt_alloc(mem, sizeof(struct property), 213 __alignof__(struct property)); 214 if (dryrun) 215 continue; 216 217 /* We accept flattened tree phandles either in 218 * ePAPR-style "phandle" properties, or the 219 * legacy "linux,phandle" properties. If both 220 * appear and have different values, things 221 * will get weird. Don't do that. 222 */ 223 if (!strcmp(pname, "phandle") || 224 !strcmp(pname, "linux,phandle")) { 225 if (!np->phandle) 226 np->phandle = be32_to_cpup(val); 227 } 228 229 /* And we process the "ibm,phandle" property 230 * used in pSeries dynamic device tree 231 * stuff 232 */ 233 if (!strcmp(pname, "ibm,phandle")) 234 np->phandle = be32_to_cpup(val); 235 236 pp->name = (char *)pname; 237 pp->length = sz; 238 pp->value = (__be32 *)val; 239 *pprev = pp; 240 pprev = &pp->next; 241 } 242 243 /* With version 0x10 we may not have the name property, 244 * recreate it here from the unit name if absent 245 */ 246 if (!has_name) { 247 const char *p = nodename, *ps = p, *pa = NULL; 248 int len; 249 250 while (*p) { 251 if ((*p) == '@') 252 pa = p; 253 else if ((*p) == '/') 254 ps = p + 1; 255 p++; 256 } 257 258 if (pa < ps) 259 pa = p; 260 len = (pa - ps) + 1; 261 pp = unflatten_dt_alloc(mem, sizeof(struct property) + len, 262 __alignof__(struct property)); 263 if (!dryrun) { 264 pp->name = "name"; 265 pp->length = len; 266 pp->value = pp + 1; 267 *pprev = pp; 268 pprev = &pp->next; 269 memcpy(pp->value, ps, len - 1); 270 ((char *)pp->value)[len - 1] = 0; 271 pr_debug("fixed up name for %s -> %s\n", 272 nodename, (char *)pp->value); 273 } 274 } 275 276 if (!dryrun) 277 *pprev = NULL; 278 } 279 280 static bool populate_node(const void *blob, 281 int offset, 282 void **mem, 283 struct device_node *dad, 284 struct device_node **pnp, 285 bool dryrun) 286 { 287 struct device_node *np; 288 const char *pathp; 289 unsigned int l, allocl; 290 291 pathp = fdt_get_name(blob, offset, &l); 292 if (!pathp) { 293 *pnp = NULL; 294 return false; 295 } 296 297 allocl = ++l; 298 299 np = unflatten_dt_alloc(mem, sizeof(struct device_node) + allocl, 300 __alignof__(struct device_node)); 301 if (!dryrun) { 302 char *fn; 303 of_node_init(np); 304 np->full_name = fn = ((char *)np) + sizeof(*np); 305 306 memcpy(fn, pathp, l); 307 308 if (dad != NULL) { 309 np->parent = dad; 310 np->sibling = dad->child; 311 dad->child = np; 312 } 313 } 314 315 populate_properties(blob, offset, mem, np, pathp, dryrun); 316 if (!dryrun) { 317 np->name = of_get_property(np, "name", NULL); 318 np->type = of_get_property(np, "device_type", NULL); 319 320 if (!np->name) 321 np->name = "<NULL>"; 322 if (!np->type) 323 np->type = "<NULL>"; 324 } 325 326 *pnp = np; 327 return true; 328 } 329 330 static void reverse_nodes(struct device_node *parent) 331 { 332 struct device_node *child, *next; 333 334 /* In-depth first */ 335 child = parent->child; 336 while (child) { 337 reverse_nodes(child); 338 339 child = child->sibling; 340 } 341 342 /* Reverse the nodes in the child list */ 343 child = parent->child; 344 parent->child = NULL; 345 while (child) { 346 next = child->sibling; 347 348 child->sibling = parent->child; 349 parent->child = child; 350 child = next; 351 } 352 } 353 354 /** 355 * unflatten_dt_nodes - Alloc and populate a device_node from the flat tree 356 * @blob: The parent device tree blob 357 * @mem: Memory chunk to use for allocating device nodes and properties 358 * @dad: Parent struct device_node 359 * @nodepp: The device_node tree created by the call 360 * 361 * It returns the size of unflattened device tree or error code 362 */ 363 static int unflatten_dt_nodes(const void *blob, 364 void *mem, 365 struct device_node *dad, 366 struct device_node **nodepp) 367 { 368 struct device_node *root; 369 int offset = 0, depth = 0, initial_depth = 0; 370 #define FDT_MAX_DEPTH 64 371 struct device_node *nps[FDT_MAX_DEPTH]; 372 void *base = mem; 373 bool dryrun = !base; 374 375 if (nodepp) 376 *nodepp = NULL; 377 378 /* 379 * We're unflattening device sub-tree if @dad is valid. There are 380 * possibly multiple nodes in the first level of depth. We need 381 * set @depth to 1 to make fdt_next_node() happy as it bails 382 * immediately when negative @depth is found. Otherwise, the device 383 * nodes except the first one won't be unflattened successfully. 384 */ 385 if (dad) 386 depth = initial_depth = 1; 387 388 root = dad; 389 nps[depth] = dad; 390 391 for (offset = 0; 392 offset >= 0 && depth >= initial_depth; 393 offset = fdt_next_node(blob, offset, &depth)) { 394 if (WARN_ON_ONCE(depth >= FDT_MAX_DEPTH)) 395 continue; 396 397 if (!IS_ENABLED(CONFIG_OF_KOBJ) && 398 !of_fdt_device_is_available(blob, offset)) 399 continue; 400 401 if (!populate_node(blob, offset, &mem, nps[depth], 402 &nps[depth+1], dryrun)) 403 return mem - base; 404 405 if (!dryrun && nodepp && !*nodepp) 406 *nodepp = nps[depth+1]; 407 if (!dryrun && !root) 408 root = nps[depth+1]; 409 } 410 411 if (offset < 0 && offset != -FDT_ERR_NOTFOUND) { 412 pr_err("Error %d processing FDT\n", offset); 413 return -EINVAL; 414 } 415 416 /* 417 * Reverse the child list. Some drivers assumes node order matches .dts 418 * node order 419 */ 420 if (!dryrun) 421 reverse_nodes(root); 422 423 return mem - base; 424 } 425 426 /** 427 * __unflatten_device_tree - create tree of device_nodes from flat blob 428 * 429 * unflattens a device-tree, creating the 430 * tree of struct device_node. It also fills the "name" and "type" 431 * pointers of the nodes so the normal device-tree walking functions 432 * can be used. 433 * @blob: The blob to expand 434 * @dad: Parent device node 435 * @mynodes: The device_node tree created by the call 436 * @dt_alloc: An allocator that provides a virtual address to memory 437 * for the resulting tree 438 * @detached: if true set OF_DETACHED on @mynodes 439 * 440 * Returns NULL on failure or the memory chunk containing the unflattened 441 * device tree on success. 442 */ 443 void *__unflatten_device_tree(const void *blob, 444 struct device_node *dad, 445 struct device_node **mynodes, 446 void *(*dt_alloc)(u64 size, u64 align), 447 bool detached) 448 { 449 int size; 450 void *mem; 451 452 pr_debug(" -> unflatten_device_tree()\n"); 453 454 if (!blob) { 455 pr_debug("No device tree pointer\n"); 456 return NULL; 457 } 458 459 pr_debug("Unflattening device tree:\n"); 460 pr_debug("magic: %08x\n", fdt_magic(blob)); 461 pr_debug("size: %08x\n", fdt_totalsize(blob)); 462 pr_debug("version: %08x\n", fdt_version(blob)); 463 464 if (fdt_check_header(blob)) { 465 pr_err("Invalid device tree blob header\n"); 466 return NULL; 467 } 468 469 /* First pass, scan for size */ 470 size = unflatten_dt_nodes(blob, NULL, dad, NULL); 471 if (size < 0) 472 return NULL; 473 474 size = ALIGN(size, 4); 475 pr_debug(" size is %d, allocating...\n", size); 476 477 /* Allocate memory for the expanded device tree */ 478 mem = dt_alloc(size + 4, __alignof__(struct device_node)); 479 if (!mem) 480 return NULL; 481 482 memset(mem, 0, size); 483 484 *(__be32 *)(mem + size) = cpu_to_be32(0xdeadbeef); 485 486 pr_debug(" unflattening %p...\n", mem); 487 488 /* Second pass, do actual unflattening */ 489 unflatten_dt_nodes(blob, mem, dad, mynodes); 490 if (be32_to_cpup(mem + size) != 0xdeadbeef) 491 pr_warning("End of tree marker overwritten: %08x\n", 492 be32_to_cpup(mem + size)); 493 494 if (detached && mynodes) { 495 of_node_set_flag(*mynodes, OF_DETACHED); 496 pr_debug("unflattened tree is detached\n"); 497 } 498 499 pr_debug(" <- unflatten_device_tree()\n"); 500 return mem; 501 } 502 503 static void *kernel_tree_alloc(u64 size, u64 align) 504 { 505 return kzalloc(size, GFP_KERNEL); 506 } 507 508 static DEFINE_MUTEX(of_fdt_unflatten_mutex); 509 510 /** 511 * of_fdt_unflatten_tree - create tree of device_nodes from flat blob 512 * @blob: Flat device tree blob 513 * @dad: Parent device node 514 * @mynodes: The device tree created by the call 515 * 516 * unflattens the device-tree passed by the firmware, creating the 517 * tree of struct device_node. It also fills the "name" and "type" 518 * pointers of the nodes so the normal device-tree walking functions 519 * can be used. 520 * 521 * Returns NULL on failure or the memory chunk containing the unflattened 522 * device tree on success. 523 */ 524 void *of_fdt_unflatten_tree(const unsigned long *blob, 525 struct device_node *dad, 526 struct device_node **mynodes) 527 { 528 void *mem; 529 530 mutex_lock(&of_fdt_unflatten_mutex); 531 mem = __unflatten_device_tree(blob, dad, mynodes, &kernel_tree_alloc, 532 true); 533 mutex_unlock(&of_fdt_unflatten_mutex); 534 535 return mem; 536 } 537 EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree); 538 539 /* Everything below here references initial_boot_params directly. */ 540 int __initdata dt_root_addr_cells; 541 int __initdata dt_root_size_cells; 542 543 void *initial_boot_params; 544 545 #ifdef CONFIG_OF_EARLY_FLATTREE 546 547 static u32 of_fdt_crc32; 548 549 /** 550 * res_mem_reserve_reg() - reserve all memory described in 'reg' property 551 */ 552 static int __init __reserved_mem_reserve_reg(unsigned long node, 553 const char *uname) 554 { 555 int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32); 556 phys_addr_t base, size; 557 int len; 558 const __be32 *prop; 559 int nomap, first = 1; 560 561 prop = of_get_flat_dt_prop(node, "reg", &len); 562 if (!prop) 563 return -ENOENT; 564 565 if (len && len % t_len != 0) { 566 pr_err("Reserved memory: invalid reg property in '%s', skipping node.\n", 567 uname); 568 return -EINVAL; 569 } 570 571 nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL; 572 573 while (len >= t_len) { 574 base = dt_mem_next_cell(dt_root_addr_cells, &prop); 575 size = dt_mem_next_cell(dt_root_size_cells, &prop); 576 577 if (size && 578 early_init_dt_reserve_memory_arch(base, size, nomap) == 0) 579 pr_debug("Reserved memory: reserved region for node '%s': base %pa, size %ld MiB\n", 580 uname, &base, (unsigned long)size / SZ_1M); 581 else 582 pr_info("Reserved memory: failed to reserve memory for node '%s': base %pa, size %ld MiB\n", 583 uname, &base, (unsigned long)size / SZ_1M); 584 585 len -= t_len; 586 if (first) { 587 fdt_reserved_mem_save_node(node, uname, base, size); 588 first = 0; 589 } 590 } 591 return 0; 592 } 593 594 /** 595 * __reserved_mem_check_root() - check if #size-cells, #address-cells provided 596 * in /reserved-memory matches the values supported by the current implementation, 597 * also check if ranges property has been provided 598 */ 599 static int __init __reserved_mem_check_root(unsigned long node) 600 { 601 const __be32 *prop; 602 603 prop = of_get_flat_dt_prop(node, "#size-cells", NULL); 604 if (!prop || be32_to_cpup(prop) != dt_root_size_cells) 605 return -EINVAL; 606 607 prop = of_get_flat_dt_prop(node, "#address-cells", NULL); 608 if (!prop || be32_to_cpup(prop) != dt_root_addr_cells) 609 return -EINVAL; 610 611 prop = of_get_flat_dt_prop(node, "ranges", NULL); 612 if (!prop) 613 return -EINVAL; 614 return 0; 615 } 616 617 /** 618 * fdt_scan_reserved_mem() - scan a single FDT node for reserved memory 619 */ 620 static int __init __fdt_scan_reserved_mem(unsigned long node, const char *uname, 621 int depth, void *data) 622 { 623 static int found; 624 int err; 625 626 if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) { 627 if (__reserved_mem_check_root(node) != 0) { 628 pr_err("Reserved memory: unsupported node format, ignoring\n"); 629 /* break scan */ 630 return 1; 631 } 632 found = 1; 633 /* scan next node */ 634 return 0; 635 } else if (!found) { 636 /* scan next node */ 637 return 0; 638 } else if (found && depth < 2) { 639 /* scanning of /reserved-memory has been finished */ 640 return 1; 641 } 642 643 if (!of_fdt_device_is_available(initial_boot_params, node)) 644 return 0; 645 646 err = __reserved_mem_reserve_reg(node, uname); 647 if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL)) 648 fdt_reserved_mem_save_node(node, uname, 0, 0); 649 650 /* scan next node */ 651 return 0; 652 } 653 654 /** 655 * early_init_fdt_scan_reserved_mem() - create reserved memory regions 656 * 657 * This function grabs memory from early allocator for device exclusive use 658 * defined in device tree structures. It should be called by arch specific code 659 * once the early allocator (i.e. memblock) has been fully activated. 660 */ 661 void __init early_init_fdt_scan_reserved_mem(void) 662 { 663 int n; 664 u64 base, size; 665 666 if (!initial_boot_params) 667 return; 668 669 /* Process header /memreserve/ fields */ 670 for (n = 0; ; n++) { 671 fdt_get_mem_rsv(initial_boot_params, n, &base, &size); 672 if (!size) 673 break; 674 early_init_dt_reserve_memory_arch(base, size, 0); 675 } 676 677 of_scan_flat_dt(__fdt_scan_reserved_mem, NULL); 678 fdt_init_reserved_mem(); 679 } 680 681 /** 682 * early_init_fdt_reserve_self() - reserve the memory used by the FDT blob 683 */ 684 void __init early_init_fdt_reserve_self(void) 685 { 686 if (!initial_boot_params) 687 return; 688 689 /* Reserve the dtb region */ 690 early_init_dt_reserve_memory_arch(__pa(initial_boot_params), 691 fdt_totalsize(initial_boot_params), 692 0); 693 } 694 695 /** 696 * of_scan_flat_dt - scan flattened tree blob and call callback on each. 697 * @it: callback function 698 * @data: context data pointer 699 * 700 * This function is used to scan the flattened device-tree, it is 701 * used to extract the memory information at boot before we can 702 * unflatten the tree 703 */ 704 int __init of_scan_flat_dt(int (*it)(unsigned long node, 705 const char *uname, int depth, 706 void *data), 707 void *data) 708 { 709 const void *blob = initial_boot_params; 710 const char *pathp; 711 int offset, rc = 0, depth = -1; 712 713 if (!blob) 714 return 0; 715 716 for (offset = fdt_next_node(blob, -1, &depth); 717 offset >= 0 && depth >= 0 && !rc; 718 offset = fdt_next_node(blob, offset, &depth)) { 719 720 pathp = fdt_get_name(blob, offset, NULL); 721 if (*pathp == '/') 722 pathp = kbasename(pathp); 723 rc = it(offset, pathp, depth, data); 724 } 725 return rc; 726 } 727 728 /** 729 * of_scan_flat_dt_subnodes - scan sub-nodes of a node call callback on each. 730 * @it: callback function 731 * @data: context data pointer 732 * 733 * This function is used to scan sub-nodes of a node. 734 */ 735 int __init of_scan_flat_dt_subnodes(unsigned long parent, 736 int (*it)(unsigned long node, 737 const char *uname, 738 void *data), 739 void *data) 740 { 741 const void *blob = initial_boot_params; 742 int node; 743 744 fdt_for_each_subnode(node, blob, parent) { 745 const char *pathp; 746 int rc; 747 748 pathp = fdt_get_name(blob, node, NULL); 749 if (*pathp == '/') 750 pathp = kbasename(pathp); 751 rc = it(node, pathp, data); 752 if (rc) 753 return rc; 754 } 755 return 0; 756 } 757 758 /** 759 * of_get_flat_dt_subnode_by_name - get the subnode by given name 760 * 761 * @node: the parent node 762 * @uname: the name of subnode 763 * @return offset of the subnode, or -FDT_ERR_NOTFOUND if there is none 764 */ 765 766 int of_get_flat_dt_subnode_by_name(unsigned long node, const char *uname) 767 { 768 return fdt_subnode_offset(initial_boot_params, node, uname); 769 } 770 771 /** 772 * of_get_flat_dt_root - find the root node in the flat blob 773 */ 774 unsigned long __init of_get_flat_dt_root(void) 775 { 776 return 0; 777 } 778 779 /** 780 * of_get_flat_dt_size - Return the total size of the FDT 781 */ 782 int __init of_get_flat_dt_size(void) 783 { 784 return fdt_totalsize(initial_boot_params); 785 } 786 787 /** 788 * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr 789 * 790 * This function can be used within scan_flattened_dt callback to get 791 * access to properties 792 */ 793 const void *__init of_get_flat_dt_prop(unsigned long node, const char *name, 794 int *size) 795 { 796 return fdt_getprop(initial_boot_params, node, name, size); 797 } 798 799 /** 800 * of_flat_dt_is_compatible - Return true if given node has compat in compatible list 801 * @node: node to test 802 * @compat: compatible string to compare with compatible list. 803 */ 804 int __init of_flat_dt_is_compatible(unsigned long node, const char *compat) 805 { 806 return of_fdt_is_compatible(initial_boot_params, node, compat); 807 } 808 809 /** 810 * of_flat_dt_match - Return true if node matches a list of compatible values 811 */ 812 int __init of_flat_dt_match(unsigned long node, const char *const *compat) 813 { 814 return of_fdt_match(initial_boot_params, node, compat); 815 } 816 817 /** 818 * of_get_flat_dt_prop - Given a node in the flat blob, return the phandle 819 */ 820 uint32_t __init of_get_flat_dt_phandle(unsigned long node) 821 { 822 return fdt_get_phandle(initial_boot_params, node); 823 } 824 825 struct fdt_scan_status { 826 const char *name; 827 int namelen; 828 int depth; 829 int found; 830 int (*iterator)(unsigned long node, const char *uname, int depth, void *data); 831 void *data; 832 }; 833 834 const char * __init of_flat_dt_get_machine_name(void) 835 { 836 const char *name; 837 unsigned long dt_root = of_get_flat_dt_root(); 838 839 name = of_get_flat_dt_prop(dt_root, "model", NULL); 840 if (!name) 841 name = of_get_flat_dt_prop(dt_root, "compatible", NULL); 842 return name; 843 } 844 845 /** 846 * of_flat_dt_match_machine - Iterate match tables to find matching machine. 847 * 848 * @default_match: A machine specific ptr to return in case of no match. 849 * @get_next_compat: callback function to return next compatible match table. 850 * 851 * Iterate through machine match tables to find the best match for the machine 852 * compatible string in the FDT. 853 */ 854 const void * __init of_flat_dt_match_machine(const void *default_match, 855 const void * (*get_next_compat)(const char * const**)) 856 { 857 const void *data = NULL; 858 const void *best_data = default_match; 859 const char *const *compat; 860 unsigned long dt_root; 861 unsigned int best_score = ~1, score = 0; 862 863 dt_root = of_get_flat_dt_root(); 864 while ((data = get_next_compat(&compat))) { 865 score = of_flat_dt_match(dt_root, compat); 866 if (score > 0 && score < best_score) { 867 best_data = data; 868 best_score = score; 869 } 870 } 871 if (!best_data) { 872 const char *prop; 873 int size; 874 875 pr_err("\n unrecognized device tree list:\n[ "); 876 877 prop = of_get_flat_dt_prop(dt_root, "compatible", &size); 878 if (prop) { 879 while (size > 0) { 880 printk("'%s' ", prop); 881 size -= strlen(prop) + 1; 882 prop += strlen(prop) + 1; 883 } 884 } 885 printk("]\n\n"); 886 return NULL; 887 } 888 889 pr_info("Machine model: %s\n", of_flat_dt_get_machine_name()); 890 891 return best_data; 892 } 893 894 #ifdef CONFIG_BLK_DEV_INITRD 895 #ifndef __early_init_dt_declare_initrd 896 static void __early_init_dt_declare_initrd(unsigned long start, 897 unsigned long end) 898 { 899 initrd_start = (unsigned long)__va(start); 900 initrd_end = (unsigned long)__va(end); 901 initrd_below_start_ok = 1; 902 } 903 #endif 904 905 /** 906 * early_init_dt_check_for_initrd - Decode initrd location from flat tree 907 * @node: reference to node containing initrd location ('chosen') 908 */ 909 static void __init early_init_dt_check_for_initrd(unsigned long node) 910 { 911 u64 start, end; 912 int len; 913 const __be32 *prop; 914 915 pr_debug("Looking for initrd properties... "); 916 917 prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len); 918 if (!prop) 919 return; 920 start = of_read_number(prop, len/4); 921 922 prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len); 923 if (!prop) 924 return; 925 end = of_read_number(prop, len/4); 926 927 __early_init_dt_declare_initrd(start, end); 928 929 pr_debug("initrd_start=0x%llx initrd_end=0x%llx\n", 930 (unsigned long long)start, (unsigned long long)end); 931 } 932 #else 933 static inline void early_init_dt_check_for_initrd(unsigned long node) 934 { 935 } 936 #endif /* CONFIG_BLK_DEV_INITRD */ 937 938 #ifdef CONFIG_SERIAL_EARLYCON 939 940 int __init early_init_dt_scan_chosen_stdout(void) 941 { 942 int offset; 943 const char *p, *q, *options = NULL; 944 int l; 945 const struct earlycon_id **p_match; 946 const void *fdt = initial_boot_params; 947 948 offset = fdt_path_offset(fdt, "/chosen"); 949 if (offset < 0) 950 offset = fdt_path_offset(fdt, "/chosen@0"); 951 if (offset < 0) 952 return -ENOENT; 953 954 p = fdt_getprop(fdt, offset, "stdout-path", &l); 955 if (!p) 956 p = fdt_getprop(fdt, offset, "linux,stdout-path", &l); 957 if (!p || !l) 958 return -ENOENT; 959 960 q = strchrnul(p, ':'); 961 if (*q != '\0') 962 options = q + 1; 963 l = q - p; 964 965 /* Get the node specified by stdout-path */ 966 offset = fdt_path_offset_namelen(fdt, p, l); 967 if (offset < 0) { 968 pr_warn("earlycon: stdout-path %.*s not found\n", l, p); 969 return 0; 970 } 971 972 for (p_match = __earlycon_table; p_match < __earlycon_table_end; 973 p_match++) { 974 const struct earlycon_id *match = *p_match; 975 976 if (!match->compatible[0]) 977 continue; 978 979 if (fdt_node_check_compatible(fdt, offset, match->compatible)) 980 continue; 981 982 of_setup_earlycon(match, offset, options); 983 return 0; 984 } 985 return -ENODEV; 986 } 987 #endif 988 989 /** 990 * early_init_dt_scan_root - fetch the top level address and size cells 991 */ 992 int __init early_init_dt_scan_root(unsigned long node, const char *uname, 993 int depth, void *data) 994 { 995 const __be32 *prop; 996 997 if (depth != 0) 998 return 0; 999 1000 dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT; 1001 dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT; 1002 1003 prop = of_get_flat_dt_prop(node, "#size-cells", NULL); 1004 if (prop) 1005 dt_root_size_cells = be32_to_cpup(prop); 1006 pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells); 1007 1008 prop = of_get_flat_dt_prop(node, "#address-cells", NULL); 1009 if (prop) 1010 dt_root_addr_cells = be32_to_cpup(prop); 1011 pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells); 1012 1013 /* break now */ 1014 return 1; 1015 } 1016 1017 u64 __init dt_mem_next_cell(int s, const __be32 **cellp) 1018 { 1019 const __be32 *p = *cellp; 1020 1021 *cellp = p + s; 1022 return of_read_number(p, s); 1023 } 1024 1025 /** 1026 * early_init_dt_scan_memory - Look for and parse memory nodes 1027 */ 1028 int __init early_init_dt_scan_memory(unsigned long node, const char *uname, 1029 int depth, void *data) 1030 { 1031 const char *type = of_get_flat_dt_prop(node, "device_type", NULL); 1032 const __be32 *reg, *endp; 1033 int l; 1034 bool hotpluggable; 1035 1036 /* We are scanning "memory" nodes only */ 1037 if (type == NULL) { 1038 /* 1039 * The longtrail doesn't have a device_type on the 1040 * /memory node, so look for the node called /memory@0. 1041 */ 1042 if (!IS_ENABLED(CONFIG_PPC32) || depth != 1 || strcmp(uname, "memory@0") != 0) 1043 return 0; 1044 } else if (strcmp(type, "memory") != 0) 1045 return 0; 1046 1047 reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l); 1048 if (reg == NULL) 1049 reg = of_get_flat_dt_prop(node, "reg", &l); 1050 if (reg == NULL) 1051 return 0; 1052 1053 endp = reg + (l / sizeof(__be32)); 1054 hotpluggable = of_get_flat_dt_prop(node, "hotpluggable", NULL); 1055 1056 pr_debug("memory scan node %s, reg size %d,\n", uname, l); 1057 1058 while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) { 1059 u64 base, size; 1060 1061 base = dt_mem_next_cell(dt_root_addr_cells, ®); 1062 size = dt_mem_next_cell(dt_root_size_cells, ®); 1063 1064 if (size == 0) 1065 continue; 1066 pr_debug(" - %llx , %llx\n", (unsigned long long)base, 1067 (unsigned long long)size); 1068 1069 early_init_dt_add_memory_arch(base, size); 1070 1071 if (!hotpluggable) 1072 continue; 1073 1074 if (early_init_dt_mark_hotplug_memory_arch(base, size)) 1075 pr_warn("failed to mark hotplug range 0x%llx - 0x%llx\n", 1076 base, base + size); 1077 } 1078 1079 return 0; 1080 } 1081 1082 int __init early_init_dt_scan_chosen(unsigned long node, const char *uname, 1083 int depth, void *data) 1084 { 1085 int l; 1086 const char *p; 1087 1088 pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname); 1089 1090 if (depth != 1 || !data || 1091 (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0)) 1092 return 0; 1093 1094 early_init_dt_check_for_initrd(node); 1095 1096 /* Retrieve command line */ 1097 p = of_get_flat_dt_prop(node, "bootargs", &l); 1098 if (p != NULL && l > 0) 1099 strlcpy(data, p, min((int)l, COMMAND_LINE_SIZE)); 1100 1101 /* 1102 * CONFIG_CMDLINE is meant to be a default in case nothing else 1103 * managed to set the command line, unless CONFIG_CMDLINE_FORCE 1104 * is set in which case we override whatever was found earlier. 1105 */ 1106 #ifdef CONFIG_CMDLINE 1107 #if defined(CONFIG_CMDLINE_EXTEND) 1108 strlcat(data, " ", COMMAND_LINE_SIZE); 1109 strlcat(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 1110 #elif defined(CONFIG_CMDLINE_FORCE) 1111 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 1112 #else 1113 /* No arguments from boot loader, use kernel's cmdl*/ 1114 if (!((char *)data)[0]) 1115 strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE); 1116 #endif 1117 #endif /* CONFIG_CMDLINE */ 1118 1119 pr_debug("Command line is: %s\n", (char*)data); 1120 1121 /* break now */ 1122 return 1; 1123 } 1124 1125 #ifdef CONFIG_HAVE_MEMBLOCK 1126 #ifndef MIN_MEMBLOCK_ADDR 1127 #define MIN_MEMBLOCK_ADDR __pa(PAGE_OFFSET) 1128 #endif 1129 #ifndef MAX_MEMBLOCK_ADDR 1130 #define MAX_MEMBLOCK_ADDR ((phys_addr_t)~0) 1131 #endif 1132 1133 void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size) 1134 { 1135 const u64 phys_offset = MIN_MEMBLOCK_ADDR; 1136 1137 if (!PAGE_ALIGNED(base)) { 1138 if (size < PAGE_SIZE - (base & ~PAGE_MASK)) { 1139 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n", 1140 base, base + size); 1141 return; 1142 } 1143 size -= PAGE_SIZE - (base & ~PAGE_MASK); 1144 base = PAGE_ALIGN(base); 1145 } 1146 size &= PAGE_MASK; 1147 1148 if (base > MAX_MEMBLOCK_ADDR) { 1149 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n", 1150 base, base + size); 1151 return; 1152 } 1153 1154 if (base + size - 1 > MAX_MEMBLOCK_ADDR) { 1155 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n", 1156 ((u64)MAX_MEMBLOCK_ADDR) + 1, base + size); 1157 size = MAX_MEMBLOCK_ADDR - base + 1; 1158 } 1159 1160 if (base + size < phys_offset) { 1161 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n", 1162 base, base + size); 1163 return; 1164 } 1165 if (base < phys_offset) { 1166 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n", 1167 base, phys_offset); 1168 size -= phys_offset - base; 1169 base = phys_offset; 1170 } 1171 memblock_add(base, size); 1172 } 1173 1174 int __init __weak early_init_dt_mark_hotplug_memory_arch(u64 base, u64 size) 1175 { 1176 return memblock_mark_hotplug(base, size); 1177 } 1178 1179 int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base, 1180 phys_addr_t size, bool nomap) 1181 { 1182 if (nomap) 1183 return memblock_remove(base, size); 1184 return memblock_reserve(base, size); 1185 } 1186 1187 #else 1188 void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size) 1189 { 1190 WARN_ON(1); 1191 } 1192 1193 int __init __weak early_init_dt_mark_hotplug_memory_arch(u64 base, u64 size) 1194 { 1195 return -ENOSYS; 1196 } 1197 1198 int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base, 1199 phys_addr_t size, bool nomap) 1200 { 1201 pr_err("Reserved memory not supported, ignoring range %pa - %pa%s\n", 1202 &base, &size, nomap ? " (nomap)" : ""); 1203 return -ENOSYS; 1204 } 1205 #endif 1206 1207 static void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align) 1208 { 1209 return memblock_virt_alloc(size, align); 1210 } 1211 1212 bool __init early_init_dt_verify(void *params) 1213 { 1214 if (!params) 1215 return false; 1216 1217 /* check device tree validity */ 1218 if (fdt_check_header(params)) 1219 return false; 1220 1221 /* Setup flat device-tree pointer */ 1222 initial_boot_params = params; 1223 of_fdt_crc32 = crc32_be(~0, initial_boot_params, 1224 fdt_totalsize(initial_boot_params)); 1225 return true; 1226 } 1227 1228 1229 void __init early_init_dt_scan_nodes(void) 1230 { 1231 /* Retrieve various information from the /chosen node */ 1232 of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line); 1233 1234 /* Initialize {size,address}-cells info */ 1235 of_scan_flat_dt(early_init_dt_scan_root, NULL); 1236 1237 /* Setup memory, calling early_init_dt_add_memory_arch */ 1238 of_scan_flat_dt(early_init_dt_scan_memory, NULL); 1239 } 1240 1241 bool __init early_init_dt_scan(void *params) 1242 { 1243 bool status; 1244 1245 status = early_init_dt_verify(params); 1246 if (!status) 1247 return false; 1248 1249 early_init_dt_scan_nodes(); 1250 return true; 1251 } 1252 1253 /** 1254 * unflatten_device_tree - create tree of device_nodes from flat blob 1255 * 1256 * unflattens the device-tree passed by the firmware, creating the 1257 * tree of struct device_node. It also fills the "name" and "type" 1258 * pointers of the nodes so the normal device-tree walking functions 1259 * can be used. 1260 */ 1261 void __init unflatten_device_tree(void) 1262 { 1263 __unflatten_device_tree(initial_boot_params, NULL, &of_root, 1264 early_init_dt_alloc_memory_arch, false); 1265 1266 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */ 1267 of_alias_scan(early_init_dt_alloc_memory_arch); 1268 1269 unittest_unflatten_overlay_base(); 1270 } 1271 1272 /** 1273 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob 1274 * 1275 * Copies and unflattens the device-tree passed by the firmware, creating the 1276 * tree of struct device_node. It also fills the "name" and "type" 1277 * pointers of the nodes so the normal device-tree walking functions 1278 * can be used. This should only be used when the FDT memory has not been 1279 * reserved such is the case when the FDT is built-in to the kernel init 1280 * section. If the FDT memory is reserved already then unflatten_device_tree 1281 * should be used instead. 1282 */ 1283 void __init unflatten_and_copy_device_tree(void) 1284 { 1285 int size; 1286 void *dt; 1287 1288 if (!initial_boot_params) { 1289 pr_warn("No valid device tree found, continuing without\n"); 1290 return; 1291 } 1292 1293 size = fdt_totalsize(initial_boot_params); 1294 dt = early_init_dt_alloc_memory_arch(size, 1295 roundup_pow_of_two(FDT_V17_SIZE)); 1296 1297 if (dt) { 1298 memcpy(dt, initial_boot_params, size); 1299 initial_boot_params = dt; 1300 } 1301 unflatten_device_tree(); 1302 } 1303 1304 #ifdef CONFIG_SYSFS 1305 static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj, 1306 struct bin_attribute *bin_attr, 1307 char *buf, loff_t off, size_t count) 1308 { 1309 memcpy(buf, initial_boot_params + off, count); 1310 return count; 1311 } 1312 1313 static int __init of_fdt_raw_init(void) 1314 { 1315 static struct bin_attribute of_fdt_raw_attr = 1316 __BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0); 1317 1318 if (!initial_boot_params) 1319 return 0; 1320 1321 if (of_fdt_crc32 != crc32_be(~0, initial_boot_params, 1322 fdt_totalsize(initial_boot_params))) { 1323 pr_warn("not creating '/sys/firmware/fdt': CRC check failed\n"); 1324 return 0; 1325 } 1326 of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params); 1327 return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr); 1328 } 1329 late_initcall(of_fdt_raw_init); 1330 #endif 1331 1332 #endif /* CONFIG_OF_EARLY_FLATTREE */ 1333