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