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/module.h> 31#include <linux/kexec.h> 32#include <linux/debugfs.h> 33#include <linux/irq.h> 34#include <linux/memblock.h> 35 36#include <asm/prom.h> 37#include <asm/rtas.h> 38#include <asm/page.h> 39#include <asm/processor.h> 40#include <asm/irq.h> 41#include <asm/io.h> 42#include <asm/kdump.h> 43#include <asm/smp.h> 44#include <asm/system.h> 45#include <asm/mmu.h> 46#include <asm/paca.h> 47#include <asm/pgtable.h> 48#include <asm/pci.h> 49#include <asm/iommu.h> 50#include <asm/btext.h> 51#include <asm/sections.h> 52#include <asm/machdep.h> 53#include <asm/pSeries_reconfig.h> 54#include <asm/pci-bridge.h> 55#include <asm/phyp_dump.h> 56#include <asm/kexec.h> 57#include <mm/mmu_decl.h> 58 59#ifdef DEBUG 60#define DBG(fmt...) printk(KERN_ERR fmt) 61#else 62#define DBG(fmt...) 63#endif 64 65#ifdef CONFIG_PPC64 66int __initdata iommu_is_off; 67int __initdata iommu_force_on; 68unsigned long tce_alloc_start, tce_alloc_end; 69#endif 70 71static int __init early_parse_mem(char *p) 72{ 73 if (!p) 74 return 1; 75 76 memory_limit = PAGE_ALIGN(memparse(p, &p)); 77 DBG("memory limit = 0x%llx\n", (unsigned long long)memory_limit); 78 79 return 0; 80} 81early_param("mem", early_parse_mem); 82 83/** 84 * move_device_tree - move tree to an unused area, if needed. 85 * 86 * The device tree may be allocated beyond our memory limit, or inside the 87 * crash kernel region for kdump. If so, move it out of the way. 88 */ 89static void __init move_device_tree(void) 90{ 91 unsigned long start, size; 92 void *p; 93 94 DBG("-> move_device_tree\n"); 95 96 start = __pa(initial_boot_params); 97 size = be32_to_cpu(initial_boot_params->totalsize); 98 99 if ((memory_limit && (start + size) > memory_limit) || 100 overlaps_crashkernel(start, size)) { 101 p = __va(memblock_alloc_base(size, PAGE_SIZE, memblock.rmo_size)); 102 memcpy(p, initial_boot_params, size); 103 initial_boot_params = (struct boot_param_header *)p; 104 DBG("Moved device tree to 0x%p\n", p); 105 } 106 107 DBG("<- move_device_tree\n"); 108} 109 110/* 111 * ibm,pa-features is a per-cpu property that contains a string of 112 * attribute descriptors, each of which has a 2 byte header plus up 113 * to 254 bytes worth of processor attribute bits. First header 114 * byte specifies the number of bytes following the header. 115 * Second header byte is an "attribute-specifier" type, of which 116 * zero is the only currently-defined value. 117 * Implementation: Pass in the byte and bit offset for the feature 118 * that we are interested in. The function will return -1 if the 119 * pa-features property is missing, or a 1/0 to indicate if the feature 120 * is supported/not supported. Note that the bit numbers are 121 * big-endian to match the definition in PAPR. 122 */ 123static struct ibm_pa_feature { 124 unsigned long cpu_features; /* CPU_FTR_xxx bit */ 125 unsigned int cpu_user_ftrs; /* PPC_FEATURE_xxx bit */ 126 unsigned char pabyte; /* byte number in ibm,pa-features */ 127 unsigned char pabit; /* bit number (big-endian) */ 128 unsigned char invert; /* if 1, pa bit set => clear feature */ 129} ibm_pa_features[] __initdata = { 130 {0, PPC_FEATURE_HAS_MMU, 0, 0, 0}, 131 {0, PPC_FEATURE_HAS_FPU, 0, 1, 0}, 132 {CPU_FTR_SLB, 0, 0, 2, 0}, 133 {CPU_FTR_CTRL, 0, 0, 3, 0}, 134 {CPU_FTR_NOEXECUTE, 0, 0, 6, 0}, 135 {CPU_FTR_NODSISRALIGN, 0, 1, 1, 1}, 136 {CPU_FTR_CI_LARGE_PAGE, 0, 1, 2, 0}, 137 {CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0}, 138}; 139 140static void __init scan_features(unsigned long node, unsigned char *ftrs, 141 unsigned long tablelen, 142 struct ibm_pa_feature *fp, 143 unsigned long ft_size) 144{ 145 unsigned long i, len, bit; 146 147 /* find descriptor with type == 0 */ 148 for (;;) { 149 if (tablelen < 3) 150 return; 151 len = 2 + ftrs[0]; 152 if (tablelen < len) 153 return; /* descriptor 0 not found */ 154 if (ftrs[1] == 0) 155 break; 156 tablelen -= len; 157 ftrs += len; 158 } 159 160 /* loop over bits we know about */ 161 for (i = 0; i < ft_size; ++i, ++fp) { 162 if (fp->pabyte >= ftrs[0]) 163 continue; 164 bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1; 165 if (bit ^ fp->invert) { 166 cur_cpu_spec->cpu_features |= fp->cpu_features; 167 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs; 168 } else { 169 cur_cpu_spec->cpu_features &= ~fp->cpu_features; 170 cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs; 171 } 172 } 173} 174 175static void __init check_cpu_pa_features(unsigned long node) 176{ 177 unsigned char *pa_ftrs; 178 unsigned long tablelen; 179 180 pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen); 181 if (pa_ftrs == NULL) 182 return; 183 184 scan_features(node, pa_ftrs, tablelen, 185 ibm_pa_features, ARRAY_SIZE(ibm_pa_features)); 186} 187 188#ifdef CONFIG_PPC_STD_MMU_64 189static void __init check_cpu_slb_size(unsigned long node) 190{ 191 u32 *slb_size_ptr; 192 193 slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL); 194 if (slb_size_ptr != NULL) { 195 mmu_slb_size = *slb_size_ptr; 196 return; 197 } 198 slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL); 199 if (slb_size_ptr != NULL) { 200 mmu_slb_size = *slb_size_ptr; 201 } 202} 203#else 204#define check_cpu_slb_size(node) do { } while(0) 205#endif 206 207static struct feature_property { 208 const char *name; 209 u32 min_value; 210 unsigned long cpu_feature; 211 unsigned long cpu_user_ftr; 212} feature_properties[] __initdata = { 213#ifdef CONFIG_ALTIVEC 214 {"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 215 {"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC}, 216#endif /* CONFIG_ALTIVEC */ 217#ifdef CONFIG_VSX 218 /* Yes, this _really_ is ibm,vmx == 2 to enable VSX */ 219 {"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX}, 220#endif /* CONFIG_VSX */ 221#ifdef CONFIG_PPC64 222 {"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP}, 223 {"ibm,purr", 1, CPU_FTR_PURR, 0}, 224 {"ibm,spurr", 1, CPU_FTR_SPURR, 0}, 225#endif /* CONFIG_PPC64 */ 226}; 227 228#if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU) 229static inline void identical_pvr_fixup(unsigned long node) 230{ 231 unsigned int pvr; 232 char *model = of_get_flat_dt_prop(node, "model", NULL); 233 234 /* 235 * Since 440GR(x)/440EP(x) processors have the same pvr, 236 * we check the node path and set bit 28 in the cur_cpu_spec 237 * pvr for EP(x) processor version. This bit is always 0 in 238 * the "real" pvr. Then we call identify_cpu again with 239 * the new logical pvr to enable FPU support. 240 */ 241 if (model && strstr(model, "440EP")) { 242 pvr = cur_cpu_spec->pvr_value | 0x8; 243 identify_cpu(0, pvr); 244 DBG("Using logical pvr %x for %s\n", pvr, model); 245 } 246} 247#else 248#define identical_pvr_fixup(node) do { } while(0) 249#endif 250 251static void __init check_cpu_feature_properties(unsigned long node) 252{ 253 unsigned long i; 254 struct feature_property *fp = feature_properties; 255 const u32 *prop; 256 257 for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) { 258 prop = of_get_flat_dt_prop(node, fp->name, NULL); 259 if (prop && *prop >= fp->min_value) { 260 cur_cpu_spec->cpu_features |= fp->cpu_feature; 261 cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr; 262 } 263 } 264} 265 266static int __init early_init_dt_scan_cpus(unsigned long node, 267 const char *uname, int depth, 268 void *data) 269{ 270 static int logical_cpuid = 0; 271 char *type = of_get_flat_dt_prop(node, "device_type", NULL); 272 const u32 *prop; 273 const u32 *intserv; 274 int i, nthreads; 275 unsigned long len; 276 int found = 0; 277 278 /* We are scanning "cpu" nodes only */ 279 if (type == NULL || strcmp(type, "cpu") != 0) 280 return 0; 281 282 /* Get physical cpuid */ 283 intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len); 284 if (intserv) { 285 nthreads = len / sizeof(int); 286 } else { 287 intserv = of_get_flat_dt_prop(node, "reg", NULL); 288 nthreads = 1; 289 } 290 291 /* 292 * Now see if any of these threads match our boot cpu. 293 * NOTE: This must match the parsing done in smp_setup_cpu_maps. 294 */ 295 for (i = 0; i < nthreads; i++) { 296 /* 297 * version 2 of the kexec param format adds the phys cpuid of 298 * booted proc. 299 */ 300 if (initial_boot_params && initial_boot_params->version >= 2) { 301 if (intserv[i] == 302 initial_boot_params->boot_cpuid_phys) { 303 found = 1; 304 break; 305 } 306 } else { 307 /* 308 * Check if it's the boot-cpu, set it's hw index now, 309 * unfortunately this format did not support booting 310 * off secondary threads. 311 */ 312 if (of_get_flat_dt_prop(node, 313 "linux,boot-cpu", NULL) != NULL) { 314 found = 1; 315 break; 316 } 317 } 318 319#ifdef CONFIG_SMP 320 /* logical cpu id is always 0 on UP kernels */ 321 logical_cpuid++; 322#endif 323 } 324 325 if (found) { 326 DBG("boot cpu: logical %d physical %d\n", logical_cpuid, 327 intserv[i]); 328 boot_cpuid = logical_cpuid; 329 set_hard_smp_processor_id(boot_cpuid, intserv[i]); 330 331 /* 332 * PAPR defines "logical" PVR values for cpus that 333 * meet various levels of the architecture: 334 * 0x0f000001 Architecture version 2.04 335 * 0x0f000002 Architecture version 2.05 336 * If the cpu-version property in the cpu node contains 337 * such a value, we call identify_cpu again with the 338 * logical PVR value in order to use the cpu feature 339 * bits appropriate for the architecture level. 340 * 341 * A POWER6 partition in "POWER6 architected" mode 342 * uses the 0x0f000002 PVR value; in POWER5+ mode 343 * it uses 0x0f000001. 344 */ 345 prop = of_get_flat_dt_prop(node, "cpu-version", NULL); 346 if (prop && (*prop & 0xff000000) == 0x0f000000) 347 identify_cpu(0, *prop); 348 349 identical_pvr_fixup(node); 350 } 351 352 check_cpu_feature_properties(node); 353 check_cpu_pa_features(node); 354 check_cpu_slb_size(node); 355 356#ifdef CONFIG_PPC_PSERIES 357 if (nthreads > 1) 358 cur_cpu_spec->cpu_features |= CPU_FTR_SMT; 359 else 360 cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT; 361#endif 362 363 return 0; 364} 365 366void __init early_init_dt_scan_chosen_arch(unsigned long node) 367{ 368 unsigned long *lprop; 369 370#ifdef CONFIG_PPC64 371 /* check if iommu is forced on or off */ 372 if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL) 373 iommu_is_off = 1; 374 if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL) 375 iommu_force_on = 1; 376#endif 377 378 /* mem=x on the command line is the preferred mechanism */ 379 lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL); 380 if (lprop) 381 memory_limit = *lprop; 382 383#ifdef CONFIG_PPC64 384 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL); 385 if (lprop) 386 tce_alloc_start = *lprop; 387 lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL); 388 if (lprop) 389 tce_alloc_end = *lprop; 390#endif 391 392#ifdef CONFIG_KEXEC 393 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL); 394 if (lprop) 395 crashk_res.start = *lprop; 396 397 lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL); 398 if (lprop) 399 crashk_res.end = crashk_res.start + *lprop - 1; 400#endif 401} 402 403#ifdef CONFIG_PPC_PSERIES 404/* 405 * Interpret the ibm,dynamic-memory property in the 406 * /ibm,dynamic-reconfiguration-memory node. 407 * This contains a list of memory blocks along with NUMA affinity 408 * information. 409 */ 410static int __init early_init_dt_scan_drconf_memory(unsigned long node) 411{ 412 __be32 *dm, *ls, *usm; 413 unsigned long l, n, flags; 414 u64 base, size, memblock_size; 415 unsigned int is_kexec_kdump = 0, rngs; 416 417 ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l); 418 if (ls == NULL || l < dt_root_size_cells * sizeof(__be32)) 419 return 0; 420 memblock_size = dt_mem_next_cell(dt_root_size_cells, &ls); 421 422 dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l); 423 if (dm == NULL || l < sizeof(__be32)) 424 return 0; 425 426 n = *dm++; /* number of entries */ 427 if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(__be32)) 428 return 0; 429 430 /* check if this is a kexec/kdump kernel. */ 431 usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory", 432 &l); 433 if (usm != NULL) 434 is_kexec_kdump = 1; 435 436 for (; n != 0; --n) { 437 base = dt_mem_next_cell(dt_root_addr_cells, &dm); 438 flags = dm[3]; 439 /* skip DRC index, pad, assoc. list index, flags */ 440 dm += 4; 441 /* skip this block if the reserved bit is set in flags (0x80) 442 or if the block is not assigned to this partition (0x8) */ 443 if ((flags & 0x80) || !(flags & 0x8)) 444 continue; 445 size = memblock_size; 446 rngs = 1; 447 if (is_kexec_kdump) { 448 /* 449 * For each memblock in ibm,dynamic-memory, a corresponding 450 * entry in linux,drconf-usable-memory property contains 451 * a counter 'p' followed by 'p' (base, size) duple. 452 * Now read the counter from 453 * linux,drconf-usable-memory property 454 */ 455 rngs = dt_mem_next_cell(dt_root_size_cells, &usm); 456 if (!rngs) /* there are no (base, size) duple */ 457 continue; 458 } 459 do { 460 if (is_kexec_kdump) { 461 base = dt_mem_next_cell(dt_root_addr_cells, 462 &usm); 463 size = dt_mem_next_cell(dt_root_size_cells, 464 &usm); 465 } 466 if (iommu_is_off) { 467 if (base >= 0x80000000ul) 468 continue; 469 if ((base + size) > 0x80000000ul) 470 size = 0x80000000ul - base; 471 } 472 memblock_add(base, size); 473 } while (--rngs); 474 } 475 memblock_dump_all(); 476 return 0; 477} 478#else 479#define early_init_dt_scan_drconf_memory(node) 0 480#endif /* CONFIG_PPC_PSERIES */ 481 482static int __init early_init_dt_scan_memory_ppc(unsigned long node, 483 const char *uname, 484 int depth, void *data) 485{ 486 if (depth == 1 && 487 strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0) 488 return early_init_dt_scan_drconf_memory(node); 489 490 return early_init_dt_scan_memory(node, uname, depth, data); 491} 492 493void __init early_init_dt_add_memory_arch(u64 base, u64 size) 494{ 495#if defined(CONFIG_PPC64) 496 if (iommu_is_off) { 497 if (base >= 0x80000000ul) 498 return; 499 if ((base + size) > 0x80000000ul) 500 size = 0x80000000ul - base; 501 } 502#endif 503 504 memblock_add(base, size); 505 506 memstart_addr = min((u64)memstart_addr, base); 507} 508 509u64 __init early_init_dt_alloc_memory_arch(u64 size, u64 align) 510{ 511 return memblock_alloc(size, align); 512} 513 514#ifdef CONFIG_BLK_DEV_INITRD 515void __init early_init_dt_setup_initrd_arch(unsigned long start, 516 unsigned long end) 517{ 518 initrd_start = (unsigned long)__va(start); 519 initrd_end = (unsigned long)__va(end); 520 initrd_below_start_ok = 1; 521} 522#endif 523 524static void __init early_reserve_mem(void) 525{ 526 u64 base, size; 527 u64 *reserve_map; 528 unsigned long self_base; 529 unsigned long self_size; 530 531 reserve_map = (u64 *)(((unsigned long)initial_boot_params) + 532 initial_boot_params->off_mem_rsvmap); 533 534 /* before we do anything, lets reserve the dt blob */ 535 self_base = __pa((unsigned long)initial_boot_params); 536 self_size = initial_boot_params->totalsize; 537 memblock_reserve(self_base, self_size); 538 539#ifdef CONFIG_BLK_DEV_INITRD 540 /* then reserve the initrd, if any */ 541 if (initrd_start && (initrd_end > initrd_start)) 542 memblock_reserve(__pa(initrd_start), initrd_end - initrd_start); 543#endif /* CONFIG_BLK_DEV_INITRD */ 544 545#ifdef CONFIG_PPC32 546 /* 547 * Handle the case where we might be booting from an old kexec 548 * image that setup the mem_rsvmap as pairs of 32-bit values 549 */ 550 if (*reserve_map > 0xffffffffull) { 551 u32 base_32, size_32; 552 u32 *reserve_map_32 = (u32 *)reserve_map; 553 554 while (1) { 555 base_32 = *(reserve_map_32++); 556 size_32 = *(reserve_map_32++); 557 if (size_32 == 0) 558 break; 559 /* skip if the reservation is for the blob */ 560 if (base_32 == self_base && size_32 == self_size) 561 continue; 562 DBG("reserving: %x -> %x\n", base_32, size_32); 563 memblock_reserve(base_32, size_32); 564 } 565 return; 566 } 567#endif 568 while (1) { 569 base = *(reserve_map++); 570 size = *(reserve_map++); 571 if (size == 0) 572 break; 573 DBG("reserving: %llx -> %llx\n", base, size); 574 memblock_reserve(base, size); 575 } 576} 577 578#ifdef CONFIG_PHYP_DUMP 579/** 580 * phyp_dump_calculate_reserve_size() - reserve variable boot area 5% or arg 581 * 582 * Function to find the largest size we need to reserve 583 * during early boot process. 584 * 585 * It either looks for boot param and returns that OR 586 * returns larger of 256 or 5% rounded down to multiples of 256MB. 587 * 588 */ 589static inline unsigned long phyp_dump_calculate_reserve_size(void) 590{ 591 unsigned long tmp; 592 593 if (phyp_dump_info->reserve_bootvar) 594 return phyp_dump_info->reserve_bootvar; 595 596 /* divide by 20 to get 5% of value */ 597 tmp = memblock_end_of_DRAM(); 598 do_div(tmp, 20); 599 600 /* round it down in multiples of 256 */ 601 tmp = tmp & ~0x0FFFFFFFUL; 602 603 return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END); 604} 605 606/** 607 * phyp_dump_reserve_mem() - reserve all not-yet-dumped mmemory 608 * 609 * This routine may reserve memory regions in the kernel only 610 * if the system is supported and a dump was taken in last 611 * boot instance or if the hardware is supported and the 612 * scratch area needs to be setup. In other instances it returns 613 * without reserving anything. The memory in case of dump being 614 * active is freed when the dump is collected (by userland tools). 615 */ 616static void __init phyp_dump_reserve_mem(void) 617{ 618 unsigned long base, size; 619 unsigned long variable_reserve_size; 620 621 if (!phyp_dump_info->phyp_dump_configured) { 622 printk(KERN_ERR "Phyp-dump not supported on this hardware\n"); 623 return; 624 } 625 626 if (!phyp_dump_info->phyp_dump_at_boot) { 627 printk(KERN_INFO "Phyp-dump disabled at boot time\n"); 628 return; 629 } 630 631 variable_reserve_size = phyp_dump_calculate_reserve_size(); 632 633 if (phyp_dump_info->phyp_dump_is_active) { 634 /* Reserve *everything* above RMR.Area freed by userland tools*/ 635 base = variable_reserve_size; 636 size = memblock_end_of_DRAM() - base; 637 638 memblock_reserve(base, size); 639 640 phyp_dump_info->init_reserve_start = base; 641 phyp_dump_info->init_reserve_size = size; 642 } else { 643 size = phyp_dump_info->cpu_state_size + 644 phyp_dump_info->hpte_region_size + 645 variable_reserve_size; 646 base = memblock_end_of_DRAM() - size; 647 memblock_reserve(base, size); 648 phyp_dump_info->init_reserve_start = base; 649 phyp_dump_info->init_reserve_size = size; 650 } 651} 652#else 653static inline void __init phyp_dump_reserve_mem(void) {} 654#endif /* CONFIG_PHYP_DUMP && CONFIG_PPC_RTAS */ 655 656 657void __init early_init_devtree(void *params) 658{ 659 phys_addr_t limit; 660 661 DBG(" -> early_init_devtree(%p)\n", params); 662 663 /* Setup flat device-tree pointer */ 664 initial_boot_params = params; 665 666#ifdef CONFIG_PPC_RTAS 667 /* Some machines might need RTAS info for debugging, grab it now. */ 668 of_scan_flat_dt(early_init_dt_scan_rtas, NULL); 669#endif 670 671#ifdef CONFIG_PHYP_DUMP 672 /* scan tree to see if dump occured during last boot */ 673 of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL); 674#endif 675 676 /* Retrieve various informations from the /chosen node of the 677 * device-tree, including the platform type, initrd location and 678 * size, TCE reserve, and more ... 679 */ 680 of_scan_flat_dt(early_init_dt_scan_chosen, NULL); 681 682 /* Scan memory nodes and rebuild MEMBLOCKs */ 683 memblock_init(); 684 of_scan_flat_dt(early_init_dt_scan_root, NULL); 685 of_scan_flat_dt(early_init_dt_scan_memory_ppc, NULL); 686 687 /* Save command line for /proc/cmdline and then parse parameters */ 688 strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE); 689 parse_early_param(); 690 691 /* Reserve MEMBLOCK regions used by kernel, initrd, dt, etc... */ 692 memblock_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START); 693 /* If relocatable, reserve first 32k for interrupt vectors etc. */ 694 if (PHYSICAL_START > MEMORY_START) 695 memblock_reserve(MEMORY_START, 0x8000); 696 reserve_kdump_trampoline(); 697 reserve_crashkernel(); 698 early_reserve_mem(); 699 phyp_dump_reserve_mem(); 700 701 limit = memory_limit; 702 if (! limit) { 703 phys_addr_t memsize; 704 705 /* Ensure that total memory size is page-aligned, because 706 * otherwise mark_bootmem() gets upset. */ 707 memblock_analyze(); 708 memsize = memblock_phys_mem_size(); 709 if ((memsize & PAGE_MASK) != memsize) 710 limit = memsize & PAGE_MASK; 711 } 712 memblock_enforce_memory_limit(limit); 713 714 memblock_analyze(); 715 memblock_dump_all(); 716 717 DBG("Phys. mem: %llx\n", memblock_phys_mem_size()); 718 719 move_device_tree(); 720 721 allocate_pacas(); 722 723 DBG("Scanning CPUs ...\n"); 724 725 /* Retreive CPU related informations from the flat tree 726 * (altivec support, boot CPU ID, ...) 727 */ 728 of_scan_flat_dt(early_init_dt_scan_cpus, NULL); 729 730 DBG(" <- early_init_devtree()\n"); 731} 732 733/******* 734 * 735 * New implementation of the OF "find" APIs, return a refcounted 736 * object, call of_node_put() when done. The device tree and list 737 * are protected by a rw_lock. 738 * 739 * Note that property management will need some locking as well, 740 * this isn't dealt with yet. 741 * 742 *******/ 743 744/** 745 * of_find_next_cache_node - Find a node's subsidiary cache 746 * @np: node of type "cpu" or "cache" 747 * 748 * Returns a node pointer with refcount incremented, use 749 * of_node_put() on it when done. Caller should hold a reference 750 * to np. 751 */ 752struct device_node *of_find_next_cache_node(struct device_node *np) 753{ 754 struct device_node *child; 755 const phandle *handle; 756 757 handle = of_get_property(np, "l2-cache", NULL); 758 if (!handle) 759 handle = of_get_property(np, "next-level-cache", NULL); 760 761 if (handle) 762 return of_find_node_by_phandle(*handle); 763 764 /* OF on pmac has nodes instead of properties named "l2-cache" 765 * beneath CPU nodes. 766 */ 767 if (!strcmp(np->type, "cpu")) 768 for_each_child_of_node(np, child) 769 if (!strcmp(child->type, "cache")) 770 return child; 771 772 return NULL; 773} 774 775#ifdef CONFIG_PPC_PSERIES 776/* 777 * Fix up the uninitialized fields in a new device node: 778 * name, type and pci-specific fields 779 */ 780 781static int of_finish_dynamic_node(struct device_node *node) 782{ 783 struct device_node *parent = of_get_parent(node); 784 int err = 0; 785 const phandle *ibm_phandle; 786 787 node->name = of_get_property(node, "name", NULL); 788 node->type = of_get_property(node, "device_type", NULL); 789 790 if (!node->name) 791 node->name = "<NULL>"; 792 if (!node->type) 793 node->type = "<NULL>"; 794 795 if (!parent) { 796 err = -ENODEV; 797 goto out; 798 } 799 800 /* We don't support that function on PowerMac, at least 801 * not yet 802 */ 803 if (machine_is(powermac)) 804 return -ENODEV; 805 806 /* fix up new node's phandle field */ 807 if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL))) 808 node->phandle = *ibm_phandle; 809 810out: 811 of_node_put(parent); 812 return err; 813} 814 815static int prom_reconfig_notifier(struct notifier_block *nb, 816 unsigned long action, void *node) 817{ 818 int err; 819 820 switch (action) { 821 case PSERIES_RECONFIG_ADD: 822 err = of_finish_dynamic_node(node); 823 if (err < 0) { 824 printk(KERN_ERR "finish_node returned %d\n", err); 825 err = NOTIFY_BAD; 826 } 827 break; 828 default: 829 err = NOTIFY_DONE; 830 break; 831 } 832 return err; 833} 834 835static struct notifier_block prom_reconfig_nb = { 836 .notifier_call = prom_reconfig_notifier, 837 .priority = 10, /* This one needs to run first */ 838}; 839 840static int __init prom_reconfig_setup(void) 841{ 842 return pSeries_reconfig_notifier_register(&prom_reconfig_nb); 843} 844__initcall(prom_reconfig_setup); 845#endif 846 847/* Find the device node for a given logical cpu number, also returns the cpu 848 * local thread number (index in ibm,interrupt-server#s) if relevant and 849 * asked for (non NULL) 850 */ 851struct device_node *of_get_cpu_node(int cpu, unsigned int *thread) 852{ 853 int hardid; 854 struct device_node *np; 855 856 hardid = get_hard_smp_processor_id(cpu); 857 858 for_each_node_by_type(np, "cpu") { 859 const u32 *intserv; 860 unsigned int plen, t; 861 862 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist 863 * fallback to "reg" property and assume no threads 864 */ 865 intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", 866 &plen); 867 if (intserv == NULL) { 868 const u32 *reg = of_get_property(np, "reg", NULL); 869 if (reg == NULL) 870 continue; 871 if (*reg == hardid) { 872 if (thread) 873 *thread = 0; 874 return np; 875 } 876 } else { 877 plen /= sizeof(u32); 878 for (t = 0; t < plen; t++) { 879 if (hardid == intserv[t]) { 880 if (thread) 881 *thread = t; 882 return np; 883 } 884 } 885 } 886 } 887 return NULL; 888} 889EXPORT_SYMBOL(of_get_cpu_node); 890 891#if defined(CONFIG_DEBUG_FS) && defined(DEBUG) 892static struct debugfs_blob_wrapper flat_dt_blob; 893 894static int __init export_flat_device_tree(void) 895{ 896 struct dentry *d; 897 898 flat_dt_blob.data = initial_boot_params; 899 flat_dt_blob.size = initial_boot_params->totalsize; 900 901 d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR, 902 powerpc_debugfs_root, &flat_dt_blob); 903 if (!d) 904 return 1; 905 906 return 0; 907} 908__initcall(export_flat_device_tree); 909#endif 910