1/* 2 * Procedures for interfacing to Open Firmware. 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_PROM 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/proc_fs.h> 27#include <linux/stringify.h> 28#include <linux/delay.h> 29#include <linux/initrd.h> 30#include <linux/bitops.h> 31#include <asm/prom.h> 32#include <asm/rtas.h> 33#include <asm/page.h> 34#include <asm/processor.h> 35#include <asm/irq.h> 36#include <asm/io.h> 37#include <asm/smp.h> 38#include <asm/mmu.h> 39#include <asm/pgtable.h> 40#include <asm/pci.h> 41#include <asm/iommu.h> 42#include <asm/btext.h> 43#include <asm/sections.h> 44#include <asm/machdep.h> 45#include <asm/opal.h> 46 47#include <linux/linux_logo.h> 48 49/* 50 * Eventually bump that one up 51 */ 52#define DEVTREE_CHUNK_SIZE 0x100000 53 54/* 55 * This is the size of the local memory reserve map that gets copied 56 * into the boot params passed to the kernel. That size is totally 57 * flexible as the kernel just reads the list until it encounters an 58 * entry with size 0, so it can be changed without breaking binary 59 * compatibility 60 */ 61#define MEM_RESERVE_MAP_SIZE 8 62 63/* 64 * prom_init() is called very early on, before the kernel text 65 * and data have been mapped to KERNELBASE. At this point the code 66 * is running at whatever address it has been loaded at. 67 * On ppc32 we compile with -mrelocatable, which means that references 68 * to extern and static variables get relocated automatically. 69 * ppc64 objects are always relocatable, we just need to relocate the 70 * TOC. 71 * 72 * Because OF may have mapped I/O devices into the area starting at 73 * KERNELBASE, particularly on CHRP machines, we can't safely call 74 * OF once the kernel has been mapped to KERNELBASE. Therefore all 75 * OF calls must be done within prom_init(). 76 * 77 * ADDR is used in calls to call_prom. The 4th and following 78 * arguments to call_prom should be 32-bit values. 79 * On ppc64, 64 bit values are truncated to 32 bits (and 80 * fortunately don't get interpreted as two arguments). 81 */ 82#define ADDR(x) (u32)(unsigned long)(x) 83 84#ifdef CONFIG_PPC64 85#define OF_WORKAROUNDS 0 86#else 87#define OF_WORKAROUNDS of_workarounds 88int of_workarounds; 89#endif 90 91#define OF_WA_CLAIM 1 /* do phys/virt claim separately, then map */ 92#define OF_WA_LONGTRAIL 2 /* work around longtrail bugs */ 93 94#define PROM_BUG() do { \ 95 prom_printf("kernel BUG at %s line 0x%x!\n", \ 96 __FILE__, __LINE__); \ 97 __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR); \ 98} while (0) 99 100#ifdef DEBUG_PROM 101#define prom_debug(x...) prom_printf(x) 102#else 103#define prom_debug(x...) 104#endif 105 106 107typedef u32 prom_arg_t; 108 109struct prom_args { 110 __be32 service; 111 __be32 nargs; 112 __be32 nret; 113 __be32 args[10]; 114}; 115 116struct prom_t { 117 ihandle root; 118 phandle chosen; 119 int cpu; 120 ihandle stdout; 121 ihandle mmumap; 122 ihandle memory; 123}; 124 125struct mem_map_entry { 126 __be64 base; 127 __be64 size; 128}; 129 130typedef __be32 cell_t; 131 132extern void __start(unsigned long r3, unsigned long r4, unsigned long r5, 133 unsigned long r6, unsigned long r7, unsigned long r8, 134 unsigned long r9); 135 136#ifdef CONFIG_PPC64 137extern int enter_prom(struct prom_args *args, unsigned long entry); 138#else 139static inline int enter_prom(struct prom_args *args, unsigned long entry) 140{ 141 return ((int (*)(struct prom_args *))entry)(args); 142} 143#endif 144 145extern void copy_and_flush(unsigned long dest, unsigned long src, 146 unsigned long size, unsigned long offset); 147 148/* prom structure */ 149static struct prom_t __initdata prom; 150 151static unsigned long prom_entry __initdata; 152 153#define PROM_SCRATCH_SIZE 256 154 155static char __initdata of_stdout_device[256]; 156static char __initdata prom_scratch[PROM_SCRATCH_SIZE]; 157 158static unsigned long __initdata dt_header_start; 159static unsigned long __initdata dt_struct_start, dt_struct_end; 160static unsigned long __initdata dt_string_start, dt_string_end; 161 162static unsigned long __initdata prom_initrd_start, prom_initrd_end; 163 164#ifdef CONFIG_PPC64 165static int __initdata prom_iommu_force_on; 166static int __initdata prom_iommu_off; 167static unsigned long __initdata prom_tce_alloc_start; 168static unsigned long __initdata prom_tce_alloc_end; 169#endif 170 171/* Platforms codes are now obsolete in the kernel. Now only used within this 172 * file and ultimately gone too. Feel free to change them if you need, they 173 * are not shared with anything outside of this file anymore 174 */ 175#define PLATFORM_PSERIES 0x0100 176#define PLATFORM_PSERIES_LPAR 0x0101 177#define PLATFORM_LPAR 0x0001 178#define PLATFORM_POWERMAC 0x0400 179#define PLATFORM_GENERIC 0x0500 180#define PLATFORM_OPAL 0x0600 181 182static int __initdata of_platform; 183 184static char __initdata prom_cmd_line[COMMAND_LINE_SIZE]; 185 186static unsigned long __initdata prom_memory_limit; 187 188static unsigned long __initdata alloc_top; 189static unsigned long __initdata alloc_top_high; 190static unsigned long __initdata alloc_bottom; 191static unsigned long __initdata rmo_top; 192static unsigned long __initdata ram_top; 193 194static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE]; 195static int __initdata mem_reserve_cnt; 196 197static cell_t __initdata regbuf[1024]; 198 199static bool rtas_has_query_cpu_stopped; 200 201 202/* 203 * Error results ... some OF calls will return "-1" on error, some 204 * will return 0, some will return either. To simplify, here are 205 * macros to use with any ihandle or phandle return value to check if 206 * it is valid 207 */ 208 209#define PROM_ERROR (-1u) 210#define PHANDLE_VALID(p) ((p) != 0 && (p) != PROM_ERROR) 211#define IHANDLE_VALID(i) ((i) != 0 && (i) != PROM_ERROR) 212 213 214/* This is the one and *ONLY* place where we actually call open 215 * firmware. 216 */ 217 218static int __init call_prom(const char *service, int nargs, int nret, ...) 219{ 220 int i; 221 struct prom_args args; 222 va_list list; 223 224 args.service = cpu_to_be32(ADDR(service)); 225 args.nargs = cpu_to_be32(nargs); 226 args.nret = cpu_to_be32(nret); 227 228 va_start(list, nret); 229 for (i = 0; i < nargs; i++) 230 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t)); 231 va_end(list); 232 233 for (i = 0; i < nret; i++) 234 args.args[nargs+i] = 0; 235 236 if (enter_prom(&args, prom_entry) < 0) 237 return PROM_ERROR; 238 239 return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0; 240} 241 242static int __init call_prom_ret(const char *service, int nargs, int nret, 243 prom_arg_t *rets, ...) 244{ 245 int i; 246 struct prom_args args; 247 va_list list; 248 249 args.service = cpu_to_be32(ADDR(service)); 250 args.nargs = cpu_to_be32(nargs); 251 args.nret = cpu_to_be32(nret); 252 253 va_start(list, rets); 254 for (i = 0; i < nargs; i++) 255 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t)); 256 va_end(list); 257 258 for (i = 0; i < nret; i++) 259 args.args[nargs+i] = 0; 260 261 if (enter_prom(&args, prom_entry) < 0) 262 return PROM_ERROR; 263 264 if (rets != NULL) 265 for (i = 1; i < nret; ++i) 266 rets[i-1] = be32_to_cpu(args.args[nargs+i]); 267 268 return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0; 269} 270 271 272static void __init prom_print(const char *msg) 273{ 274 const char *p, *q; 275 276 if (prom.stdout == 0) 277 return; 278 279 for (p = msg; *p != 0; p = q) { 280 for (q = p; *q != 0 && *q != '\n'; ++q) 281 ; 282 if (q > p) 283 call_prom("write", 3, 1, prom.stdout, p, q - p); 284 if (*q == 0) 285 break; 286 ++q; 287 call_prom("write", 3, 1, prom.stdout, ADDR("\r\n"), 2); 288 } 289} 290 291 292static void __init prom_print_hex(unsigned long val) 293{ 294 int i, nibbles = sizeof(val)*2; 295 char buf[sizeof(val)*2+1]; 296 297 for (i = nibbles-1; i >= 0; i--) { 298 buf[i] = (val & 0xf) + '0'; 299 if (buf[i] > '9') 300 buf[i] += ('a'-'0'-10); 301 val >>= 4; 302 } 303 buf[nibbles] = '\0'; 304 call_prom("write", 3, 1, prom.stdout, buf, nibbles); 305} 306 307/* max number of decimal digits in an unsigned long */ 308#define UL_DIGITS 21 309static void __init prom_print_dec(unsigned long val) 310{ 311 int i, size; 312 char buf[UL_DIGITS+1]; 313 314 for (i = UL_DIGITS-1; i >= 0; i--) { 315 buf[i] = (val % 10) + '0'; 316 val = val/10; 317 if (val == 0) 318 break; 319 } 320 /* shift stuff down */ 321 size = UL_DIGITS - i; 322 call_prom("write", 3, 1, prom.stdout, buf+i, size); 323} 324 325static void __init prom_printf(const char *format, ...) 326{ 327 const char *p, *q, *s; 328 va_list args; 329 unsigned long v; 330 long vs; 331 332 va_start(args, format); 333 for (p = format; *p != 0; p = q) { 334 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q) 335 ; 336 if (q > p) 337 call_prom("write", 3, 1, prom.stdout, p, q - p); 338 if (*q == 0) 339 break; 340 if (*q == '\n') { 341 ++q; 342 call_prom("write", 3, 1, prom.stdout, 343 ADDR("\r\n"), 2); 344 continue; 345 } 346 ++q; 347 if (*q == 0) 348 break; 349 switch (*q) { 350 case 's': 351 ++q; 352 s = va_arg(args, const char *); 353 prom_print(s); 354 break; 355 case 'x': 356 ++q; 357 v = va_arg(args, unsigned long); 358 prom_print_hex(v); 359 break; 360 case 'd': 361 ++q; 362 vs = va_arg(args, int); 363 if (vs < 0) { 364 prom_print("-"); 365 vs = -vs; 366 } 367 prom_print_dec(vs); 368 break; 369 case 'l': 370 ++q; 371 if (*q == 0) 372 break; 373 else if (*q == 'x') { 374 ++q; 375 v = va_arg(args, unsigned long); 376 prom_print_hex(v); 377 } else if (*q == 'u') { /* '%lu' */ 378 ++q; 379 v = va_arg(args, unsigned long); 380 prom_print_dec(v); 381 } else if (*q == 'd') { /* %ld */ 382 ++q; 383 vs = va_arg(args, long); 384 if (vs < 0) { 385 prom_print("-"); 386 vs = -vs; 387 } 388 prom_print_dec(vs); 389 } 390 break; 391 } 392 } 393} 394 395 396static unsigned int __init prom_claim(unsigned long virt, unsigned long size, 397 unsigned long align) 398{ 399 400 if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) { 401 /* 402 * Old OF requires we claim physical and virtual separately 403 * and then map explicitly (assuming virtual mode) 404 */ 405 int ret; 406 prom_arg_t result; 407 408 ret = call_prom_ret("call-method", 5, 2, &result, 409 ADDR("claim"), prom.memory, 410 align, size, virt); 411 if (ret != 0 || result == -1) 412 return -1; 413 ret = call_prom_ret("call-method", 5, 2, &result, 414 ADDR("claim"), prom.mmumap, 415 align, size, virt); 416 if (ret != 0) { 417 call_prom("call-method", 4, 1, ADDR("release"), 418 prom.memory, size, virt); 419 return -1; 420 } 421 /* the 0x12 is M (coherence) + PP == read/write */ 422 call_prom("call-method", 6, 1, 423 ADDR("map"), prom.mmumap, 0x12, size, virt, virt); 424 return virt; 425 } 426 return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size, 427 (prom_arg_t)align); 428} 429 430static void __init __attribute__((noreturn)) prom_panic(const char *reason) 431{ 432 prom_print(reason); 433 /* Do not call exit because it clears the screen on pmac 434 * it also causes some sort of double-fault on early pmacs */ 435 if (of_platform == PLATFORM_POWERMAC) 436 asm("trap\n"); 437 438 /* ToDo: should put up an SRC here on pSeries */ 439 call_prom("exit", 0, 0); 440 441 for (;;) /* should never get here */ 442 ; 443} 444 445 446static int __init prom_next_node(phandle *nodep) 447{ 448 phandle node; 449 450 if ((node = *nodep) != 0 451 && (*nodep = call_prom("child", 1, 1, node)) != 0) 452 return 1; 453 if ((*nodep = call_prom("peer", 1, 1, node)) != 0) 454 return 1; 455 for (;;) { 456 if ((node = call_prom("parent", 1, 1, node)) == 0) 457 return 0; 458 if ((*nodep = call_prom("peer", 1, 1, node)) != 0) 459 return 1; 460 } 461} 462 463static int inline prom_getprop(phandle node, const char *pname, 464 void *value, size_t valuelen) 465{ 466 return call_prom("getprop", 4, 1, node, ADDR(pname), 467 (u32)(unsigned long) value, (u32) valuelen); 468} 469 470static int inline prom_getproplen(phandle node, const char *pname) 471{ 472 return call_prom("getproplen", 2, 1, node, ADDR(pname)); 473} 474 475static void add_string(char **str, const char *q) 476{ 477 char *p = *str; 478 479 while (*q) 480 *p++ = *q++; 481 *p++ = ' '; 482 *str = p; 483} 484 485static char *tohex(unsigned int x) 486{ 487 static char digits[] = "0123456789abcdef"; 488 static char result[9]; 489 int i; 490 491 result[8] = 0; 492 i = 8; 493 do { 494 --i; 495 result[i] = digits[x & 0xf]; 496 x >>= 4; 497 } while (x != 0 && i > 0); 498 return &result[i]; 499} 500 501static int __init prom_setprop(phandle node, const char *nodename, 502 const char *pname, void *value, size_t valuelen) 503{ 504 char cmd[256], *p; 505 506 if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL)) 507 return call_prom("setprop", 4, 1, node, ADDR(pname), 508 (u32)(unsigned long) value, (u32) valuelen); 509 510 /* gah... setprop doesn't work on longtrail, have to use interpret */ 511 p = cmd; 512 add_string(&p, "dev"); 513 add_string(&p, nodename); 514 add_string(&p, tohex((u32)(unsigned long) value)); 515 add_string(&p, tohex(valuelen)); 516 add_string(&p, tohex(ADDR(pname))); 517 add_string(&p, tohex(strlen(pname))); 518 add_string(&p, "property"); 519 *p = 0; 520 return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd); 521} 522 523/* We can't use the standard versions because of relocation headaches. */ 524#define isxdigit(c) (('0' <= (c) && (c) <= '9') \ 525 || ('a' <= (c) && (c) <= 'f') \ 526 || ('A' <= (c) && (c) <= 'F')) 527 528#define isdigit(c) ('0' <= (c) && (c) <= '9') 529#define islower(c) ('a' <= (c) && (c) <= 'z') 530#define toupper(c) (islower(c) ? ((c) - 'a' + 'A') : (c)) 531 532static unsigned long prom_strtoul(const char *cp, const char **endp) 533{ 534 unsigned long result = 0, base = 10, value; 535 536 if (*cp == '0') { 537 base = 8; 538 cp++; 539 if (toupper(*cp) == 'X') { 540 cp++; 541 base = 16; 542 } 543 } 544 545 while (isxdigit(*cp) && 546 (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) { 547 result = result * base + value; 548 cp++; 549 } 550 551 if (endp) 552 *endp = cp; 553 554 return result; 555} 556 557static unsigned long prom_memparse(const char *ptr, const char **retptr) 558{ 559 unsigned long ret = prom_strtoul(ptr, retptr); 560 int shift = 0; 561 562 /* 563 * We can't use a switch here because GCC *may* generate a 564 * jump table which won't work, because we're not running at 565 * the address we're linked at. 566 */ 567 if ('G' == **retptr || 'g' == **retptr) 568 shift = 30; 569 570 if ('M' == **retptr || 'm' == **retptr) 571 shift = 20; 572 573 if ('K' == **retptr || 'k' == **retptr) 574 shift = 10; 575 576 if (shift) { 577 ret <<= shift; 578 (*retptr)++; 579 } 580 581 return ret; 582} 583 584/* 585 * Early parsing of the command line passed to the kernel, used for 586 * "mem=x" and the options that affect the iommu 587 */ 588static void __init early_cmdline_parse(void) 589{ 590 const char *opt; 591 592 char *p; 593 int l = 0; 594 595 prom_cmd_line[0] = 0; 596 p = prom_cmd_line; 597 if ((long)prom.chosen > 0) 598 l = prom_getprop(prom.chosen, "bootargs", p, COMMAND_LINE_SIZE-1); 599#ifdef CONFIG_CMDLINE 600 if (l <= 0 || p[0] == '\0') /* dbl check */ 601 strlcpy(prom_cmd_line, 602 CONFIG_CMDLINE, sizeof(prom_cmd_line)); 603#endif /* CONFIG_CMDLINE */ 604 prom_printf("command line: %s\n", prom_cmd_line); 605 606#ifdef CONFIG_PPC64 607 opt = strstr(prom_cmd_line, "iommu="); 608 if (opt) { 609 prom_printf("iommu opt is: %s\n", opt); 610 opt += 6; 611 while (*opt && *opt == ' ') 612 opt++; 613 if (!strncmp(opt, "off", 3)) 614 prom_iommu_off = 1; 615 else if (!strncmp(opt, "force", 5)) 616 prom_iommu_force_on = 1; 617 } 618#endif 619 opt = strstr(prom_cmd_line, "mem="); 620 if (opt) { 621 opt += 4; 622 prom_memory_limit = prom_memparse(opt, (const char **)&opt); 623#ifdef CONFIG_PPC64 624 /* Align to 16 MB == size of ppc64 large page */ 625 prom_memory_limit = ALIGN(prom_memory_limit, 0x1000000); 626#endif 627 } 628} 629 630#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) 631/* 632 * The architecture vector has an array of PVR mask/value pairs, 633 * followed by # option vectors - 1, followed by the option vectors. 634 * 635 * See prom.h for the definition of the bits specified in the 636 * architecture vector. 637 * 638 * Because the description vector contains a mix of byte and word 639 * values, we declare it as an unsigned char array, and use this 640 * macro to put word values in. 641 */ 642#define W(x) ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \ 643 ((x) >> 8) & 0xff, (x) & 0xff 644 645unsigned char ibm_architecture_vec[] = { 646 W(0xfffe0000), W(0x003a0000), /* POWER5/POWER5+ */ 647 W(0xffff0000), W(0x003e0000), /* POWER6 */ 648 W(0xffff0000), W(0x003f0000), /* POWER7 */ 649 W(0xffff0000), W(0x004b0000), /* POWER8E */ 650 W(0xffff0000), W(0x004c0000), /* POWER8NVL */ 651 W(0xffff0000), W(0x004d0000), /* POWER8 */ 652 W(0xffffffff), W(0x0f000004), /* all 2.07-compliant */ 653 W(0xffffffff), W(0x0f000003), /* all 2.06-compliant */ 654 W(0xffffffff), W(0x0f000002), /* all 2.05-compliant */ 655 W(0xfffffffe), W(0x0f000001), /* all 2.04-compliant and earlier */ 656 6 - 1, /* 6 option vectors */ 657 658 /* option vector 1: processor architectures supported */ 659 3 - 2, /* length */ 660 0, /* don't ignore, don't halt */ 661 OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 | 662 OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06 | OV1_PPC_2_07, 663 664 /* option vector 2: Open Firmware options supported */ 665 34 - 2, /* length */ 666 OV2_REAL_MODE, 667 0, 0, 668 W(0xffffffff), /* real_base */ 669 W(0xffffffff), /* real_size */ 670 W(0xffffffff), /* virt_base */ 671 W(0xffffffff), /* virt_size */ 672 W(0xffffffff), /* load_base */ 673 W(256), /* 256MB min RMA */ 674 W(0xffffffff), /* full client load */ 675 0, /* min RMA percentage of total RAM */ 676 48, /* max log_2(hash table size) */ 677 678 /* option vector 3: processor options supported */ 679 3 - 2, /* length */ 680 0, /* don't ignore, don't halt */ 681 OV3_FP | OV3_VMX | OV3_DFP, 682 683 /* option vector 4: IBM PAPR implementation */ 684 3 - 2, /* length */ 685 0, /* don't halt */ 686 OV4_MIN_ENT_CAP, /* minimum VP entitled capacity */ 687 688 /* option vector 5: PAPR/OF options */ 689 19 - 2, /* length */ 690 0, /* don't ignore, don't halt */ 691 OV5_FEAT(OV5_LPAR) | OV5_FEAT(OV5_SPLPAR) | OV5_FEAT(OV5_LARGE_PAGES) | 692 OV5_FEAT(OV5_DRCONF_MEMORY) | OV5_FEAT(OV5_DONATE_DEDICATE_CPU) | 693#ifdef CONFIG_PCI_MSI 694 /* PCIe/MSI support. Without MSI full PCIe is not supported */ 695 OV5_FEAT(OV5_MSI), 696#else 697 0, 698#endif 699 0, 700#ifdef CONFIG_PPC_SMLPAR 701 OV5_FEAT(OV5_CMO) | OV5_FEAT(OV5_XCMO), 702#else 703 0, 704#endif 705 OV5_FEAT(OV5_TYPE1_AFFINITY) | OV5_FEAT(OV5_PRRN), 706 0, 707 0, 708 0, 709 /* WARNING: The offset of the "number of cores" field below 710 * must match by the macro below. Update the definition if 711 * the structure layout changes. 712 */ 713#define IBM_ARCH_VEC_NRCORES_OFFSET 133 714 W(NR_CPUS), /* number of cores supported */ 715 0, 716 0, 717 0, 718 0, 719 OV5_FEAT(OV5_PFO_HW_RNG) | OV5_FEAT(OV5_PFO_HW_ENCR) | 720 OV5_FEAT(OV5_PFO_HW_842), 721 OV5_FEAT(OV5_SUB_PROCESSORS), 722 /* option vector 6: IBM PAPR hints */ 723 4 - 2, /* length */ 724 0, 725 0, 726 OV6_LINUX, 727 728}; 729 730/* Old method - ELF header with PT_NOTE sections only works on BE */ 731#ifdef __BIG_ENDIAN__ 732static struct fake_elf { 733 Elf32_Ehdr elfhdr; 734 Elf32_Phdr phdr[2]; 735 struct chrpnote { 736 u32 namesz; 737 u32 descsz; 738 u32 type; 739 char name[8]; /* "PowerPC" */ 740 struct chrpdesc { 741 u32 real_mode; 742 u32 real_base; 743 u32 real_size; 744 u32 virt_base; 745 u32 virt_size; 746 u32 load_base; 747 } chrpdesc; 748 } chrpnote; 749 struct rpanote { 750 u32 namesz; 751 u32 descsz; 752 u32 type; 753 char name[24]; /* "IBM,RPA-Client-Config" */ 754 struct rpadesc { 755 u32 lpar_affinity; 756 u32 min_rmo_size; 757 u32 min_rmo_percent; 758 u32 max_pft_size; 759 u32 splpar; 760 u32 min_load; 761 u32 new_mem_def; 762 u32 ignore_me; 763 } rpadesc; 764 } rpanote; 765} fake_elf = { 766 .elfhdr = { 767 .e_ident = { 0x7f, 'E', 'L', 'F', 768 ELFCLASS32, ELFDATA2MSB, EV_CURRENT }, 769 .e_type = ET_EXEC, /* yeah right */ 770 .e_machine = EM_PPC, 771 .e_version = EV_CURRENT, 772 .e_phoff = offsetof(struct fake_elf, phdr), 773 .e_phentsize = sizeof(Elf32_Phdr), 774 .e_phnum = 2 775 }, 776 .phdr = { 777 [0] = { 778 .p_type = PT_NOTE, 779 .p_offset = offsetof(struct fake_elf, chrpnote), 780 .p_filesz = sizeof(struct chrpnote) 781 }, [1] = { 782 .p_type = PT_NOTE, 783 .p_offset = offsetof(struct fake_elf, rpanote), 784 .p_filesz = sizeof(struct rpanote) 785 } 786 }, 787 .chrpnote = { 788 .namesz = sizeof("PowerPC"), 789 .descsz = sizeof(struct chrpdesc), 790 .type = 0x1275, 791 .name = "PowerPC", 792 .chrpdesc = { 793 .real_mode = ~0U, /* ~0 means "don't care" */ 794 .real_base = ~0U, 795 .real_size = ~0U, 796 .virt_base = ~0U, 797 .virt_size = ~0U, 798 .load_base = ~0U 799 }, 800 }, 801 .rpanote = { 802 .namesz = sizeof("IBM,RPA-Client-Config"), 803 .descsz = sizeof(struct rpadesc), 804 .type = 0x12759999, 805 .name = "IBM,RPA-Client-Config", 806 .rpadesc = { 807 .lpar_affinity = 0, 808 .min_rmo_size = 64, /* in megabytes */ 809 .min_rmo_percent = 0, 810 .max_pft_size = 48, /* 2^48 bytes max PFT size */ 811 .splpar = 1, 812 .min_load = ~0U, 813 .new_mem_def = 0 814 } 815 } 816}; 817#endif /* __BIG_ENDIAN__ */ 818 819static int __init prom_count_smt_threads(void) 820{ 821 phandle node; 822 char type[64]; 823 unsigned int plen; 824 825 /* Pick up th first CPU node we can find */ 826 for (node = 0; prom_next_node(&node); ) { 827 type[0] = 0; 828 prom_getprop(node, "device_type", type, sizeof(type)); 829 830 if (strcmp(type, "cpu")) 831 continue; 832 /* 833 * There is an entry for each smt thread, each entry being 834 * 4 bytes long. All cpus should have the same number of 835 * smt threads, so return after finding the first. 836 */ 837 plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s"); 838 if (plen == PROM_ERROR) 839 break; 840 plen >>= 2; 841 prom_debug("Found %lu smt threads per core\n", (unsigned long)plen); 842 843 /* Sanity check */ 844 if (plen < 1 || plen > 64) { 845 prom_printf("Threads per core %lu out of bounds, assuming 1\n", 846 (unsigned long)plen); 847 return 1; 848 } 849 return plen; 850 } 851 prom_debug("No threads found, assuming 1 per core\n"); 852 853 return 1; 854 855} 856 857 858static void __init prom_send_capabilities(void) 859{ 860 ihandle root; 861 prom_arg_t ret; 862 u32 cores; 863 unsigned char *ptcores; 864 865 root = call_prom("open", 1, 1, ADDR("/")); 866 if (root != 0) { 867 /* We need to tell the FW about the number of cores we support. 868 * 869 * To do that, we count the number of threads on the first core 870 * (we assume this is the same for all cores) and use it to 871 * divide NR_CPUS. 872 */ 873 874 /* The core value may start at an odd address. If such a word 875 * access is made at a cache line boundary, this leads to an 876 * exception which may not be handled at this time. 877 * Forcing a per byte access to avoid exception. 878 */ 879 ptcores = &ibm_architecture_vec[IBM_ARCH_VEC_NRCORES_OFFSET]; 880 cores = 0; 881 cores |= ptcores[0] << 24; 882 cores |= ptcores[1] << 16; 883 cores |= ptcores[2] << 8; 884 cores |= ptcores[3]; 885 if (cores != NR_CPUS) { 886 prom_printf("WARNING ! " 887 "ibm_architecture_vec structure inconsistent: %lu!\n", 888 cores); 889 } else { 890 cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads()); 891 prom_printf("Max number of cores passed to firmware: %lu (NR_CPUS = %lu)\n", 892 cores, NR_CPUS); 893 ptcores[0] = (cores >> 24) & 0xff; 894 ptcores[1] = (cores >> 16) & 0xff; 895 ptcores[2] = (cores >> 8) & 0xff; 896 ptcores[3] = cores & 0xff; 897 } 898 899 /* try calling the ibm,client-architecture-support method */ 900 prom_printf("Calling ibm,client-architecture-support..."); 901 if (call_prom_ret("call-method", 3, 2, &ret, 902 ADDR("ibm,client-architecture-support"), 903 root, 904 ADDR(ibm_architecture_vec)) == 0) { 905 /* the call exists... */ 906 if (ret) 907 prom_printf("\nWARNING: ibm,client-architecture" 908 "-support call FAILED!\n"); 909 call_prom("close", 1, 0, root); 910 prom_printf(" done\n"); 911 return; 912 } 913 call_prom("close", 1, 0, root); 914 prom_printf(" not implemented\n"); 915 } 916 917#ifdef __BIG_ENDIAN__ 918 { 919 ihandle elfloader; 920 921 /* no ibm,client-architecture-support call, try the old way */ 922 elfloader = call_prom("open", 1, 1, 923 ADDR("/packages/elf-loader")); 924 if (elfloader == 0) { 925 prom_printf("couldn't open /packages/elf-loader\n"); 926 return; 927 } 928 call_prom("call-method", 3, 1, ADDR("process-elf-header"), 929 elfloader, ADDR(&fake_elf)); 930 call_prom("close", 1, 0, elfloader); 931 } 932#endif /* __BIG_ENDIAN__ */ 933} 934#endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */ 935 936/* 937 * Memory allocation strategy... our layout is normally: 938 * 939 * at 14Mb or more we have vmlinux, then a gap and initrd. In some 940 * rare cases, initrd might end up being before the kernel though. 941 * We assume this won't override the final kernel at 0, we have no 942 * provision to handle that in this version, but it should hopefully 943 * never happen. 944 * 945 * alloc_top is set to the top of RMO, eventually shrink down if the 946 * TCEs overlap 947 * 948 * alloc_bottom is set to the top of kernel/initrd 949 * 950 * from there, allocations are done this way : rtas is allocated 951 * topmost, and the device-tree is allocated from the bottom. We try 952 * to grow the device-tree allocation as we progress. If we can't, 953 * then we fail, we don't currently have a facility to restart 954 * elsewhere, but that shouldn't be necessary. 955 * 956 * Note that calls to reserve_mem have to be done explicitly, memory 957 * allocated with either alloc_up or alloc_down isn't automatically 958 * reserved. 959 */ 960 961 962/* 963 * Allocates memory in the RMO upward from the kernel/initrd 964 * 965 * When align is 0, this is a special case, it means to allocate in place 966 * at the current location of alloc_bottom or fail (that is basically 967 * extending the previous allocation). Used for the device-tree flattening 968 */ 969static unsigned long __init alloc_up(unsigned long size, unsigned long align) 970{ 971 unsigned long base = alloc_bottom; 972 unsigned long addr = 0; 973 974 if (align) 975 base = _ALIGN_UP(base, align); 976 prom_debug("alloc_up(%x, %x)\n", size, align); 977 if (ram_top == 0) 978 prom_panic("alloc_up() called with mem not initialized\n"); 979 980 if (align) 981 base = _ALIGN_UP(alloc_bottom, align); 982 else 983 base = alloc_bottom; 984 985 for(; (base + size) <= alloc_top; 986 base = _ALIGN_UP(base + 0x100000, align)) { 987 prom_debug(" trying: 0x%x\n\r", base); 988 addr = (unsigned long)prom_claim(base, size, 0); 989 if (addr != PROM_ERROR && addr != 0) 990 break; 991 addr = 0; 992 if (align == 0) 993 break; 994 } 995 if (addr == 0) 996 return 0; 997 alloc_bottom = addr + size; 998 999 prom_debug(" -> %x\n", addr); 1000 prom_debug(" alloc_bottom : %x\n", alloc_bottom); 1001 prom_debug(" alloc_top : %x\n", alloc_top); 1002 prom_debug(" alloc_top_hi : %x\n", alloc_top_high); 1003 prom_debug(" rmo_top : %x\n", rmo_top); 1004 prom_debug(" ram_top : %x\n", ram_top); 1005 1006 return addr; 1007} 1008 1009/* 1010 * Allocates memory downward, either from top of RMO, or if highmem 1011 * is set, from the top of RAM. Note that this one doesn't handle 1012 * failures. It does claim memory if highmem is not set. 1013 */ 1014static unsigned long __init alloc_down(unsigned long size, unsigned long align, 1015 int highmem) 1016{ 1017 unsigned long base, addr = 0; 1018 1019 prom_debug("alloc_down(%x, %x, %s)\n", size, align, 1020 highmem ? "(high)" : "(low)"); 1021 if (ram_top == 0) 1022 prom_panic("alloc_down() called with mem not initialized\n"); 1023 1024 if (highmem) { 1025 /* Carve out storage for the TCE table. */ 1026 addr = _ALIGN_DOWN(alloc_top_high - size, align); 1027 if (addr <= alloc_bottom) 1028 return 0; 1029 /* Will we bump into the RMO ? If yes, check out that we 1030 * didn't overlap existing allocations there, if we did, 1031 * we are dead, we must be the first in town ! 1032 */ 1033 if (addr < rmo_top) { 1034 /* Good, we are first */ 1035 if (alloc_top == rmo_top) 1036 alloc_top = rmo_top = addr; 1037 else 1038 return 0; 1039 } 1040 alloc_top_high = addr; 1041 goto bail; 1042 } 1043 1044 base = _ALIGN_DOWN(alloc_top - size, align); 1045 for (; base > alloc_bottom; 1046 base = _ALIGN_DOWN(base - 0x100000, align)) { 1047 prom_debug(" trying: 0x%x\n\r", base); 1048 addr = (unsigned long)prom_claim(base, size, 0); 1049 if (addr != PROM_ERROR && addr != 0) 1050 break; 1051 addr = 0; 1052 } 1053 if (addr == 0) 1054 return 0; 1055 alloc_top = addr; 1056 1057 bail: 1058 prom_debug(" -> %x\n", addr); 1059 prom_debug(" alloc_bottom : %x\n", alloc_bottom); 1060 prom_debug(" alloc_top : %x\n", alloc_top); 1061 prom_debug(" alloc_top_hi : %x\n", alloc_top_high); 1062 prom_debug(" rmo_top : %x\n", rmo_top); 1063 prom_debug(" ram_top : %x\n", ram_top); 1064 1065 return addr; 1066} 1067 1068/* 1069 * Parse a "reg" cell 1070 */ 1071static unsigned long __init prom_next_cell(int s, cell_t **cellp) 1072{ 1073 cell_t *p = *cellp; 1074 unsigned long r = 0; 1075 1076 /* Ignore more than 2 cells */ 1077 while (s > sizeof(unsigned long) / 4) { 1078 p++; 1079 s--; 1080 } 1081 r = be32_to_cpu(*p++); 1082#ifdef CONFIG_PPC64 1083 if (s > 1) { 1084 r <<= 32; 1085 r |= be32_to_cpu(*(p++)); 1086 } 1087#endif 1088 *cellp = p; 1089 return r; 1090} 1091 1092/* 1093 * Very dumb function for adding to the memory reserve list, but 1094 * we don't need anything smarter at this point 1095 * 1096 * XXX Eventually check for collisions. They should NEVER happen. 1097 * If problems seem to show up, it would be a good start to track 1098 * them down. 1099 */ 1100static void __init reserve_mem(u64 base, u64 size) 1101{ 1102 u64 top = base + size; 1103 unsigned long cnt = mem_reserve_cnt; 1104 1105 if (size == 0) 1106 return; 1107 1108 /* We need to always keep one empty entry so that we 1109 * have our terminator with "size" set to 0 since we are 1110 * dumb and just copy this entire array to the boot params 1111 */ 1112 base = _ALIGN_DOWN(base, PAGE_SIZE); 1113 top = _ALIGN_UP(top, PAGE_SIZE); 1114 size = top - base; 1115 1116 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1)) 1117 prom_panic("Memory reserve map exhausted !\n"); 1118 mem_reserve_map[cnt].base = cpu_to_be64(base); 1119 mem_reserve_map[cnt].size = cpu_to_be64(size); 1120 mem_reserve_cnt = cnt + 1; 1121} 1122 1123/* 1124 * Initialize memory allocation mechanism, parse "memory" nodes and 1125 * obtain that way the top of memory and RMO to setup out local allocator 1126 */ 1127static void __init prom_init_mem(void) 1128{ 1129 phandle node; 1130 char *path, type[64]; 1131 unsigned int plen; 1132 cell_t *p, *endp; 1133 __be32 val; 1134 u32 rac, rsc; 1135 1136 /* 1137 * We iterate the memory nodes to find 1138 * 1) top of RMO (first node) 1139 * 2) top of memory 1140 */ 1141 val = cpu_to_be32(2); 1142 prom_getprop(prom.root, "#address-cells", &val, sizeof(val)); 1143 rac = be32_to_cpu(val); 1144 val = cpu_to_be32(1); 1145 prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc)); 1146 rsc = be32_to_cpu(val); 1147 prom_debug("root_addr_cells: %x\n", rac); 1148 prom_debug("root_size_cells: %x\n", rsc); 1149 1150 prom_debug("scanning memory:\n"); 1151 path = prom_scratch; 1152 1153 for (node = 0; prom_next_node(&node); ) { 1154 type[0] = 0; 1155 prom_getprop(node, "device_type", type, sizeof(type)); 1156 1157 if (type[0] == 0) { 1158 /* 1159 * CHRP Longtrail machines have no device_type 1160 * on the memory node, so check the name instead... 1161 */ 1162 prom_getprop(node, "name", type, sizeof(type)); 1163 } 1164 if (strcmp(type, "memory")) 1165 continue; 1166 1167 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf)); 1168 if (plen > sizeof(regbuf)) { 1169 prom_printf("memory node too large for buffer !\n"); 1170 plen = sizeof(regbuf); 1171 } 1172 p = regbuf; 1173 endp = p + (plen / sizeof(cell_t)); 1174 1175#ifdef DEBUG_PROM 1176 memset(path, 0, PROM_SCRATCH_SIZE); 1177 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 1178 prom_debug(" node %s :\n", path); 1179#endif /* DEBUG_PROM */ 1180 1181 while ((endp - p) >= (rac + rsc)) { 1182 unsigned long base, size; 1183 1184 base = prom_next_cell(rac, &p); 1185 size = prom_next_cell(rsc, &p); 1186 1187 if (size == 0) 1188 continue; 1189 prom_debug(" %x %x\n", base, size); 1190 if (base == 0 && (of_platform & PLATFORM_LPAR)) 1191 rmo_top = size; 1192 if ((base + size) > ram_top) 1193 ram_top = base + size; 1194 } 1195 } 1196 1197 alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000); 1198 1199 /* 1200 * If prom_memory_limit is set we reduce the upper limits *except* for 1201 * alloc_top_high. This must be the real top of RAM so we can put 1202 * TCE's up there. 1203 */ 1204 1205 alloc_top_high = ram_top; 1206 1207 if (prom_memory_limit) { 1208 if (prom_memory_limit <= alloc_bottom) { 1209 prom_printf("Ignoring mem=%x <= alloc_bottom.\n", 1210 prom_memory_limit); 1211 prom_memory_limit = 0; 1212 } else if (prom_memory_limit >= ram_top) { 1213 prom_printf("Ignoring mem=%x >= ram_top.\n", 1214 prom_memory_limit); 1215 prom_memory_limit = 0; 1216 } else { 1217 ram_top = prom_memory_limit; 1218 rmo_top = min(rmo_top, prom_memory_limit); 1219 } 1220 } 1221 1222 /* 1223 * Setup our top alloc point, that is top of RMO or top of 1224 * segment 0 when running non-LPAR. 1225 * Some RS64 machines have buggy firmware where claims up at 1226 * 1GB fail. Cap at 768MB as a workaround. 1227 * Since 768MB is plenty of room, and we need to cap to something 1228 * reasonable on 32-bit, cap at 768MB on all machines. 1229 */ 1230 if (!rmo_top) 1231 rmo_top = ram_top; 1232 rmo_top = min(0x30000000ul, rmo_top); 1233 alloc_top = rmo_top; 1234 alloc_top_high = ram_top; 1235 1236 /* 1237 * Check if we have an initrd after the kernel but still inside 1238 * the RMO. If we do move our bottom point to after it. 1239 */ 1240 if (prom_initrd_start && 1241 prom_initrd_start < rmo_top && 1242 prom_initrd_end > alloc_bottom) 1243 alloc_bottom = PAGE_ALIGN(prom_initrd_end); 1244 1245 prom_printf("memory layout at init:\n"); 1246 prom_printf(" memory_limit : %x (16 MB aligned)\n", prom_memory_limit); 1247 prom_printf(" alloc_bottom : %x\n", alloc_bottom); 1248 prom_printf(" alloc_top : %x\n", alloc_top); 1249 prom_printf(" alloc_top_hi : %x\n", alloc_top_high); 1250 prom_printf(" rmo_top : %x\n", rmo_top); 1251 prom_printf(" ram_top : %x\n", ram_top); 1252} 1253 1254static void __init prom_close_stdin(void) 1255{ 1256 __be32 val; 1257 ihandle stdin; 1258 1259 if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) { 1260 stdin = be32_to_cpu(val); 1261 call_prom("close", 1, 0, stdin); 1262 } 1263} 1264 1265#ifdef CONFIG_PPC_POWERNV 1266 1267#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 1268static u64 __initdata prom_opal_base; 1269static u64 __initdata prom_opal_entry; 1270#endif 1271 1272/* 1273 * Allocate room for and instantiate OPAL 1274 */ 1275static void __init prom_instantiate_opal(void) 1276{ 1277 phandle opal_node; 1278 ihandle opal_inst; 1279 u64 base, entry; 1280 u64 size = 0, align = 0x10000; 1281 __be64 val64; 1282 u32 rets[2]; 1283 1284 prom_debug("prom_instantiate_opal: start...\n"); 1285 1286 opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal")); 1287 prom_debug("opal_node: %x\n", opal_node); 1288 if (!PHANDLE_VALID(opal_node)) 1289 return; 1290 1291 val64 = 0; 1292 prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64)); 1293 size = be64_to_cpu(val64); 1294 if (size == 0) 1295 return; 1296 val64 = 0; 1297 prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64)); 1298 align = be64_to_cpu(val64); 1299 1300 base = alloc_down(size, align, 0); 1301 if (base == 0) { 1302 prom_printf("OPAL allocation failed !\n"); 1303 return; 1304 } 1305 1306 opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal")); 1307 if (!IHANDLE_VALID(opal_inst)) { 1308 prom_printf("opening opal package failed (%x)\n", opal_inst); 1309 return; 1310 } 1311 1312 prom_printf("instantiating opal at 0x%x...", base); 1313 1314 if (call_prom_ret("call-method", 4, 3, rets, 1315 ADDR("load-opal-runtime"), 1316 opal_inst, 1317 base >> 32, base & 0xffffffff) != 0 1318 || (rets[0] == 0 && rets[1] == 0)) { 1319 prom_printf(" failed\n"); 1320 return; 1321 } 1322 entry = (((u64)rets[0]) << 32) | rets[1]; 1323 1324 prom_printf(" done\n"); 1325 1326 reserve_mem(base, size); 1327 1328 prom_debug("opal base = 0x%x\n", base); 1329 prom_debug("opal align = 0x%x\n", align); 1330 prom_debug("opal entry = 0x%x\n", entry); 1331 prom_debug("opal size = 0x%x\n", (long)size); 1332 1333 prom_setprop(opal_node, "/ibm,opal", "opal-base-address", 1334 &base, sizeof(base)); 1335 prom_setprop(opal_node, "/ibm,opal", "opal-entry-address", 1336 &entry, sizeof(entry)); 1337 1338#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 1339 prom_opal_base = base; 1340 prom_opal_entry = entry; 1341#endif 1342 prom_debug("prom_instantiate_opal: end...\n"); 1343} 1344 1345#endif /* CONFIG_PPC_POWERNV */ 1346 1347/* 1348 * Allocate room for and instantiate RTAS 1349 */ 1350static void __init prom_instantiate_rtas(void) 1351{ 1352 phandle rtas_node; 1353 ihandle rtas_inst; 1354 u32 base, entry = 0; 1355 __be32 val; 1356 u32 size = 0; 1357 1358 prom_debug("prom_instantiate_rtas: start...\n"); 1359 1360 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1361 prom_debug("rtas_node: %x\n", rtas_node); 1362 if (!PHANDLE_VALID(rtas_node)) 1363 return; 1364 1365 val = 0; 1366 prom_getprop(rtas_node, "rtas-size", &val, sizeof(size)); 1367 size = be32_to_cpu(val); 1368 if (size == 0) 1369 return; 1370 1371 base = alloc_down(size, PAGE_SIZE, 0); 1372 if (base == 0) 1373 prom_panic("Could not allocate memory for RTAS\n"); 1374 1375 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas")); 1376 if (!IHANDLE_VALID(rtas_inst)) { 1377 prom_printf("opening rtas package failed (%x)\n", rtas_inst); 1378 return; 1379 } 1380 1381 prom_printf("instantiating rtas at 0x%x...", base); 1382 1383 if (call_prom_ret("call-method", 3, 2, &entry, 1384 ADDR("instantiate-rtas"), 1385 rtas_inst, base) != 0 1386 || entry == 0) { 1387 prom_printf(" failed\n"); 1388 return; 1389 } 1390 prom_printf(" done\n"); 1391 1392 reserve_mem(base, size); 1393 1394 val = cpu_to_be32(base); 1395 prom_setprop(rtas_node, "/rtas", "linux,rtas-base", 1396 &val, sizeof(val)); 1397 val = cpu_to_be32(entry); 1398 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry", 1399 &val, sizeof(val)); 1400 1401 /* Check if it supports "query-cpu-stopped-state" */ 1402 if (prom_getprop(rtas_node, "query-cpu-stopped-state", 1403 &val, sizeof(val)) != PROM_ERROR) 1404 rtas_has_query_cpu_stopped = true; 1405 1406 prom_debug("rtas base = 0x%x\n", base); 1407 prom_debug("rtas entry = 0x%x\n", entry); 1408 prom_debug("rtas size = 0x%x\n", (long)size); 1409 1410 prom_debug("prom_instantiate_rtas: end...\n"); 1411} 1412 1413#ifdef CONFIG_PPC64 1414/* 1415 * Allocate room for and instantiate Stored Measurement Log (SML) 1416 */ 1417static void __init prom_instantiate_sml(void) 1418{ 1419 phandle ibmvtpm_node; 1420 ihandle ibmvtpm_inst; 1421 u32 entry = 0, size = 0; 1422 u64 base; 1423 1424 prom_debug("prom_instantiate_sml: start...\n"); 1425 1426 ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/ibm,vtpm")); 1427 prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node); 1428 if (!PHANDLE_VALID(ibmvtpm_node)) 1429 return; 1430 1431 ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/ibm,vtpm")); 1432 if (!IHANDLE_VALID(ibmvtpm_inst)) { 1433 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst); 1434 return; 1435 } 1436 1437 if (call_prom_ret("call-method", 2, 2, &size, 1438 ADDR("sml-get-handover-size"), 1439 ibmvtpm_inst) != 0 || size == 0) { 1440 prom_printf("SML get handover size failed\n"); 1441 return; 1442 } 1443 1444 base = alloc_down(size, PAGE_SIZE, 0); 1445 if (base == 0) 1446 prom_panic("Could not allocate memory for sml\n"); 1447 1448 prom_printf("instantiating sml at 0x%x...", base); 1449 1450 if (call_prom_ret("call-method", 4, 2, &entry, 1451 ADDR("sml-handover"), 1452 ibmvtpm_inst, size, base) != 0 || entry == 0) { 1453 prom_printf("SML handover failed\n"); 1454 return; 1455 } 1456 prom_printf(" done\n"); 1457 1458 reserve_mem(base, size); 1459 1460 prom_setprop(ibmvtpm_node, "/ibm,vtpm", "linux,sml-base", 1461 &base, sizeof(base)); 1462 prom_setprop(ibmvtpm_node, "/ibm,vtpm", "linux,sml-size", 1463 &size, sizeof(size)); 1464 1465 prom_debug("sml base = 0x%x\n", base); 1466 prom_debug("sml size = 0x%x\n", (long)size); 1467 1468 prom_debug("prom_instantiate_sml: end...\n"); 1469} 1470 1471/* 1472 * Allocate room for and initialize TCE tables 1473 */ 1474#ifdef __BIG_ENDIAN__ 1475static void __init prom_initialize_tce_table(void) 1476{ 1477 phandle node; 1478 ihandle phb_node; 1479 char compatible[64], type[64], model[64]; 1480 char *path = prom_scratch; 1481 u64 base, align; 1482 u32 minalign, minsize; 1483 u64 tce_entry, *tce_entryp; 1484 u64 local_alloc_top, local_alloc_bottom; 1485 u64 i; 1486 1487 if (prom_iommu_off) 1488 return; 1489 1490 prom_debug("starting prom_initialize_tce_table\n"); 1491 1492 /* Cache current top of allocs so we reserve a single block */ 1493 local_alloc_top = alloc_top_high; 1494 local_alloc_bottom = local_alloc_top; 1495 1496 /* Search all nodes looking for PHBs. */ 1497 for (node = 0; prom_next_node(&node); ) { 1498 compatible[0] = 0; 1499 type[0] = 0; 1500 model[0] = 0; 1501 prom_getprop(node, "compatible", 1502 compatible, sizeof(compatible)); 1503 prom_getprop(node, "device_type", type, sizeof(type)); 1504 prom_getprop(node, "model", model, sizeof(model)); 1505 1506 if ((type[0] == 0) || (strstr(type, "pci") == NULL)) 1507 continue; 1508 1509 /* Keep the old logic intact to avoid regression. */ 1510 if (compatible[0] != 0) { 1511 if ((strstr(compatible, "python") == NULL) && 1512 (strstr(compatible, "Speedwagon") == NULL) && 1513 (strstr(compatible, "Winnipeg") == NULL)) 1514 continue; 1515 } else if (model[0] != 0) { 1516 if ((strstr(model, "ython") == NULL) && 1517 (strstr(model, "peedwagon") == NULL) && 1518 (strstr(model, "innipeg") == NULL)) 1519 continue; 1520 } 1521 1522 if (prom_getprop(node, "tce-table-minalign", &minalign, 1523 sizeof(minalign)) == PROM_ERROR) 1524 minalign = 0; 1525 if (prom_getprop(node, "tce-table-minsize", &minsize, 1526 sizeof(minsize)) == PROM_ERROR) 1527 minsize = 4UL << 20; 1528 1529 /* 1530 * Even though we read what OF wants, we just set the table 1531 * size to 4 MB. This is enough to map 2GB of PCI DMA space. 1532 * By doing this, we avoid the pitfalls of trying to DMA to 1533 * MMIO space and the DMA alias hole. 1534 * 1535 * On POWER4, firmware sets the TCE region by assuming 1536 * each TCE table is 8MB. Using this memory for anything 1537 * else will impact performance, so we always allocate 8MB. 1538 * Anton 1539 */ 1540 if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p)) 1541 minsize = 8UL << 20; 1542 else 1543 minsize = 4UL << 20; 1544 1545 /* Align to the greater of the align or size */ 1546 align = max(minalign, minsize); 1547 base = alloc_down(minsize, align, 1); 1548 if (base == 0) 1549 prom_panic("ERROR, cannot find space for TCE table.\n"); 1550 if (base < local_alloc_bottom) 1551 local_alloc_bottom = base; 1552 1553 /* It seems OF doesn't null-terminate the path :-( */ 1554 memset(path, 0, PROM_SCRATCH_SIZE); 1555 /* Call OF to setup the TCE hardware */ 1556 if (call_prom("package-to-path", 3, 1, node, 1557 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) { 1558 prom_printf("package-to-path failed\n"); 1559 } 1560 1561 /* Save away the TCE table attributes for later use. */ 1562 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base)); 1563 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize)); 1564 1565 prom_debug("TCE table: %s\n", path); 1566 prom_debug("\tnode = 0x%x\n", node); 1567 prom_debug("\tbase = 0x%x\n", base); 1568 prom_debug("\tsize = 0x%x\n", minsize); 1569 1570 /* Initialize the table to have a one-to-one mapping 1571 * over the allocated size. 1572 */ 1573 tce_entryp = (u64 *)base; 1574 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) { 1575 tce_entry = (i << PAGE_SHIFT); 1576 tce_entry |= 0x3; 1577 *tce_entryp = tce_entry; 1578 } 1579 1580 prom_printf("opening PHB %s", path); 1581 phb_node = call_prom("open", 1, 1, path); 1582 if (phb_node == 0) 1583 prom_printf("... failed\n"); 1584 else 1585 prom_printf("... done\n"); 1586 1587 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"), 1588 phb_node, -1, minsize, 1589 (u32) base, (u32) (base >> 32)); 1590 call_prom("close", 1, 0, phb_node); 1591 } 1592 1593 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom); 1594 1595 /* These are only really needed if there is a memory limit in 1596 * effect, but we don't know so export them always. */ 1597 prom_tce_alloc_start = local_alloc_bottom; 1598 prom_tce_alloc_end = local_alloc_top; 1599 1600 /* Flag the first invalid entry */ 1601 prom_debug("ending prom_initialize_tce_table\n"); 1602} 1603#endif /* __BIG_ENDIAN__ */ 1604#endif /* CONFIG_PPC64 */ 1605 1606/* 1607 * With CHRP SMP we need to use the OF to start the other processors. 1608 * We can't wait until smp_boot_cpus (the OF is trashed by then) 1609 * so we have to put the processors into a holding pattern controlled 1610 * by the kernel (not OF) before we destroy the OF. 1611 * 1612 * This uses a chunk of low memory, puts some holding pattern 1613 * code there and sends the other processors off to there until 1614 * smp_boot_cpus tells them to do something. The holding pattern 1615 * checks that address until its cpu # is there, when it is that 1616 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care 1617 * of setting those values. 1618 * 1619 * We also use physical address 0x4 here to tell when a cpu 1620 * is in its holding pattern code. 1621 * 1622 * -- Cort 1623 */ 1624/* 1625 * We want to reference the copy of __secondary_hold_* in the 1626 * 0 - 0x100 address range 1627 */ 1628#define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff) 1629 1630static void __init prom_hold_cpus(void) 1631{ 1632 unsigned long i; 1633 phandle node; 1634 char type[64]; 1635 unsigned long *spinloop 1636 = (void *) LOW_ADDR(__secondary_hold_spinloop); 1637 unsigned long *acknowledge 1638 = (void *) LOW_ADDR(__secondary_hold_acknowledge); 1639 unsigned long secondary_hold = LOW_ADDR(__secondary_hold); 1640 1641 /* 1642 * On pseries, if RTAS supports "query-cpu-stopped-state", 1643 * we skip this stage, the CPUs will be started by the 1644 * kernel using RTAS. 1645 */ 1646 if ((of_platform == PLATFORM_PSERIES || 1647 of_platform == PLATFORM_PSERIES_LPAR) && 1648 rtas_has_query_cpu_stopped) { 1649 prom_printf("prom_hold_cpus: skipped\n"); 1650 return; 1651 } 1652 1653 prom_debug("prom_hold_cpus: start...\n"); 1654 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop); 1655 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop); 1656 prom_debug(" 1) acknowledge = 0x%x\n", 1657 (unsigned long)acknowledge); 1658 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge); 1659 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold); 1660 1661 /* Set the common spinloop variable, so all of the secondary cpus 1662 * will block when they are awakened from their OF spinloop. 1663 * This must occur for both SMP and non SMP kernels, since OF will 1664 * be trashed when we move the kernel. 1665 */ 1666 *spinloop = 0; 1667 1668 /* look for cpus */ 1669 for (node = 0; prom_next_node(&node); ) { 1670 unsigned int cpu_no; 1671 __be32 reg; 1672 1673 type[0] = 0; 1674 prom_getprop(node, "device_type", type, sizeof(type)); 1675 if (strcmp(type, "cpu") != 0) 1676 continue; 1677 1678 /* Skip non-configured cpus. */ 1679 if (prom_getprop(node, "status", type, sizeof(type)) > 0) 1680 if (strcmp(type, "okay") != 0) 1681 continue; 1682 1683 reg = cpu_to_be32(-1); /* make sparse happy */ 1684 prom_getprop(node, "reg", ®, sizeof(reg)); 1685 cpu_no = be32_to_cpu(reg); 1686 1687 prom_debug("cpu hw idx = %lu\n", cpu_no); 1688 1689 /* Init the acknowledge var which will be reset by 1690 * the secondary cpu when it awakens from its OF 1691 * spinloop. 1692 */ 1693 *acknowledge = (unsigned long)-1; 1694 1695 if (cpu_no != prom.cpu) { 1696 /* Primary Thread of non-boot cpu or any thread */ 1697 prom_printf("starting cpu hw idx %lu... ", cpu_no); 1698 call_prom("start-cpu", 3, 0, node, 1699 secondary_hold, cpu_no); 1700 1701 for (i = 0; (i < 100000000) && 1702 (*acknowledge == ((unsigned long)-1)); i++ ) 1703 mb(); 1704 1705 if (*acknowledge == cpu_no) 1706 prom_printf("done\n"); 1707 else 1708 prom_printf("failed: %x\n", *acknowledge); 1709 } 1710#ifdef CONFIG_SMP 1711 else 1712 prom_printf("boot cpu hw idx %lu\n", cpu_no); 1713#endif /* CONFIG_SMP */ 1714 } 1715 1716 prom_debug("prom_hold_cpus: end...\n"); 1717} 1718 1719 1720static void __init prom_init_client_services(unsigned long pp) 1721{ 1722 /* Get a handle to the prom entry point before anything else */ 1723 prom_entry = pp; 1724 1725 /* get a handle for the stdout device */ 1726 prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen")); 1727 if (!PHANDLE_VALID(prom.chosen)) 1728 prom_panic("cannot find chosen"); /* msg won't be printed :( */ 1729 1730 /* get device tree root */ 1731 prom.root = call_prom("finddevice", 1, 1, ADDR("/")); 1732 if (!PHANDLE_VALID(prom.root)) 1733 prom_panic("cannot find device tree root"); /* msg won't be printed :( */ 1734 1735 prom.mmumap = 0; 1736} 1737 1738#ifdef CONFIG_PPC32 1739/* 1740 * For really old powermacs, we need to map things we claim. 1741 * For that, we need the ihandle of the mmu. 1742 * Also, on the longtrail, we need to work around other bugs. 1743 */ 1744static void __init prom_find_mmu(void) 1745{ 1746 phandle oprom; 1747 char version[64]; 1748 1749 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom")); 1750 if (!PHANDLE_VALID(oprom)) 1751 return; 1752 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0) 1753 return; 1754 version[sizeof(version) - 1] = 0; 1755 /* XXX might need to add other versions here */ 1756 if (strcmp(version, "Open Firmware, 1.0.5") == 0) 1757 of_workarounds = OF_WA_CLAIM; 1758 else if (strncmp(version, "FirmWorks,3.", 12) == 0) { 1759 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL; 1760 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim"); 1761 } else 1762 return; 1763 prom.memory = call_prom("open", 1, 1, ADDR("/memory")); 1764 prom_getprop(prom.chosen, "mmu", &prom.mmumap, 1765 sizeof(prom.mmumap)); 1766 prom.mmumap = be32_to_cpu(prom.mmumap); 1767 if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap)) 1768 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */ 1769} 1770#else 1771#define prom_find_mmu() 1772#endif 1773 1774static void __init prom_init_stdout(void) 1775{ 1776 char *path = of_stdout_device; 1777 char type[16]; 1778 phandle stdout_node; 1779 __be32 val; 1780 1781 if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0) 1782 prom_panic("cannot find stdout"); 1783 1784 prom.stdout = be32_to_cpu(val); 1785 1786 /* Get the full OF pathname of the stdout device */ 1787 memset(path, 0, 256); 1788 call_prom("instance-to-path", 3, 1, prom.stdout, path, 255); 1789 prom_printf("OF stdout device is: %s\n", of_stdout_device); 1790 prom_setprop(prom.chosen, "/chosen", "linux,stdout-path", 1791 path, strlen(path) + 1); 1792 1793 /* instance-to-package fails on PA-Semi */ 1794 stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout); 1795 if (stdout_node != PROM_ERROR) { 1796 val = cpu_to_be32(stdout_node); 1797 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package", 1798 &val, sizeof(val)); 1799 1800 /* If it's a display, note it */ 1801 memset(type, 0, sizeof(type)); 1802 prom_getprop(stdout_node, "device_type", type, sizeof(type)); 1803 if (strcmp(type, "display") == 0) 1804 prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0); 1805 } 1806} 1807 1808static int __init prom_find_machine_type(void) 1809{ 1810 char compat[256]; 1811 int len, i = 0; 1812#ifdef CONFIG_PPC64 1813 phandle rtas; 1814 int x; 1815#endif 1816 1817 /* Look for a PowerMac or a Cell */ 1818 len = prom_getprop(prom.root, "compatible", 1819 compat, sizeof(compat)-1); 1820 if (len > 0) { 1821 compat[len] = 0; 1822 while (i < len) { 1823 char *p = &compat[i]; 1824 int sl = strlen(p); 1825 if (sl == 0) 1826 break; 1827 if (strstr(p, "Power Macintosh") || 1828 strstr(p, "MacRISC")) 1829 return PLATFORM_POWERMAC; 1830#ifdef CONFIG_PPC64 1831 /* We must make sure we don't detect the IBM Cell 1832 * blades as pSeries due to some firmware issues, 1833 * so we do it here. 1834 */ 1835 if (strstr(p, "IBM,CBEA") || 1836 strstr(p, "IBM,CPBW-1.0")) 1837 return PLATFORM_GENERIC; 1838#endif /* CONFIG_PPC64 */ 1839 i += sl + 1; 1840 } 1841 } 1842#ifdef CONFIG_PPC64 1843 /* Try to detect OPAL */ 1844 if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal")))) 1845 return PLATFORM_OPAL; 1846 1847 /* Try to figure out if it's an IBM pSeries or any other 1848 * PAPR compliant platform. We assume it is if : 1849 * - /device_type is "chrp" (please, do NOT use that for future 1850 * non-IBM designs ! 1851 * - it has /rtas 1852 */ 1853 len = prom_getprop(prom.root, "device_type", 1854 compat, sizeof(compat)-1); 1855 if (len <= 0) 1856 return PLATFORM_GENERIC; 1857 if (strcmp(compat, "chrp")) 1858 return PLATFORM_GENERIC; 1859 1860 /* Default to pSeries. We need to know if we are running LPAR */ 1861 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1862 if (!PHANDLE_VALID(rtas)) 1863 return PLATFORM_GENERIC; 1864 x = prom_getproplen(rtas, "ibm,hypertas-functions"); 1865 if (x != PROM_ERROR) { 1866 prom_debug("Hypertas detected, assuming LPAR !\n"); 1867 return PLATFORM_PSERIES_LPAR; 1868 } 1869 return PLATFORM_PSERIES; 1870#else 1871 return PLATFORM_GENERIC; 1872#endif 1873} 1874 1875static int __init prom_set_color(ihandle ih, int i, int r, int g, int b) 1876{ 1877 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r); 1878} 1879 1880/* 1881 * If we have a display that we don't know how to drive, 1882 * we will want to try to execute OF's open method for it 1883 * later. However, OF will probably fall over if we do that 1884 * we've taken over the MMU. 1885 * So we check whether we will need to open the display, 1886 * and if so, open it now. 1887 */ 1888static void __init prom_check_displays(void) 1889{ 1890 char type[16], *path; 1891 phandle node; 1892 ihandle ih; 1893 int i; 1894 1895 static unsigned char default_colors[] = { 1896 0x00, 0x00, 0x00, 1897 0x00, 0x00, 0xaa, 1898 0x00, 0xaa, 0x00, 1899 0x00, 0xaa, 0xaa, 1900 0xaa, 0x00, 0x00, 1901 0xaa, 0x00, 0xaa, 1902 0xaa, 0xaa, 0x00, 1903 0xaa, 0xaa, 0xaa, 1904 0x55, 0x55, 0x55, 1905 0x55, 0x55, 0xff, 1906 0x55, 0xff, 0x55, 1907 0x55, 0xff, 0xff, 1908 0xff, 0x55, 0x55, 1909 0xff, 0x55, 0xff, 1910 0xff, 0xff, 0x55, 1911 0xff, 0xff, 0xff 1912 }; 1913 const unsigned char *clut; 1914 1915 prom_debug("Looking for displays\n"); 1916 for (node = 0; prom_next_node(&node); ) { 1917 memset(type, 0, sizeof(type)); 1918 prom_getprop(node, "device_type", type, sizeof(type)); 1919 if (strcmp(type, "display") != 0) 1920 continue; 1921 1922 /* It seems OF doesn't null-terminate the path :-( */ 1923 path = prom_scratch; 1924 memset(path, 0, PROM_SCRATCH_SIZE); 1925 1926 /* 1927 * leave some room at the end of the path for appending extra 1928 * arguments 1929 */ 1930 if (call_prom("package-to-path", 3, 1, node, path, 1931 PROM_SCRATCH_SIZE-10) == PROM_ERROR) 1932 continue; 1933 prom_printf("found display : %s, opening... ", path); 1934 1935 ih = call_prom("open", 1, 1, path); 1936 if (ih == 0) { 1937 prom_printf("failed\n"); 1938 continue; 1939 } 1940 1941 /* Success */ 1942 prom_printf("done\n"); 1943 prom_setprop(node, path, "linux,opened", NULL, 0); 1944 1945 /* Setup a usable color table when the appropriate 1946 * method is available. Should update this to set-colors */ 1947 clut = default_colors; 1948 for (i = 0; i < 16; i++, clut += 3) 1949 if (prom_set_color(ih, i, clut[0], clut[1], 1950 clut[2]) != 0) 1951 break; 1952 1953#ifdef CONFIG_LOGO_LINUX_CLUT224 1954 clut = PTRRELOC(logo_linux_clut224.clut); 1955 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3) 1956 if (prom_set_color(ih, i + 32, clut[0], clut[1], 1957 clut[2]) != 0) 1958 break; 1959#endif /* CONFIG_LOGO_LINUX_CLUT224 */ 1960 1961#ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX 1962 if (prom_getprop(node, "linux,boot-display", NULL, 0) != 1963 PROM_ERROR) { 1964 u32 width, height, pitch, addr; 1965 1966 prom_printf("Setting btext !\n"); 1967 prom_getprop(node, "width", &width, 4); 1968 prom_getprop(node, "height", &height, 4); 1969 prom_getprop(node, "linebytes", &pitch, 4); 1970 prom_getprop(node, "address", &addr, 4); 1971 prom_printf("W=%d H=%d LB=%d addr=0x%x\n", 1972 width, height, pitch, addr); 1973 btext_setup_display(width, height, 8, pitch, addr); 1974 } 1975#endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */ 1976 } 1977} 1978 1979 1980/* Return (relocated) pointer to this much memory: moves initrd if reqd. */ 1981static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end, 1982 unsigned long needed, unsigned long align) 1983{ 1984 void *ret; 1985 1986 *mem_start = _ALIGN(*mem_start, align); 1987 while ((*mem_start + needed) > *mem_end) { 1988 unsigned long room, chunk; 1989 1990 prom_debug("Chunk exhausted, claiming more at %x...\n", 1991 alloc_bottom); 1992 room = alloc_top - alloc_bottom; 1993 if (room > DEVTREE_CHUNK_SIZE) 1994 room = DEVTREE_CHUNK_SIZE; 1995 if (room < PAGE_SIZE) 1996 prom_panic("No memory for flatten_device_tree " 1997 "(no room)\n"); 1998 chunk = alloc_up(room, 0); 1999 if (chunk == 0) 2000 prom_panic("No memory for flatten_device_tree " 2001 "(claim failed)\n"); 2002 *mem_end = chunk + room; 2003 } 2004 2005 ret = (void *)*mem_start; 2006 *mem_start += needed; 2007 2008 return ret; 2009} 2010 2011#define dt_push_token(token, mem_start, mem_end) do { \ 2012 void *room = make_room(mem_start, mem_end, 4, 4); \ 2013 *(__be32 *)room = cpu_to_be32(token); \ 2014 } while(0) 2015 2016static unsigned long __init dt_find_string(char *str) 2017{ 2018 char *s, *os; 2019 2020 s = os = (char *)dt_string_start; 2021 s += 4; 2022 while (s < (char *)dt_string_end) { 2023 if (strcmp(s, str) == 0) 2024 return s - os; 2025 s += strlen(s) + 1; 2026 } 2027 return 0; 2028} 2029 2030/* 2031 * The Open Firmware 1275 specification states properties must be 31 bytes or 2032 * less, however not all firmwares obey this. Make it 64 bytes to be safe. 2033 */ 2034#define MAX_PROPERTY_NAME 64 2035 2036static void __init scan_dt_build_strings(phandle node, 2037 unsigned long *mem_start, 2038 unsigned long *mem_end) 2039{ 2040 char *prev_name, *namep, *sstart; 2041 unsigned long soff; 2042 phandle child; 2043 2044 sstart = (char *)dt_string_start; 2045 2046 /* get and store all property names */ 2047 prev_name = ""; 2048 for (;;) { 2049 /* 64 is max len of name including nul. */ 2050 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1); 2051 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) { 2052 /* No more nodes: unwind alloc */ 2053 *mem_start = (unsigned long)namep; 2054 break; 2055 } 2056 2057 /* skip "name" */ 2058 if (strcmp(namep, "name") == 0) { 2059 *mem_start = (unsigned long)namep; 2060 prev_name = "name"; 2061 continue; 2062 } 2063 /* get/create string entry */ 2064 soff = dt_find_string(namep); 2065 if (soff != 0) { 2066 *mem_start = (unsigned long)namep; 2067 namep = sstart + soff; 2068 } else { 2069 /* Trim off some if we can */ 2070 *mem_start = (unsigned long)namep + strlen(namep) + 1; 2071 dt_string_end = *mem_start; 2072 } 2073 prev_name = namep; 2074 } 2075 2076 /* do all our children */ 2077 child = call_prom("child", 1, 1, node); 2078 while (child != 0) { 2079 scan_dt_build_strings(child, mem_start, mem_end); 2080 child = call_prom("peer", 1, 1, child); 2081 } 2082} 2083 2084static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start, 2085 unsigned long *mem_end) 2086{ 2087 phandle child; 2088 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path; 2089 unsigned long soff; 2090 unsigned char *valp; 2091 static char pname[MAX_PROPERTY_NAME]; 2092 int l, room, has_phandle = 0; 2093 2094 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end); 2095 2096 /* get the node's full name */ 2097 namep = (char *)*mem_start; 2098 room = *mem_end - *mem_start; 2099 if (room > 255) 2100 room = 255; 2101 l = call_prom("package-to-path", 3, 1, node, namep, room); 2102 if (l >= 0) { 2103 /* Didn't fit? Get more room. */ 2104 if (l >= room) { 2105 if (l >= *mem_end - *mem_start) 2106 namep = make_room(mem_start, mem_end, l+1, 1); 2107 call_prom("package-to-path", 3, 1, node, namep, l); 2108 } 2109 namep[l] = '\0'; 2110 2111 /* Fixup an Apple bug where they have bogus \0 chars in the 2112 * middle of the path in some properties, and extract 2113 * the unit name (everything after the last '/'). 2114 */ 2115 for (lp = p = namep, ep = namep + l; p < ep; p++) { 2116 if (*p == '/') 2117 lp = namep; 2118 else if (*p != 0) 2119 *lp++ = *p; 2120 } 2121 *lp = 0; 2122 *mem_start = _ALIGN((unsigned long)lp + 1, 4); 2123 } 2124 2125 /* get it again for debugging */ 2126 path = prom_scratch; 2127 memset(path, 0, PROM_SCRATCH_SIZE); 2128 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 2129 2130 /* get and store all properties */ 2131 prev_name = ""; 2132 sstart = (char *)dt_string_start; 2133 for (;;) { 2134 if (call_prom("nextprop", 3, 1, node, prev_name, 2135 pname) != 1) 2136 break; 2137 2138 /* skip "name" */ 2139 if (strcmp(pname, "name") == 0) { 2140 prev_name = "name"; 2141 continue; 2142 } 2143 2144 /* find string offset */ 2145 soff = dt_find_string(pname); 2146 if (soff == 0) { 2147 prom_printf("WARNING: Can't find string index for" 2148 " <%s>, node %s\n", pname, path); 2149 break; 2150 } 2151 prev_name = sstart + soff; 2152 2153 /* get length */ 2154 l = call_prom("getproplen", 2, 1, node, pname); 2155 2156 /* sanity checks */ 2157 if (l == PROM_ERROR) 2158 continue; 2159 2160 /* push property head */ 2161 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2162 dt_push_token(l, mem_start, mem_end); 2163 dt_push_token(soff, mem_start, mem_end); 2164 2165 /* push property content */ 2166 valp = make_room(mem_start, mem_end, l, 4); 2167 call_prom("getprop", 4, 1, node, pname, valp, l); 2168 *mem_start = _ALIGN(*mem_start, 4); 2169 2170 if (!strcmp(pname, "phandle")) 2171 has_phandle = 1; 2172 } 2173 2174 /* Add a "linux,phandle" property if no "phandle" property already 2175 * existed (can happen with OPAL) 2176 */ 2177 if (!has_phandle) { 2178 soff = dt_find_string("linux,phandle"); 2179 if (soff == 0) 2180 prom_printf("WARNING: Can't find string index for" 2181 " <linux-phandle> node %s\n", path); 2182 else { 2183 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2184 dt_push_token(4, mem_start, mem_end); 2185 dt_push_token(soff, mem_start, mem_end); 2186 valp = make_room(mem_start, mem_end, 4, 4); 2187 *(__be32 *)valp = cpu_to_be32(node); 2188 } 2189 } 2190 2191 /* do all our children */ 2192 child = call_prom("child", 1, 1, node); 2193 while (child != 0) { 2194 scan_dt_build_struct(child, mem_start, mem_end); 2195 child = call_prom("peer", 1, 1, child); 2196 } 2197 2198 dt_push_token(OF_DT_END_NODE, mem_start, mem_end); 2199} 2200 2201static void __init flatten_device_tree(void) 2202{ 2203 phandle root; 2204 unsigned long mem_start, mem_end, room; 2205 struct boot_param_header *hdr; 2206 char *namep; 2207 u64 *rsvmap; 2208 2209 /* 2210 * Check how much room we have between alloc top & bottom (+/- a 2211 * few pages), crop to 1MB, as this is our "chunk" size 2212 */ 2213 room = alloc_top - alloc_bottom - 0x4000; 2214 if (room > DEVTREE_CHUNK_SIZE) 2215 room = DEVTREE_CHUNK_SIZE; 2216 prom_debug("starting device tree allocs at %x\n", alloc_bottom); 2217 2218 /* Now try to claim that */ 2219 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE); 2220 if (mem_start == 0) 2221 prom_panic("Can't allocate initial device-tree chunk\n"); 2222 mem_end = mem_start + room; 2223 2224 /* Get root of tree */ 2225 root = call_prom("peer", 1, 1, (phandle)0); 2226 if (root == (phandle)0) 2227 prom_panic ("couldn't get device tree root\n"); 2228 2229 /* Build header and make room for mem rsv map */ 2230 mem_start = _ALIGN(mem_start, 4); 2231 hdr = make_room(&mem_start, &mem_end, 2232 sizeof(struct boot_param_header), 4); 2233 dt_header_start = (unsigned long)hdr; 2234 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8); 2235 2236 /* Start of strings */ 2237 mem_start = PAGE_ALIGN(mem_start); 2238 dt_string_start = mem_start; 2239 mem_start += 4; /* hole */ 2240 2241 /* Add "linux,phandle" in there, we'll need it */ 2242 namep = make_room(&mem_start, &mem_end, 16, 1); 2243 strcpy(namep, "linux,phandle"); 2244 mem_start = (unsigned long)namep + strlen(namep) + 1; 2245 2246 /* Build string array */ 2247 prom_printf("Building dt strings...\n"); 2248 scan_dt_build_strings(root, &mem_start, &mem_end); 2249 dt_string_end = mem_start; 2250 2251 /* Build structure */ 2252 mem_start = PAGE_ALIGN(mem_start); 2253 dt_struct_start = mem_start; 2254 prom_printf("Building dt structure...\n"); 2255 scan_dt_build_struct(root, &mem_start, &mem_end); 2256 dt_push_token(OF_DT_END, &mem_start, &mem_end); 2257 dt_struct_end = PAGE_ALIGN(mem_start); 2258 2259 /* Finish header */ 2260 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu); 2261 hdr->magic = cpu_to_be32(OF_DT_HEADER); 2262 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start); 2263 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start); 2264 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start); 2265 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start); 2266 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start); 2267 hdr->version = cpu_to_be32(OF_DT_VERSION); 2268 /* Version 16 is not backward compatible */ 2269 hdr->last_comp_version = cpu_to_be32(0x10); 2270 2271 /* Copy the reserve map in */ 2272 memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map)); 2273 2274#ifdef DEBUG_PROM 2275 { 2276 int i; 2277 prom_printf("reserved memory map:\n"); 2278 for (i = 0; i < mem_reserve_cnt; i++) 2279 prom_printf(" %x - %x\n", 2280 be64_to_cpu(mem_reserve_map[i].base), 2281 be64_to_cpu(mem_reserve_map[i].size)); 2282 } 2283#endif 2284 /* Bump mem_reserve_cnt to cause further reservations to fail 2285 * since it's too late. 2286 */ 2287 mem_reserve_cnt = MEM_RESERVE_MAP_SIZE; 2288 2289 prom_printf("Device tree strings 0x%x -> 0x%x\n", 2290 dt_string_start, dt_string_end); 2291 prom_printf("Device tree struct 0x%x -> 0x%x\n", 2292 dt_struct_start, dt_struct_end); 2293} 2294 2295#ifdef CONFIG_PPC_MAPLE 2296/* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property. 2297 * The values are bad, and it doesn't even have the right number of cells. */ 2298static void __init fixup_device_tree_maple(void) 2299{ 2300 phandle isa; 2301 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */ 2302 u32 isa_ranges[6]; 2303 char *name; 2304 2305 name = "/ht@0/isa@4"; 2306 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2307 if (!PHANDLE_VALID(isa)) { 2308 name = "/ht@0/isa@6"; 2309 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2310 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2311 } 2312 if (!PHANDLE_VALID(isa)) 2313 return; 2314 2315 if (prom_getproplen(isa, "ranges") != 12) 2316 return; 2317 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges)) 2318 == PROM_ERROR) 2319 return; 2320 2321 if (isa_ranges[0] != 0x1 || 2322 isa_ranges[1] != 0xf4000000 || 2323 isa_ranges[2] != 0x00010000) 2324 return; 2325 2326 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n"); 2327 2328 isa_ranges[0] = 0x1; 2329 isa_ranges[1] = 0x0; 2330 isa_ranges[2] = rloc; 2331 isa_ranges[3] = 0x0; 2332 isa_ranges[4] = 0x0; 2333 isa_ranges[5] = 0x00010000; 2334 prom_setprop(isa, name, "ranges", 2335 isa_ranges, sizeof(isa_ranges)); 2336} 2337 2338#define CPC925_MC_START 0xf8000000 2339#define CPC925_MC_LENGTH 0x1000000 2340/* The values for memory-controller don't have right number of cells */ 2341static void __init fixup_device_tree_maple_memory_controller(void) 2342{ 2343 phandle mc; 2344 u32 mc_reg[4]; 2345 char *name = "/hostbridge@f8000000"; 2346 u32 ac, sc; 2347 2348 mc = call_prom("finddevice", 1, 1, ADDR(name)); 2349 if (!PHANDLE_VALID(mc)) 2350 return; 2351 2352 if (prom_getproplen(mc, "reg") != 8) 2353 return; 2354 2355 prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac)); 2356 prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc)); 2357 if ((ac != 2) || (sc != 2)) 2358 return; 2359 2360 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR) 2361 return; 2362 2363 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH) 2364 return; 2365 2366 prom_printf("Fixing up bogus hostbridge on Maple...\n"); 2367 2368 mc_reg[0] = 0x0; 2369 mc_reg[1] = CPC925_MC_START; 2370 mc_reg[2] = 0x0; 2371 mc_reg[3] = CPC925_MC_LENGTH; 2372 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg)); 2373} 2374#else 2375#define fixup_device_tree_maple() 2376#define fixup_device_tree_maple_memory_controller() 2377#endif 2378 2379#ifdef CONFIG_PPC_CHRP 2380/* 2381 * Pegasos and BriQ lacks the "ranges" property in the isa node 2382 * Pegasos needs decimal IRQ 14/15, not hexadecimal 2383 * Pegasos has the IDE configured in legacy mode, but advertised as native 2384 */ 2385static void __init fixup_device_tree_chrp(void) 2386{ 2387 phandle ph; 2388 u32 prop[6]; 2389 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */ 2390 char *name; 2391 int rc; 2392 2393 name = "/pci@80000000/isa@c"; 2394 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2395 if (!PHANDLE_VALID(ph)) { 2396 name = "/pci@ff500000/isa@6"; 2397 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2398 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2399 } 2400 if (PHANDLE_VALID(ph)) { 2401 rc = prom_getproplen(ph, "ranges"); 2402 if (rc == 0 || rc == PROM_ERROR) { 2403 prom_printf("Fixing up missing ISA range on Pegasos...\n"); 2404 2405 prop[0] = 0x1; 2406 prop[1] = 0x0; 2407 prop[2] = rloc; 2408 prop[3] = 0x0; 2409 prop[4] = 0x0; 2410 prop[5] = 0x00010000; 2411 prom_setprop(ph, name, "ranges", prop, sizeof(prop)); 2412 } 2413 } 2414 2415 name = "/pci@80000000/ide@C,1"; 2416 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2417 if (PHANDLE_VALID(ph)) { 2418 prom_printf("Fixing up IDE interrupt on Pegasos...\n"); 2419 prop[0] = 14; 2420 prop[1] = 0x0; 2421 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32)); 2422 prom_printf("Fixing up IDE class-code on Pegasos...\n"); 2423 rc = prom_getprop(ph, "class-code", prop, sizeof(u32)); 2424 if (rc == sizeof(u32)) { 2425 prop[0] &= ~0x5; 2426 prom_setprop(ph, name, "class-code", prop, sizeof(u32)); 2427 } 2428 } 2429} 2430#else 2431#define fixup_device_tree_chrp() 2432#endif 2433 2434#if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC) 2435static void __init fixup_device_tree_pmac(void) 2436{ 2437 phandle u3, i2c, mpic; 2438 u32 u3_rev; 2439 u32 interrupts[2]; 2440 u32 parent; 2441 2442 /* Some G5s have a missing interrupt definition, fix it up here */ 2443 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000")); 2444 if (!PHANDLE_VALID(u3)) 2445 return; 2446 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000")); 2447 if (!PHANDLE_VALID(i2c)) 2448 return; 2449 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000")); 2450 if (!PHANDLE_VALID(mpic)) 2451 return; 2452 2453 /* check if proper rev of u3 */ 2454 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev)) 2455 == PROM_ERROR) 2456 return; 2457 if (u3_rev < 0x35 || u3_rev > 0x39) 2458 return; 2459 /* does it need fixup ? */ 2460 if (prom_getproplen(i2c, "interrupts") > 0) 2461 return; 2462 2463 prom_printf("fixing up bogus interrupts for u3 i2c...\n"); 2464 2465 /* interrupt on this revision of u3 is number 0 and level */ 2466 interrupts[0] = 0; 2467 interrupts[1] = 1; 2468 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts", 2469 &interrupts, sizeof(interrupts)); 2470 parent = (u32)mpic; 2471 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent", 2472 &parent, sizeof(parent)); 2473} 2474#else 2475#define fixup_device_tree_pmac() 2476#endif 2477 2478#ifdef CONFIG_PPC_EFIKA 2479/* 2480 * The MPC5200 FEC driver requires an phy-handle property to tell it how 2481 * to talk to the phy. If the phy-handle property is missing, then this 2482 * function is called to add the appropriate nodes and link it to the 2483 * ethernet node. 2484 */ 2485static void __init fixup_device_tree_efika_add_phy(void) 2486{ 2487 u32 node; 2488 char prop[64]; 2489 int rv; 2490 2491 /* Check if /builtin/ethernet exists - bail if it doesn't */ 2492 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet")); 2493 if (!PHANDLE_VALID(node)) 2494 return; 2495 2496 /* Check if the phy-handle property exists - bail if it does */ 2497 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop)); 2498 if (!rv) 2499 return; 2500 2501 /* 2502 * At this point the ethernet device doesn't have a phy described. 2503 * Now we need to add the missing phy node and linkage 2504 */ 2505 2506 /* Check for an MDIO bus node - if missing then create one */ 2507 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio")); 2508 if (!PHANDLE_VALID(node)) { 2509 prom_printf("Adding Ethernet MDIO node\n"); 2510 call_prom("interpret", 1, 1, 2511 " s\" /builtin\" find-device" 2512 " new-device" 2513 " 1 encode-int s\" #address-cells\" property" 2514 " 0 encode-int s\" #size-cells\" property" 2515 " s\" mdio\" device-name" 2516 " s\" fsl,mpc5200b-mdio\" encode-string" 2517 " s\" compatible\" property" 2518 " 0xf0003000 0x400 reg" 2519 " 0x2 encode-int" 2520 " 0x5 encode-int encode+" 2521 " 0x3 encode-int encode+" 2522 " s\" interrupts\" property" 2523 " finish-device"); 2524 }; 2525 2526 /* Check for a PHY device node - if missing then create one and 2527 * give it's phandle to the ethernet node */ 2528 node = call_prom("finddevice", 1, 1, 2529 ADDR("/builtin/mdio/ethernet-phy")); 2530 if (!PHANDLE_VALID(node)) { 2531 prom_printf("Adding Ethernet PHY node\n"); 2532 call_prom("interpret", 1, 1, 2533 " s\" /builtin/mdio\" find-device" 2534 " new-device" 2535 " s\" ethernet-phy\" device-name" 2536 " 0x10 encode-int s\" reg\" property" 2537 " my-self" 2538 " ihandle>phandle" 2539 " finish-device" 2540 " s\" /builtin/ethernet\" find-device" 2541 " encode-int" 2542 " s\" phy-handle\" property" 2543 " device-end"); 2544 } 2545} 2546 2547static void __init fixup_device_tree_efika(void) 2548{ 2549 int sound_irq[3] = { 2, 2, 0 }; 2550 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0, 2551 3,4,0, 3,5,0, 3,6,0, 3,7,0, 2552 3,8,0, 3,9,0, 3,10,0, 3,11,0, 2553 3,12,0, 3,13,0, 3,14,0, 3,15,0 }; 2554 u32 node; 2555 char prop[64]; 2556 int rv, len; 2557 2558 /* Check if we're really running on a EFIKA */ 2559 node = call_prom("finddevice", 1, 1, ADDR("/")); 2560 if (!PHANDLE_VALID(node)) 2561 return; 2562 2563 rv = prom_getprop(node, "model", prop, sizeof(prop)); 2564 if (rv == PROM_ERROR) 2565 return; 2566 if (strcmp(prop, "EFIKA5K2")) 2567 return; 2568 2569 prom_printf("Applying EFIKA device tree fixups\n"); 2570 2571 /* Claiming to be 'chrp' is death */ 2572 node = call_prom("finddevice", 1, 1, ADDR("/")); 2573 rv = prom_getprop(node, "device_type", prop, sizeof(prop)); 2574 if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0)) 2575 prom_setprop(node, "/", "device_type", "efika", sizeof("efika")); 2576 2577 /* CODEGEN,description is exposed in /proc/cpuinfo so 2578 fix that too */ 2579 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop)); 2580 if (rv != PROM_ERROR && (strstr(prop, "CHRP"))) 2581 prom_setprop(node, "/", "CODEGEN,description", 2582 "Efika 5200B PowerPC System", 2583 sizeof("Efika 5200B PowerPC System")); 2584 2585 /* Fixup bestcomm interrupts property */ 2586 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm")); 2587 if (PHANDLE_VALID(node)) { 2588 len = prom_getproplen(node, "interrupts"); 2589 if (len == 12) { 2590 prom_printf("Fixing bestcomm interrupts property\n"); 2591 prom_setprop(node, "/builtin/bestcom", "interrupts", 2592 bcomm_irq, sizeof(bcomm_irq)); 2593 } 2594 } 2595 2596 /* Fixup sound interrupts property */ 2597 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound")); 2598 if (PHANDLE_VALID(node)) { 2599 rv = prom_getprop(node, "interrupts", prop, sizeof(prop)); 2600 if (rv == PROM_ERROR) { 2601 prom_printf("Adding sound interrupts property\n"); 2602 prom_setprop(node, "/builtin/sound", "interrupts", 2603 sound_irq, sizeof(sound_irq)); 2604 } 2605 } 2606 2607 /* Make sure ethernet phy-handle property exists */ 2608 fixup_device_tree_efika_add_phy(); 2609} 2610#else 2611#define fixup_device_tree_efika() 2612#endif 2613 2614static void __init fixup_device_tree(void) 2615{ 2616 fixup_device_tree_maple(); 2617 fixup_device_tree_maple_memory_controller(); 2618 fixup_device_tree_chrp(); 2619 fixup_device_tree_pmac(); 2620 fixup_device_tree_efika(); 2621} 2622 2623static void __init prom_find_boot_cpu(void) 2624{ 2625 __be32 rval; 2626 ihandle prom_cpu; 2627 phandle cpu_pkg; 2628 2629 rval = 0; 2630 if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0) 2631 return; 2632 prom_cpu = be32_to_cpu(rval); 2633 2634 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); 2635 2636 prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval)); 2637 prom.cpu = be32_to_cpu(rval); 2638 2639 prom_debug("Booting CPU hw index = %lu\n", prom.cpu); 2640} 2641 2642static void __init prom_check_initrd(unsigned long r3, unsigned long r4) 2643{ 2644#ifdef CONFIG_BLK_DEV_INITRD 2645 if (r3 && r4 && r4 != 0xdeadbeef) { 2646 __be64 val; 2647 2648 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3; 2649 prom_initrd_end = prom_initrd_start + r4; 2650 2651 val = cpu_to_be64(prom_initrd_start); 2652 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start", 2653 &val, sizeof(val)); 2654 val = cpu_to_be64(prom_initrd_end); 2655 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end", 2656 &val, sizeof(val)); 2657 2658 reserve_mem(prom_initrd_start, 2659 prom_initrd_end - prom_initrd_start); 2660 2661 prom_debug("initrd_start=0x%x\n", prom_initrd_start); 2662 prom_debug("initrd_end=0x%x\n", prom_initrd_end); 2663 } 2664#endif /* CONFIG_BLK_DEV_INITRD */ 2665} 2666 2667#ifdef CONFIG_PPC64 2668#ifdef CONFIG_RELOCATABLE 2669static void reloc_toc(void) 2670{ 2671} 2672 2673static void unreloc_toc(void) 2674{ 2675} 2676#else 2677static void __reloc_toc(unsigned long offset, unsigned long nr_entries) 2678{ 2679 unsigned long i; 2680 unsigned long *toc_entry; 2681 2682 /* Get the start of the TOC by using r2 directly. */ 2683 asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry)); 2684 2685 for (i = 0; i < nr_entries; i++) { 2686 *toc_entry = *toc_entry + offset; 2687 toc_entry++; 2688 } 2689} 2690 2691static void reloc_toc(void) 2692{ 2693 unsigned long offset = reloc_offset(); 2694 unsigned long nr_entries = 2695 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 2696 2697 __reloc_toc(offset, nr_entries); 2698 2699 mb(); 2700} 2701 2702static void unreloc_toc(void) 2703{ 2704 unsigned long offset = reloc_offset(); 2705 unsigned long nr_entries = 2706 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 2707 2708 mb(); 2709 2710 __reloc_toc(-offset, nr_entries); 2711} 2712#endif 2713#endif 2714 2715/* 2716 * We enter here early on, when the Open Firmware prom is still 2717 * handling exceptions and the MMU hash table for us. 2718 */ 2719 2720unsigned long __init prom_init(unsigned long r3, unsigned long r4, 2721 unsigned long pp, 2722 unsigned long r6, unsigned long r7, 2723 unsigned long kbase) 2724{ 2725 unsigned long hdr; 2726 2727#ifdef CONFIG_PPC32 2728 unsigned long offset = reloc_offset(); 2729 reloc_got2(offset); 2730#else 2731 reloc_toc(); 2732#endif 2733 2734 /* 2735 * First zero the BSS 2736 */ 2737 memset(&__bss_start, 0, __bss_stop - __bss_start); 2738 2739 /* 2740 * Init interface to Open Firmware, get some node references, 2741 * like /chosen 2742 */ 2743 prom_init_client_services(pp); 2744 2745 /* 2746 * See if this OF is old enough that we need to do explicit maps 2747 * and other workarounds 2748 */ 2749 prom_find_mmu(); 2750 2751 /* 2752 * Init prom stdout device 2753 */ 2754 prom_init_stdout(); 2755 2756 prom_printf("Preparing to boot %s", linux_banner); 2757 2758 /* 2759 * Get default machine type. At this point, we do not differentiate 2760 * between pSeries SMP and pSeries LPAR 2761 */ 2762 of_platform = prom_find_machine_type(); 2763 prom_printf("Detected machine type: %x\n", of_platform); 2764 2765#ifndef CONFIG_NONSTATIC_KERNEL 2766 /* Bail if this is a kdump kernel. */ 2767 if (PHYSICAL_START > 0) 2768 prom_panic("Error: You can't boot a kdump kernel from OF!\n"); 2769#endif 2770 2771 /* 2772 * Check for an initrd 2773 */ 2774 prom_check_initrd(r3, r4); 2775 2776#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) 2777 /* 2778 * On pSeries, inform the firmware about our capabilities 2779 */ 2780 if (of_platform == PLATFORM_PSERIES || 2781 of_platform == PLATFORM_PSERIES_LPAR) 2782 prom_send_capabilities(); 2783#endif 2784 2785 /* 2786 * Copy the CPU hold code 2787 */ 2788 if (of_platform != PLATFORM_POWERMAC) 2789 copy_and_flush(0, kbase, 0x100, 0); 2790 2791 /* 2792 * Do early parsing of command line 2793 */ 2794 early_cmdline_parse(); 2795 2796 /* 2797 * Initialize memory management within prom_init 2798 */ 2799 prom_init_mem(); 2800 2801 /* 2802 * Determine which cpu is actually running right _now_ 2803 */ 2804 prom_find_boot_cpu(); 2805 2806 /* 2807 * Initialize display devices 2808 */ 2809 prom_check_displays(); 2810 2811#if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__) 2812 /* 2813 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else 2814 * that uses the allocator, we need to make sure we get the top of memory 2815 * available for us here... 2816 */ 2817 if (of_platform == PLATFORM_PSERIES) 2818 prom_initialize_tce_table(); 2819#endif 2820 2821 /* 2822 * On non-powermacs, try to instantiate RTAS. PowerMacs don't 2823 * have a usable RTAS implementation. 2824 */ 2825 if (of_platform != PLATFORM_POWERMAC && 2826 of_platform != PLATFORM_OPAL) 2827 prom_instantiate_rtas(); 2828 2829#ifdef CONFIG_PPC_POWERNV 2830 if (of_platform == PLATFORM_OPAL) 2831 prom_instantiate_opal(); 2832#endif /* CONFIG_PPC_POWERNV */ 2833 2834#ifdef CONFIG_PPC64 2835 /* instantiate sml */ 2836 prom_instantiate_sml(); 2837#endif 2838 2839 /* 2840 * On non-powermacs, put all CPUs in spin-loops. 2841 * 2842 * PowerMacs use a different mechanism to spin CPUs 2843 * 2844 * (This must be done after instanciating RTAS) 2845 */ 2846 if (of_platform != PLATFORM_POWERMAC && 2847 of_platform != PLATFORM_OPAL) 2848 prom_hold_cpus(); 2849 2850 /* 2851 * Fill in some infos for use by the kernel later on 2852 */ 2853 if (prom_memory_limit) { 2854 __be64 val = cpu_to_be64(prom_memory_limit); 2855 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit", 2856 &val, sizeof(val)); 2857 } 2858#ifdef CONFIG_PPC64 2859 if (prom_iommu_off) 2860 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off", 2861 NULL, 0); 2862 2863 if (prom_iommu_force_on) 2864 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on", 2865 NULL, 0); 2866 2867 if (prom_tce_alloc_start) { 2868 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start", 2869 &prom_tce_alloc_start, 2870 sizeof(prom_tce_alloc_start)); 2871 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end", 2872 &prom_tce_alloc_end, 2873 sizeof(prom_tce_alloc_end)); 2874 } 2875#endif 2876 2877 /* 2878 * Fixup any known bugs in the device-tree 2879 */ 2880 fixup_device_tree(); 2881 2882 /* 2883 * Now finally create the flattened device-tree 2884 */ 2885 prom_printf("copying OF device tree...\n"); 2886 flatten_device_tree(); 2887 2888 /* 2889 * in case stdin is USB and still active on IBM machines... 2890 * Unfortunately quiesce crashes on some powermacs if we have 2891 * closed stdin already (in particular the powerbook 101). It 2892 * appears that the OPAL version of OFW doesn't like it either. 2893 */ 2894 if (of_platform != PLATFORM_POWERMAC && 2895 of_platform != PLATFORM_OPAL) 2896 prom_close_stdin(); 2897 2898 /* 2899 * Call OF "quiesce" method to shut down pending DMA's from 2900 * devices etc... 2901 */ 2902 prom_printf("Quiescing Open Firmware ...\n"); 2903 call_prom("quiesce", 0, 0); 2904 2905 /* 2906 * And finally, call the kernel passing it the flattened device 2907 * tree and NULL as r5, thus triggering the new entry point which 2908 * is common to us and kexec 2909 */ 2910 hdr = dt_header_start; 2911 2912 /* Don't print anything after quiesce under OPAL, it crashes OFW */ 2913 if (of_platform != PLATFORM_OPAL) { 2914 prom_printf("Booting Linux via __start() ...\n"); 2915 prom_debug("->dt_header_start=0x%x\n", hdr); 2916 } 2917 2918#ifdef CONFIG_PPC32 2919 reloc_got2(-offset); 2920#else 2921 unreloc_toc(); 2922#endif 2923 2924#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 2925 /* OPAL early debug gets the OPAL base & entry in r8 and r9 */ 2926 __start(hdr, kbase, 0, 0, 0, 2927 prom_opal_base, prom_opal_entry); 2928#else 2929 __start(hdr, kbase, 0, 0, 0, 0, 0); 2930#endif 2931 2932 return 0; 2933} 2934