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