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