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