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