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