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