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 */ 39void 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 */ 89int 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 */ 120bool 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 */ 133int 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 151static 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 */ 171static 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 */ 381static 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 431static 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 */ 444void of_fdt_unflatten_tree(unsigned long *blob, 445 struct device_node **mynodes) 446{ 447 __unflatten_device_tree(blob, mynodes, &kernel_tree_alloc); 448} 449EXPORT_SYMBOL_GPL(of_fdt_unflatten_tree); 450 451/* Everything below here references initial_boot_params directly. */ 452int __initdata dt_root_addr_cells; 453int __initdata dt_root_size_cells; 454 455void *initial_boot_params; 456 457#ifdef CONFIG_OF_EARLY_FLATTREE 458 459static u32 of_fdt_crc32; 460 461/** 462 * res_mem_reserve_reg() - reserve all memory described in 'reg' property 463 */ 464static 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 */ 511static 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 */ 532static 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 */ 575void __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 */ 609int __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 */ 633unsigned 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 */ 641int __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 */ 652const 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 */ 663int __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 */ 671int __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 676struct 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 685const 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 */ 705const 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 */ 750static 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 776static 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 782extern struct of_device_id __earlycon_of_table[]; 783 784static 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 826static int __init setup_of_earlycon(char *buf) 827{ 828 if (buf) 829 return 0; 830 831 return early_init_dt_scan_chosen_serial(); 832} 833early_param("earlycon", setup_of_earlycon); 834#endif 835 836/** 837 * early_init_dt_scan_root - fetch the top level address and size cells 838 */ 839int __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 864u64 __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 */ 875int __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 920int __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#ifndef MAX_MEMBLOCK_ADDR 959#define MAX_MEMBLOCK_ADDR ((phys_addr_t)~0) 960#endif 961 962void __init __weak early_init_dt_add_memory_arch(u64 base, u64 size) 963{ 964 const u64 phys_offset = __pa(PAGE_OFFSET); 965 966 if (!PAGE_ALIGNED(base)) { 967 if (size < PAGE_SIZE - (base & ~PAGE_MASK)) { 968 pr_warn("Ignoring memory block 0x%llx - 0x%llx\n", 969 base, base + size); 970 return; 971 } 972 size -= PAGE_SIZE - (base & ~PAGE_MASK); 973 base = PAGE_ALIGN(base); 974 } 975 size &= PAGE_MASK; 976 977 if (base > MAX_MEMBLOCK_ADDR) { 978 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n", 979 base, base + size); 980 return; 981 } 982 983 if (base + size - 1 > MAX_MEMBLOCK_ADDR) { 984 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n", 985 ((u64)MAX_MEMBLOCK_ADDR) + 1, base + size); 986 size = MAX_MEMBLOCK_ADDR - base + 1; 987 } 988 989 if (base + size < phys_offset) { 990 pr_warning("Ignoring memory block 0x%llx - 0x%llx\n", 991 base, base + size); 992 return; 993 } 994 if (base < phys_offset) { 995 pr_warning("Ignoring memory range 0x%llx - 0x%llx\n", 996 base, phys_offset); 997 size -= phys_offset - base; 998 base = phys_offset; 999 } 1000 memblock_add(base, size); 1001} 1002 1003int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base, 1004 phys_addr_t size, bool nomap) 1005{ 1006 if (nomap) 1007 return memblock_remove(base, size); 1008 return memblock_reserve(base, size); 1009} 1010 1011/* 1012 * called from unflatten_device_tree() to bootstrap devicetree itself 1013 * Architectures can override this definition if memblock isn't used 1014 */ 1015void * __init __weak early_init_dt_alloc_memory_arch(u64 size, u64 align) 1016{ 1017 return __va(memblock_alloc(size, align)); 1018} 1019#else 1020int __init __weak early_init_dt_reserve_memory_arch(phys_addr_t base, 1021 phys_addr_t size, bool nomap) 1022{ 1023 pr_err("Reserved memory not supported, ignoring range 0x%pa - 0x%pa%s\n", 1024 &base, &size, nomap ? " (nomap)" : ""); 1025 return -ENOSYS; 1026} 1027#endif 1028 1029bool __init early_init_dt_verify(void *params) 1030{ 1031 if (!params) 1032 return false; 1033 1034 /* check device tree validity */ 1035 if (fdt_check_header(params)) 1036 return false; 1037 1038 /* Setup flat device-tree pointer */ 1039 initial_boot_params = params; 1040 of_fdt_crc32 = crc32_be(~0, initial_boot_params, 1041 fdt_totalsize(initial_boot_params)); 1042 return true; 1043} 1044 1045 1046void __init early_init_dt_scan_nodes(void) 1047{ 1048 /* Retrieve various information from the /chosen node */ 1049 of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line); 1050 1051 /* Initialize {size,address}-cells info */ 1052 of_scan_flat_dt(early_init_dt_scan_root, NULL); 1053 1054 /* Setup memory, calling early_init_dt_add_memory_arch */ 1055 of_scan_flat_dt(early_init_dt_scan_memory, NULL); 1056} 1057 1058bool __init early_init_dt_scan(void *params) 1059{ 1060 bool status; 1061 1062 status = early_init_dt_verify(params); 1063 if (!status) 1064 return false; 1065 1066 early_init_dt_scan_nodes(); 1067 return true; 1068} 1069 1070/** 1071 * unflatten_device_tree - create tree of device_nodes from flat blob 1072 * 1073 * unflattens the device-tree passed by the firmware, creating the 1074 * tree of struct device_node. It also fills the "name" and "type" 1075 * pointers of the nodes so the normal device-tree walking functions 1076 * can be used. 1077 */ 1078void __init unflatten_device_tree(void) 1079{ 1080 __unflatten_device_tree(initial_boot_params, &of_root, 1081 early_init_dt_alloc_memory_arch); 1082 1083 /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */ 1084 of_alias_scan(early_init_dt_alloc_memory_arch); 1085} 1086 1087/** 1088 * unflatten_and_copy_device_tree - copy and create tree of device_nodes from flat blob 1089 * 1090 * Copies and unflattens the device-tree passed by the firmware, creating the 1091 * tree of struct device_node. It also fills the "name" and "type" 1092 * pointers of the nodes so the normal device-tree walking functions 1093 * can be used. This should only be used when the FDT memory has not been 1094 * reserved such is the case when the FDT is built-in to the kernel init 1095 * section. If the FDT memory is reserved already then unflatten_device_tree 1096 * should be used instead. 1097 */ 1098void __init unflatten_and_copy_device_tree(void) 1099{ 1100 int size; 1101 void *dt; 1102 1103 if (!initial_boot_params) { 1104 pr_warn("No valid device tree found, continuing without\n"); 1105 return; 1106 } 1107 1108 size = fdt_totalsize(initial_boot_params); 1109 dt = early_init_dt_alloc_memory_arch(size, 1110 roundup_pow_of_two(FDT_V17_SIZE)); 1111 1112 if (dt) { 1113 memcpy(dt, initial_boot_params, size); 1114 initial_boot_params = dt; 1115 } 1116 unflatten_device_tree(); 1117} 1118 1119#ifdef CONFIG_SYSFS 1120static ssize_t of_fdt_raw_read(struct file *filp, struct kobject *kobj, 1121 struct bin_attribute *bin_attr, 1122 char *buf, loff_t off, size_t count) 1123{ 1124 memcpy(buf, initial_boot_params + off, count); 1125 return count; 1126} 1127 1128static int __init of_fdt_raw_init(void) 1129{ 1130 static struct bin_attribute of_fdt_raw_attr = 1131 __BIN_ATTR(fdt, S_IRUSR, of_fdt_raw_read, NULL, 0); 1132 1133 if (!initial_boot_params) 1134 return 0; 1135 1136 if (of_fdt_crc32 != crc32_be(~0, initial_boot_params, 1137 fdt_totalsize(initial_boot_params))) { 1138 pr_warn("fdt: not creating '/sys/firmware/fdt': CRC check failed\n"); 1139 return 0; 1140 } 1141 of_fdt_raw_attr.size = fdt_totalsize(initial_boot_params); 1142 return sysfs_create_bin_file(firmware_kobj, &of_fdt_raw_attr); 1143} 1144late_initcall(of_fdt_raw_init); 1145#endif 1146 1147#endif /* CONFIG_OF_EARLY_FLATTREE */ 1148