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