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