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