1/* 2 * Procedures for creating, accessing and interpreting the device tree. 3 * 4 * Paul Mackerras August 1996. 5 * Copyright (C) 1996-2005 Paul Mackerras. 6 * 7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 8 * {engebret|bergner}@us.ibm.com 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 */ 15 16#undef DEBUG 17 18#include <stdarg.h> 19#include <linux/kernel.h> 20#include <linux/string.h> 21#include <linux/init.h> 22#include <linux/threads.h> 23#include <linux/spinlock.h> 24#include <linux/types.h> 25#include <linux/pci.h> 26#include <linux/stringify.h> 27#include <linux/delay.h> 28#include <linux/initrd.h> 29#include <linux/bitops.h> 30#include <linux/export.h> 31#include <linux/kexec.h> 32#include <linux/irq.h> 33#include <linux/memblock.h> 34#include <linux/of.h> 35#include <linux/of_fdt.h> 36#include <linux/libfdt.h> 37 38#include <asm/prom.h> 39#include <asm/rtas.h> 40#include <asm/page.h> 41#include <asm/processor.h> 42#include <asm/irq.h> 43#include <asm/io.h> 44#include <asm/kdump.h> 45#include <asm/smp.h> 46#include <asm/mmu.h> 47#include <asm/paca.h> 48#include <asm/pgtable.h> 49#include <asm/pci.h> 50#include <asm/iommu.h> 51#include <asm/btext.h> 52#include <asm/sections.h> 53#include <asm/machdep.h> 54#include <asm/pci-bridge.h> 55#include <asm/kexec.h> 56#include <asm/opal.h> 57#include <asm/fadump.h> 58#include <asm/debug.h> 59 60#include <mm/mmu_decl.h> 61 62#ifdef DEBUG 63#define DBG(fmt...) printk(KERN_ERR fmt) 64#else 65#define DBG(fmt...) 66#endif 67 68#ifdef CONFIG_PPC64 69int __initdata iommu_is_off; 70int __initdata iommu_force_on; 71unsigned long tce_alloc_start, tce_alloc_end; 72u64 ppc64_rma_size; 73#endif 74static phys_addr_t first_memblock_size; 75static int __initdata boot_cpu_count; 76 77static int __init early_parse_mem(char *p) 78{ 79 if (!p) 80 return 1; 81 82 memory_limit = PAGE_ALIGN(memparse(p, &p)); 83 DBG("memory limit = 0x%llx\n", memory_limit); 84 85 return 0; 86} 87early_param("mem", early_parse_mem); 88 89/* 90 * overlaps_initrd - check for overlap with page aligned extension of 91 * initrd. 92 */ 93static inline int overlaps_initrd(unsigned long start, unsigned long size) 94{ 95#ifdef CONFIG_BLK_DEV_INITRD 96 if (!initrd_start) 97 return 0; 98 99 return (start + size) > _ALIGN_DOWN(initrd_start, PAGE_SIZE) && 100 start <= _ALIGN_UP(initrd_end, PAGE_SIZE); 101#else 102 return 0; 103#endif 104} 105 106/** 107 * move_device_tree - move tree to an unused area, if needed. 108 * 109 * The device tree may be allocated beyond our memory limit, or inside the 110 * crash kernel region for kdump, or within the page aligned range of initrd. 111 * If so, move it out of the way. 112 */ 113static void __init move_device_tree(void) 114{ 115 unsigned long start, size; 116 void *p; 117 118 DBG("-> move_device_tree\n"); 119 120 start = __pa(initial_boot_params); 121 size = fdt_totalsize(initial_boot_params); 122 123 if ((memory_limit && (start + size) > PHYSICAL_START + memory_limit) || 124 overlaps_crashkernel(start, size) || 125 overlaps_initrd(start, size)) { 126 p = __va(memblock_alloc(size, PAGE_SIZE)); 127 memcpy(p, initial_boot_params, size); 128 initial_boot_params = p; 129 DBG("Moved device tree to 0x%p\n", p); 130 } 131 132 DBG("<- move_device_tree\n"); 133} 134 135/* 136 * ibm,pa-features is a per-cpu property that contains a string of 137 * attribute descriptors, each of which has a 2 byte header plus up 138 * to 254 bytes worth of processor attribute bits. First header 139 * byte specifies the number of bytes following the header. 140 * Second header byte is an "attribute-specifier" type, of which 141 * zero is the only currently-defined value. 142 * Implementation: Pass in the byte and bit offset for the feature 143 * that we are interested in. The function will return -1 if the 144 * pa-features property is missing, or a 1/0 to indicate if the feature 145 * is supported/not supported. Note that the bit numbers are 146 * big-endian to match the definition in PAPR. 147 */ 148static struct ibm_pa_feature { 149 unsigned long cpu_features; /* CPU_FTR_xxx bit */ 150 unsigned long mmu_features; /* MMU_FTR_xxx bit */ 151 unsigned int cpu_user_ftrs; /* PPC_FEATURE_xxx bit */ 152 unsigned int cpu_user_ftrs2; /* PPC_FEATURE2_xxx bit */ 153 unsigned char pabyte; /* byte number in ibm,pa-features */ 154 unsigned char pabit; /* bit number (big-endian) */ 155 unsigned char invert; /* if 1, pa bit set => clear feature */ 156} ibm_pa_features[] __initdata = { 157 {0, 0, PPC_FEATURE_HAS_MMU, 0, 0, 0, 0}, 158 {0, 0, PPC_FEATURE_HAS_FPU, 0, 0, 1, 0}, 159 {CPU_FTR_CTRL, 0, 0, 0, 0, 3, 0}, 160 {CPU_FTR_NOEXECUTE, 0, 0, 0, 0, 6, 0}, 161 {CPU_FTR_NODSISRALIGN, 0, 0, 0, 1, 1, 1}, 162 {0, MMU_FTR_CI_LARGE_PAGE, 0, 0, 1, 2, 0}, 163 {CPU_FTR_REAL_LE, 0, PPC_FEATURE_TRUE_LE, 0, 5, 0, 0}, 164 /* 165 * If the kernel doesn't support TM (ie. CONFIG_PPC_TRANSACTIONAL_MEM=n), 166 * we don't want to turn on CPU_FTR_TM here, so we use CPU_FTR_TM_COMP 167 * which is 0 if the kernel doesn't support TM. 168 */ 169 {CPU_FTR_TM_COMP, 0, 0, 0, 22, 0, 0}, 170}; 171 172static void __init scan_features(unsigned long node, const unsigned char *ftrs, 173 unsigned long tablelen, 174 struct ibm_pa_feature *fp, 175 unsigned long ft_size) 176{ 177 unsigned long i, len, bit; 178 179 /* find descriptor with type == 0 */ 180 for (;;) { 181 if (tablelen < 3) 182 return; 183 len = 2 + ftrs[0]; 184 if (tablelen < len) 185 return; /* descriptor 0 not found */ 186 if (ftrs[1] == 0) 187 break; 188 tablelen -= len; 189 ftrs += len; 190 } 191 192 /* loop over bits we know about */ 193 for (i = 0; i < ft_size; ++i, ++fp) { 194 if (fp->pabyte >= ftrs[0]) 195 continue; 196 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1; 197 if (bit ^ fp->invert) { 198 cur_cpu_spec->cpu_features |= fp->cpu_features; 199 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs; 200 cur_cpu_spec->cpu_user_features2 |= fp->cpu_user_ftrs2; 201 cur_cpu_spec->mmu_features |= fp->mmu_features; 202 } else { 203 cur_cpu_spec->cpu_features &= ~fp->cpu_features; 204 cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs; 205 cur_cpu_spec->cpu_user_features2 &= ~fp->cpu_user_ftrs2; 206 cur_cpu_spec->mmu_features &= ~fp->mmu_features; 207 } 208 } 209} 210 211static void __init check_cpu_pa_features(unsigned long node) 212{ 213 const unsigned char *pa_ftrs; 214 int tablelen; 215 216 pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen); 217 if (pa_ftrs == NULL) 218 return; 219 220 scan_features(node, pa_ftrs, tablelen, 221 ibm_pa_features, ARRAY_SIZE(ibm_pa_features)); 222} 223 224#ifdef CONFIG_PPC_STD_MMU_64 225static void __init check_cpu_slb_size(unsigned long node) 226{ 227 const __be32 *slb_size_ptr; 228 229 slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL); 230 if (slb_size_ptr != NULL) { 231 mmu_slb_size = be32_to_cpup(slb_size_ptr); 232 return; 233 } 234 slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL); 235 if (slb_size_ptr != NULL) { 236 mmu_slb_size = be32_to_cpup(slb_size_ptr); 237 } 238} 239#else 240#define check_cpu_slb_size(node) do { } while(0) 241#endif 242 243static struct feature_property { 244 const char *name; 245 u32 min_value; 246 unsigned long cpu_feature; 247 unsigned long cpu_user_ftr; 248} feature_properties[] __initdata = { 249#ifdef CONFIG_ALTIVEC 250 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 251 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 252#endif /* CONFIG_ALTIVEC */ 253#ifdef CONFIG_VSX 254 /* Yes, this _really_ is ibm,vmx == 2 to enable VSX */ 255 {"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX}, 256#endif /* CONFIG_VSX */ 257#ifdef CONFIG_PPC64 258 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP}, 259 {"ibm,purr", 1, CPU_FTR_PURR, 0}, 260 {"ibm,spurr", 1, CPU_FTR_SPURR, 0}, 261#endif /* CONFIG_PPC64 */ 262}; 263 264#if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU) 265static inline void identical_pvr_fixup(unsigned long node) 266{ 267 unsigned int pvr; 268 const char *model = of_get_flat_dt_prop(node, "model", NULL); 269 270 /* 271 * Since 440GR(x)/440EP(x) processors have the same pvr, 272 * we check the node path and set bit 28 in the cur_cpu_spec 273 * pvr for EP(x) processor version. This bit is always 0 in 274 * the "real" pvr. Then we call identify_cpu again with 275 * the new logical pvr to enable FPU support. 276 */ 277 if (model && strstr(model, "440EP")) { 278 pvr = cur_cpu_spec->pvr_value | 0x8; 279 identify_cpu(0, pvr); 280 DBG("Using logical pvr %x for %s\n", pvr, model); 281 } 282} 283#else 284#define identical_pvr_fixup(node) do { } while(0) 285#endif 286 287static void __init check_cpu_feature_properties(unsigned long node) 288{ 289 unsigned long i; 290 struct feature_property *fp = feature_properties; 291 const __be32 *prop; 292 293 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) { 294 prop = of_get_flat_dt_prop(node, fp->name, NULL); 295 if (prop && be32_to_cpup(prop) >= fp->min_value) { 296 cur_cpu_spec->cpu_features |= fp->cpu_feature; 297 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr; 298 } 299 } 300} 301 302static int __init early_init_dt_scan_cpus(unsigned long node, 303 const char *uname, int depth, 304 void *data) 305{ 306 const char *type = of_get_flat_dt_prop(node, "device_type", NULL); 307 const __be32 *prop; 308 const __be32 *intserv; 309 int i, nthreads; 310 int len; 311 int found = -1; 312 int found_thread = 0; 313 314 /* We are scanning "cpu" nodes only */ 315 if (type == NULL || strcmp(type, "cpu") != 0) 316 return 0; 317 318 /* Get physical cpuid */ 319 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len); 320 if (!intserv) 321 intserv = of_get_flat_dt_prop(node, "reg", &len); 322 323 nthreads = len / sizeof(int); 324 325 /* 326 * Now see if any of these threads match our boot cpu. 327 * NOTE: This must match the parsing done in smp_setup_cpu_maps. 328 */ 329 for (i = 0; i < nthreads; i++) { 330 /* 331 * version 2 of the kexec param format adds the phys cpuid of 332 * booted proc. 333 */ 334 if (fdt_version(initial_boot_params) >= 2) { 335 if (be32_to_cpu(intserv[i]) == 336 fdt_boot_cpuid_phys(initial_boot_params)) { 337 found = boot_cpu_count; 338 found_thread = i; 339 } 340 } else { 341 /* 342 * Check if it's the boot-cpu, set it's hw index now, 343 * unfortunately this format did not support booting 344 * off secondary threads. 345 */ 346 if (of_get_flat_dt_prop(node, 347 "linux,boot-cpu", NULL) != NULL) 348 found = boot_cpu_count; 349 } 350#ifdef CONFIG_SMP 351 /* logical cpu id is always 0 on UP kernels */ 352 boot_cpu_count++; 353#endif 354 } 355 356 /* Not the boot CPU */ 357 if (found < 0) 358 return 0; 359 360 DBG("boot cpu: logical %d physical %d\n", found, 361 be32_to_cpu(intserv[found_thread])); 362 boot_cpuid = found; 363 set_hard_smp_processor_id(found, be32_to_cpu(intserv[found_thread])); 364 365 /* 366 * PAPR defines "logical" PVR values for cpus that 367 * meet various levels of the architecture: 368 * 0x0f000001 Architecture version 2.04 369 * 0x0f000002 Architecture version 2.05 370 * If the cpu-version property in the cpu node contains 371 * such a value, we call identify_cpu again with the 372 * logical PVR value in order to use the cpu feature 373 * bits appropriate for the architecture level. 374 * 375 * A POWER6 partition in "POWER6 architected" mode 376 * uses the 0x0f000002 PVR value; in POWER5+ mode 377 * it uses 0x0f000001. 378 */ 379 prop = of_get_flat_dt_prop(node, "cpu-version", NULL); 380 if (prop && (be32_to_cpup(prop) & 0xff000000) == 0x0f000000) 381 identify_cpu(0, be32_to_cpup(prop)); 382 383 identical_pvr_fixup(node); 384 385 check_cpu_feature_properties(node); 386 check_cpu_pa_features(node); 387 check_cpu_slb_size(node); 388 389#ifdef CONFIG_PPC64 390 if (nthreads > 1) 391 cur_cpu_spec->cpu_features |= CPU_FTR_SMT; 392 else 393 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT; 394#endif 395 return 0; 396} 397 398static int __init early_init_dt_scan_chosen_ppc(unsigned long node, 399 const char *uname, 400 int depth, void *data) 401{ 402 const unsigned long *lprop; /* All these set by kernel, so no need to convert endian */ 403 404 /* Use common scan routine to determine if this is the chosen node */ 405 if (early_init_dt_scan_chosen(node, uname, depth, data) == 0) 406 return 0; 407 408#ifdef CONFIG_PPC64 409 /* check if iommu is forced on or off */ 410 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL) 411 iommu_is_off = 1; 412 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL) 413 iommu_force_on = 1; 414#endif 415 416 /* mem=x on the command line is the preferred mechanism */ 417 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL); 418 if (lprop) 419 memory_limit = *lprop; 420 421#ifdef CONFIG_PPC64 422 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL); 423 if (lprop) 424 tce_alloc_start = *lprop; 425 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL); 426 if (lprop) 427 tce_alloc_end = *lprop; 428#endif 429 430#ifdef CONFIG_KEXEC 431 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL); 432 if (lprop) 433 crashk_res.start = *lprop; 434 435 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL); 436 if (lprop) 437 crashk_res.end = crashk_res.start + *lprop - 1; 438#endif 439 440 /* break now */ 441 return 1; 442} 443 444#ifdef CONFIG_PPC_PSERIES 445/* 446 * Interpret the ibm,dynamic-memory property in the 447 * /ibm,dynamic-reconfiguration-memory node. 448 * This contains a list of memory blocks along with NUMA affinity 449 * information. 450 */ 451static int __init early_init_dt_scan_drconf_memory(unsigned long node) 452{ 453 const __be32 *dm, *ls, *usm; 454 int l; 455 unsigned long n, flags; 456 u64 base, size, memblock_size; 457 unsigned int is_kexec_kdump = 0, rngs; 458 459 ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l); 460 if (ls == NULL || l < dt_root_size_cells * sizeof(__be32)) 461 return 0; 462 memblock_size = dt_mem_next_cell(dt_root_size_cells, &ls); 463 464 dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l); 465 if (dm == NULL || l < sizeof(__be32)) 466 return 0; 467 468 n = of_read_number(dm++, 1); /* number of entries */ 469 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(__be32)) 470 return 0; 471 472 /* check if this is a kexec/kdump kernel. */ 473 usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory", 474 &l); 475 if (usm != NULL) 476 is_kexec_kdump = 1; 477 478 for (; n != 0; --n) { 479 base = dt_mem_next_cell(dt_root_addr_cells, &dm); 480 flags = of_read_number(&dm[3], 1); 481 /* skip DRC index, pad, assoc. list index, flags */ 482 dm += 4; 483 /* skip this block if the reserved bit is set in flags (0x80) 484 or if the block is not assigned to this partition (0x8) */ 485 if ((flags & 0x80) || !(flags & 0x8)) 486 continue; 487 size = memblock_size; 488 rngs = 1; 489 if (is_kexec_kdump) { 490 /* 491 * For each memblock in ibm,dynamic-memory, a corresponding 492 * entry in linux,drconf-usable-memory property contains 493 * a counter 'p' followed by 'p' (base, size) duple. 494 * Now read the counter from 495 * linux,drconf-usable-memory property 496 */ 497 rngs = dt_mem_next_cell(dt_root_size_cells, &usm); 498 if (!rngs) /* there are no (base, size) duple */ 499 continue; 500 } 501 do { 502 if (is_kexec_kdump) { 503 base = dt_mem_next_cell(dt_root_addr_cells, 504 &usm); 505 size = dt_mem_next_cell(dt_root_size_cells, 506 &usm); 507 } 508 if (iommu_is_off) { 509 if (base >= 0x80000000ul) 510 continue; 511 if ((base + size) > 0x80000000ul) 512 size = 0x80000000ul - base; 513 } 514 memblock_add(base, size); 515 } while (--rngs); 516 } 517 memblock_dump_all(); 518 return 0; 519} 520#else 521#define early_init_dt_scan_drconf_memory(node) 0 522#endif /* CONFIG_PPC_PSERIES */ 523 524static int __init early_init_dt_scan_memory_ppc(unsigned long node, 525 const char *uname, 526 int depth, void *data) 527{ 528 if (depth == 1 && 529 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0) 530 return early_init_dt_scan_drconf_memory(node); 531 532 return early_init_dt_scan_memory(node, uname, depth, data); 533} 534 535/* 536 * For a relocatable kernel, we need to get the memstart_addr first, 537 * then use it to calculate the virtual kernel start address. This has 538 * to happen at a very early stage (before machine_init). In this case, 539 * we just want to get the memstart_address and would not like to mess the 540 * memblock at this stage. So introduce a variable to skip the memblock_add() 541 * for this reason. 542 */ 543#ifdef CONFIG_RELOCATABLE 544static int add_mem_to_memblock = 1; 545#else 546#define add_mem_to_memblock 1 547#endif 548 549void __init early_init_dt_add_memory_arch(u64 base, u64 size) 550{ 551#ifdef CONFIG_PPC64 552 if (iommu_is_off) { 553 if (base >= 0x80000000ul) 554 return; 555 if ((base + size) > 0x80000000ul) 556 size = 0x80000000ul - base; 557 } 558#endif 559 /* Keep track of the beginning of memory -and- the size of 560 * the very first block in the device-tree as it represents 561 * the RMA on ppc64 server 562 */ 563 if (base < memstart_addr) { 564 memstart_addr = base; 565 first_memblock_size = size; 566 } 567 568 /* Add the chunk to the MEMBLOCK list */ 569 if (add_mem_to_memblock) 570 memblock_add(base, size); 571} 572 573static void __init early_reserve_mem_dt(void) 574{ 575 unsigned long i, dt_root; 576 int len; 577 const __be32 *prop; 578 579 early_init_fdt_scan_reserved_mem(); 580 581 dt_root = of_get_flat_dt_root(); 582 583 prop = of_get_flat_dt_prop(dt_root, "reserved-ranges", &len); 584 585 if (!prop) 586 return; 587 588 DBG("Found new-style reserved-ranges\n"); 589 590 /* Each reserved range is an (address,size) pair, 2 cells each, 591 * totalling 4 cells per range. */ 592 for (i = 0; i < len / (sizeof(*prop) * 4); i++) { 593 u64 base, size; 594 595 base = of_read_number(prop + (i * 4) + 0, 2); 596 size = of_read_number(prop + (i * 4) + 2, 2); 597 598 if (size) { 599 DBG("reserving: %llx -> %llx\n", base, size); 600 memblock_reserve(base, size); 601 } 602 } 603} 604 605static void __init early_reserve_mem(void) 606{ 607 __be64 *reserve_map; 608 609 reserve_map = (__be64 *)(((unsigned long)initial_boot_params) + 610 fdt_off_mem_rsvmap(initial_boot_params)); 611 612 /* Look for the new "reserved-regions" property in the DT */ 613 early_reserve_mem_dt(); 614 615#ifdef CONFIG_BLK_DEV_INITRD 616 /* Then reserve the initrd, if any */ 617 if (initrd_start && (initrd_end > initrd_start)) { 618 memblock_reserve(_ALIGN_DOWN(__pa(initrd_start), PAGE_SIZE), 619 _ALIGN_UP(initrd_end, PAGE_SIZE) - 620 _ALIGN_DOWN(initrd_start, PAGE_SIZE)); 621 } 622#endif /* CONFIG_BLK_DEV_INITRD */ 623 624#ifdef CONFIG_PPC32 625 /* 626 * Handle the case where we might be booting from an old kexec 627 * image that setup the mem_rsvmap as pairs of 32-bit values 628 */ 629 if (be64_to_cpup(reserve_map) > 0xffffffffull) { 630 u32 base_32, size_32; 631 __be32 *reserve_map_32 = (__be32 *)reserve_map; 632 633 DBG("Found old 32-bit reserve map\n"); 634 635 while (1) { 636 base_32 = be32_to_cpup(reserve_map_32++); 637 size_32 = be32_to_cpup(reserve_map_32++); 638 if (size_32 == 0) 639 break; 640 DBG("reserving: %x -> %x\n", base_32, size_32); 641 memblock_reserve(base_32, size_32); 642 } 643 return; 644 } 645#endif 646} 647 648void __init early_init_devtree(void *params) 649{ 650 phys_addr_t limit; 651 652 DBG(" -> early_init_devtree(%p)\n", params); 653 654 /* Too early to BUG_ON(), do it by hand */ 655 if (!early_init_dt_verify(params)) 656 panic("BUG: Failed verifying flat device tree, bad version?"); 657 658#ifdef CONFIG_PPC_RTAS 659 /* Some machines might need RTAS info for debugging, grab it now. */ 660 of_scan_flat_dt(early_init_dt_scan_rtas, NULL); 661#endif 662 663#ifdef CONFIG_PPC_POWERNV 664 /* Some machines might need OPAL info for debugging, grab it now. */ 665 of_scan_flat_dt(early_init_dt_scan_opal, NULL); 666#endif 667 668#ifdef CONFIG_FA_DUMP 669 /* scan tree to see if dump is active during last boot */ 670 of_scan_flat_dt(early_init_dt_scan_fw_dump, NULL); 671#endif 672 673 /* Retrieve various informations from the /chosen node of the 674 * device-tree, including the platform type, initrd location and 675 * size, TCE reserve, and more ... 676 */ 677 of_scan_flat_dt(early_init_dt_scan_chosen_ppc, boot_command_line); 678 679 /* Scan memory nodes and rebuild MEMBLOCKs */ 680 of_scan_flat_dt(early_init_dt_scan_root, NULL); 681 of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL); 682 683 parse_early_param(); 684 685 /* make sure we've parsed cmdline for mem= before this */ 686 if (memory_limit) 687 first_memblock_size = min_t(u64, first_memblock_size, memory_limit); 688 setup_initial_memory_limit(memstart_addr, first_memblock_size); 689 /* Reserve MEMBLOCK regions used by kernel, initrd, dt, etc... */ 690 memblock_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START); 691 /* If relocatable, reserve first 32k for interrupt vectors etc. */ 692 if (PHYSICAL_START > MEMORY_START) 693 memblock_reserve(MEMORY_START, 0x8000); 694 reserve_kdump_trampoline(); 695#ifdef CONFIG_FA_DUMP 696 /* 697 * If we fail to reserve memory for firmware-assisted dump then 698 * fallback to kexec based kdump. 699 */ 700 if (fadump_reserve_mem() == 0) 701#endif 702 reserve_crashkernel(); 703 early_reserve_mem(); 704 705 /* Ensure that total memory size is page-aligned. */ 706 limit = ALIGN(memory_limit ?: memblock_phys_mem_size(), PAGE_SIZE); 707 memblock_enforce_memory_limit(limit); 708 709 memblock_allow_resize(); 710 memblock_dump_all(); 711 712 DBG("Phys. mem: %llx\n", memblock_phys_mem_size()); 713 714 /* We may need to relocate the flat tree, do it now. 715 * FIXME .. and the initrd too? */ 716 move_device_tree(); 717 718 allocate_pacas(); 719 720 DBG("Scanning CPUs ...\n"); 721 722 /* Retrieve CPU related informations from the flat tree 723 * (altivec support, boot CPU ID, ...) 724 */ 725 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 726 if (boot_cpuid < 0) { 727 printk("Failed to identify boot CPU !\n"); 728 BUG(); 729 } 730 731#if defined(CONFIG_SMP) && defined(CONFIG_PPC64) 732 /* We'll later wait for secondaries to check in; there are 733 * NCPUS-1 non-boot CPUs :-) 734 */ 735 spinning_secondaries = boot_cpu_count - 1; 736#endif 737 738#ifdef CONFIG_PPC_POWERNV 739 /* Scan and build the list of machine check recoverable ranges */ 740 of_scan_flat_dt(early_init_dt_scan_recoverable_ranges, NULL); 741#endif 742 743 DBG(" <- early_init_devtree()\n"); 744} 745 746#ifdef CONFIG_RELOCATABLE 747/* 748 * This function run before early_init_devtree, so we have to init 749 * initial_boot_params. 750 */ 751void __init early_get_first_memblock_info(void *params, phys_addr_t *size) 752{ 753 /* Setup flat device-tree pointer */ 754 initial_boot_params = params; 755 756 /* 757 * Scan the memory nodes and set add_mem_to_memblock to 0 to avoid 758 * mess the memblock. 759 */ 760 add_mem_to_memblock = 0; 761 of_scan_flat_dt(early_init_dt_scan_root, NULL); 762 of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL); 763 add_mem_to_memblock = 1; 764 765 if (size) 766 *size = first_memblock_size; 767} 768#endif 769 770/******* 771 * 772 * New implementation of the OF "find" APIs, return a refcounted 773 * object, call of_node_put() when done. The device tree and list 774 * are protected by a rw_lock. 775 * 776 * Note that property management will need some locking as well, 777 * this isn't dealt with yet. 778 * 779 *******/ 780 781/** 782 * of_get_ibm_chip_id - Returns the IBM "chip-id" of a device 783 * @np: device node of the device 784 * 785 * This looks for a property "ibm,chip-id" in the node or any 786 * of its parents and returns its content, or -1 if it cannot 787 * be found. 788 */ 789int of_get_ibm_chip_id(struct device_node *np) 790{ 791 of_node_get(np); 792 while(np) { 793 struct device_node *old = np; 794 const __be32 *prop; 795 796 prop = of_get_property(np, "ibm,chip-id", NULL); 797 if (prop) { 798 of_node_put(np); 799 return be32_to_cpup(prop); 800 } 801 np = of_get_parent(np); 802 of_node_put(old); 803 } 804 return -1; 805} 806 807/** 808 * cpu_to_chip_id - Return the cpus chip-id 809 * @cpu: The logical cpu number. 810 * 811 * Return the value of the ibm,chip-id property corresponding to the given 812 * logical cpu number. If the chip-id can not be found, returns -1. 813 */ 814int cpu_to_chip_id(int cpu) 815{ 816 struct device_node *np; 817 818 np = of_get_cpu_node(cpu, NULL); 819 if (!np) 820 return -1; 821 822 of_node_put(np); 823 return of_get_ibm_chip_id(np); 824} 825EXPORT_SYMBOL(cpu_to_chip_id); 826 827bool arch_match_cpu_phys_id(int cpu, u64 phys_id) 828{ 829 return (int)phys_id == get_hard_smp_processor_id(cpu); 830} 831