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