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