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