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 }, 878 879 /* option vector 6: IBM PAPR hints */ 880 .vec6_len = VECTOR_LENGTH(sizeof(struct option_vector6)), 881 .vec6 = { 882 .reserved = 0, 883 .secondary_pteg = 0, 884 .os_name = OV6_LINUX, 885 }, 886 }; 887 888 /* Old method - ELF header with PT_NOTE sections only works on BE */ 889 #ifdef __BIG_ENDIAN__ 890 static struct fake_elf { 891 Elf32_Ehdr elfhdr; 892 Elf32_Phdr phdr[2]; 893 struct chrpnote { 894 u32 namesz; 895 u32 descsz; 896 u32 type; 897 char name[8]; /* "PowerPC" */ 898 struct chrpdesc { 899 u32 real_mode; 900 u32 real_base; 901 u32 real_size; 902 u32 virt_base; 903 u32 virt_size; 904 u32 load_base; 905 } chrpdesc; 906 } chrpnote; 907 struct rpanote { 908 u32 namesz; 909 u32 descsz; 910 u32 type; 911 char name[24]; /* "IBM,RPA-Client-Config" */ 912 struct rpadesc { 913 u32 lpar_affinity; 914 u32 min_rmo_size; 915 u32 min_rmo_percent; 916 u32 max_pft_size; 917 u32 splpar; 918 u32 min_load; 919 u32 new_mem_def; 920 u32 ignore_me; 921 } rpadesc; 922 } rpanote; 923 } fake_elf = { 924 .elfhdr = { 925 .e_ident = { 0x7f, 'E', 'L', 'F', 926 ELFCLASS32, ELFDATA2MSB, EV_CURRENT }, 927 .e_type = ET_EXEC, /* yeah right */ 928 .e_machine = EM_PPC, 929 .e_version = EV_CURRENT, 930 .e_phoff = offsetof(struct fake_elf, phdr), 931 .e_phentsize = sizeof(Elf32_Phdr), 932 .e_phnum = 2 933 }, 934 .phdr = { 935 [0] = { 936 .p_type = PT_NOTE, 937 .p_offset = offsetof(struct fake_elf, chrpnote), 938 .p_filesz = sizeof(struct chrpnote) 939 }, [1] = { 940 .p_type = PT_NOTE, 941 .p_offset = offsetof(struct fake_elf, rpanote), 942 .p_filesz = sizeof(struct rpanote) 943 } 944 }, 945 .chrpnote = { 946 .namesz = sizeof("PowerPC"), 947 .descsz = sizeof(struct chrpdesc), 948 .type = 0x1275, 949 .name = "PowerPC", 950 .chrpdesc = { 951 .real_mode = ~0U, /* ~0 means "don't care" */ 952 .real_base = ~0U, 953 .real_size = ~0U, 954 .virt_base = ~0U, 955 .virt_size = ~0U, 956 .load_base = ~0U 957 }, 958 }, 959 .rpanote = { 960 .namesz = sizeof("IBM,RPA-Client-Config"), 961 .descsz = sizeof(struct rpadesc), 962 .type = 0x12759999, 963 .name = "IBM,RPA-Client-Config", 964 .rpadesc = { 965 .lpar_affinity = 0, 966 .min_rmo_size = 64, /* in megabytes */ 967 .min_rmo_percent = 0, 968 .max_pft_size = 48, /* 2^48 bytes max PFT size */ 969 .splpar = 1, 970 .min_load = ~0U, 971 .new_mem_def = 0 972 } 973 } 974 }; 975 #endif /* __BIG_ENDIAN__ */ 976 977 static int __init prom_count_smt_threads(void) 978 { 979 phandle node; 980 char type[64]; 981 unsigned int plen; 982 983 /* Pick up th first CPU node we can find */ 984 for (node = 0; prom_next_node(&node); ) { 985 type[0] = 0; 986 prom_getprop(node, "device_type", type, sizeof(type)); 987 988 if (strcmp(type, "cpu")) 989 continue; 990 /* 991 * There is an entry for each smt thread, each entry being 992 * 4 bytes long. All cpus should have the same number of 993 * smt threads, so return after finding the first. 994 */ 995 plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s"); 996 if (plen == PROM_ERROR) 997 break; 998 plen >>= 2; 999 prom_debug("Found %lu smt threads per core\n", (unsigned long)plen); 1000 1001 /* Sanity check */ 1002 if (plen < 1 || plen > 64) { 1003 prom_printf("Threads per core %lu out of bounds, assuming 1\n", 1004 (unsigned long)plen); 1005 return 1; 1006 } 1007 return plen; 1008 } 1009 prom_debug("No threads found, assuming 1 per core\n"); 1010 1011 return 1; 1012 1013 } 1014 1015 static void __init prom_parse_mmu_model(u8 val, 1016 struct platform_support *support) 1017 { 1018 switch (val) { 1019 case OV5_FEAT(OV5_MMU_DYNAMIC): 1020 case OV5_FEAT(OV5_MMU_EITHER): /* Either Available */ 1021 prom_debug("MMU - either supported\n"); 1022 support->radix_mmu = !prom_radix_disable; 1023 support->hash_mmu = true; 1024 break; 1025 case OV5_FEAT(OV5_MMU_RADIX): /* Only Radix */ 1026 prom_debug("MMU - radix only\n"); 1027 if (prom_radix_disable) { 1028 /* 1029 * If we __have__ to do radix, we're better off ignoring 1030 * the command line rather than not booting. 1031 */ 1032 prom_printf("WARNING: Ignoring cmdline option disable_radix\n"); 1033 } 1034 support->radix_mmu = true; 1035 break; 1036 case OV5_FEAT(OV5_MMU_HASH): 1037 prom_debug("MMU - hash only\n"); 1038 support->hash_mmu = true; 1039 break; 1040 default: 1041 prom_debug("Unknown mmu support option: 0x%x\n", val); 1042 break; 1043 } 1044 } 1045 1046 static void __init prom_parse_xive_model(u8 val, 1047 struct platform_support *support) 1048 { 1049 switch (val) { 1050 case OV5_FEAT(OV5_XIVE_EITHER): /* Either Available */ 1051 prom_debug("XIVE - either mode supported\n"); 1052 support->xive = true; 1053 break; 1054 case OV5_FEAT(OV5_XIVE_EXPLOIT): /* Only Exploitation mode */ 1055 prom_debug("XIVE - exploitation mode supported\n"); 1056 support->xive = true; 1057 break; 1058 case OV5_FEAT(OV5_XIVE_LEGACY): /* Only Legacy mode */ 1059 prom_debug("XIVE - legacy mode supported\n"); 1060 break; 1061 default: 1062 prom_debug("Unknown xive support option: 0x%x\n", val); 1063 break; 1064 } 1065 } 1066 1067 static void __init prom_parse_platform_support(u8 index, u8 val, 1068 struct platform_support *support) 1069 { 1070 switch (index) { 1071 case OV5_INDX(OV5_MMU_SUPPORT): /* MMU Model */ 1072 prom_parse_mmu_model(val & OV5_FEAT(OV5_MMU_SUPPORT), support); 1073 break; 1074 case OV5_INDX(OV5_RADIX_GTSE): /* Radix Extensions */ 1075 if (val & OV5_FEAT(OV5_RADIX_GTSE)) { 1076 prom_debug("Radix - GTSE supported\n"); 1077 support->radix_gtse = true; 1078 } 1079 break; 1080 case OV5_INDX(OV5_XIVE_SUPPORT): /* Interrupt mode */ 1081 prom_parse_xive_model(val & OV5_FEAT(OV5_XIVE_SUPPORT), 1082 support); 1083 break; 1084 } 1085 } 1086 1087 static void __init prom_check_platform_support(void) 1088 { 1089 struct platform_support supported = { 1090 .hash_mmu = false, 1091 .radix_mmu = false, 1092 .radix_gtse = false, 1093 .xive = false 1094 }; 1095 int prop_len = prom_getproplen(prom.chosen, 1096 "ibm,arch-vec-5-platform-support"); 1097 if (prop_len > 1) { 1098 int i; 1099 u8 vec[prop_len]; 1100 prom_debug("Found ibm,arch-vec-5-platform-support, len: %d\n", 1101 prop_len); 1102 prom_getprop(prom.chosen, "ibm,arch-vec-5-platform-support", 1103 &vec, sizeof(vec)); 1104 for (i = 0; i < prop_len; i += 2) { 1105 prom_debug("%d: index = 0x%x val = 0x%x\n", i / 2 1106 , vec[i] 1107 , vec[i + 1]); 1108 prom_parse_platform_support(vec[i], vec[i + 1], 1109 &supported); 1110 } 1111 } 1112 1113 if (supported.radix_mmu && supported.radix_gtse && 1114 IS_ENABLED(CONFIG_PPC_RADIX_MMU)) { 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 minsize = 4UL << 20; 1815 1816 /* Align to the greater of the align or size */ 1817 align = max(minalign, minsize); 1818 base = alloc_down(minsize, align, 1); 1819 if (base == 0) 1820 prom_panic("ERROR, cannot find space for TCE table.\n"); 1821 if (base < local_alloc_bottom) 1822 local_alloc_bottom = base; 1823 1824 /* It seems OF doesn't null-terminate the path :-( */ 1825 memset(path, 0, PROM_SCRATCH_SIZE); 1826 /* Call OF to setup the TCE hardware */ 1827 if (call_prom("package-to-path", 3, 1, node, 1828 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) { 1829 prom_printf("package-to-path failed\n"); 1830 } 1831 1832 /* Save away the TCE table attributes for later use. */ 1833 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base)); 1834 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize)); 1835 1836 prom_debug("TCE table: %s\n", path); 1837 prom_debug("\tnode = 0x%x\n", node); 1838 prom_debug("\tbase = 0x%x\n", base); 1839 prom_debug("\tsize = 0x%x\n", minsize); 1840 1841 /* Initialize the table to have a one-to-one mapping 1842 * over the allocated size. 1843 */ 1844 tce_entryp = (u64 *)base; 1845 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) { 1846 tce_entry = (i << PAGE_SHIFT); 1847 tce_entry |= 0x3; 1848 *tce_entryp = tce_entry; 1849 } 1850 1851 prom_printf("opening PHB %s", path); 1852 phb_node = call_prom("open", 1, 1, path); 1853 if (phb_node == 0) 1854 prom_printf("... failed\n"); 1855 else 1856 prom_printf("... done\n"); 1857 1858 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"), 1859 phb_node, -1, minsize, 1860 (u32) base, (u32) (base >> 32)); 1861 call_prom("close", 1, 0, phb_node); 1862 } 1863 1864 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom); 1865 1866 /* These are only really needed if there is a memory limit in 1867 * effect, but we don't know so export them always. */ 1868 prom_tce_alloc_start = local_alloc_bottom; 1869 prom_tce_alloc_end = local_alloc_top; 1870 1871 /* Flag the first invalid entry */ 1872 prom_debug("ending prom_initialize_tce_table\n"); 1873 } 1874 #endif /* __BIG_ENDIAN__ */ 1875 #endif /* CONFIG_PPC64 */ 1876 1877 /* 1878 * With CHRP SMP we need to use the OF to start the other processors. 1879 * We can't wait until smp_boot_cpus (the OF is trashed by then) 1880 * so we have to put the processors into a holding pattern controlled 1881 * by the kernel (not OF) before we destroy the OF. 1882 * 1883 * This uses a chunk of low memory, puts some holding pattern 1884 * code there and sends the other processors off to there until 1885 * smp_boot_cpus tells them to do something. The holding pattern 1886 * checks that address until its cpu # is there, when it is that 1887 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care 1888 * of setting those values. 1889 * 1890 * We also use physical address 0x4 here to tell when a cpu 1891 * is in its holding pattern code. 1892 * 1893 * -- Cort 1894 */ 1895 /* 1896 * We want to reference the copy of __secondary_hold_* in the 1897 * 0 - 0x100 address range 1898 */ 1899 #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff) 1900 1901 static void __init prom_hold_cpus(void) 1902 { 1903 unsigned long i; 1904 phandle node; 1905 char type[64]; 1906 unsigned long *spinloop 1907 = (void *) LOW_ADDR(__secondary_hold_spinloop); 1908 unsigned long *acknowledge 1909 = (void *) LOW_ADDR(__secondary_hold_acknowledge); 1910 unsigned long secondary_hold = LOW_ADDR(__secondary_hold); 1911 1912 /* 1913 * On pseries, if RTAS supports "query-cpu-stopped-state", 1914 * we skip this stage, the CPUs will be started by the 1915 * kernel using RTAS. 1916 */ 1917 if ((of_platform == PLATFORM_PSERIES || 1918 of_platform == PLATFORM_PSERIES_LPAR) && 1919 rtas_has_query_cpu_stopped) { 1920 prom_printf("prom_hold_cpus: skipped\n"); 1921 return; 1922 } 1923 1924 prom_debug("prom_hold_cpus: start...\n"); 1925 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop); 1926 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop); 1927 prom_debug(" 1) acknowledge = 0x%x\n", 1928 (unsigned long)acknowledge); 1929 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge); 1930 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold); 1931 1932 /* Set the common spinloop variable, so all of the secondary cpus 1933 * will block when they are awakened from their OF spinloop. 1934 * This must occur for both SMP and non SMP kernels, since OF will 1935 * be trashed when we move the kernel. 1936 */ 1937 *spinloop = 0; 1938 1939 /* look for cpus */ 1940 for (node = 0; prom_next_node(&node); ) { 1941 unsigned int cpu_no; 1942 __be32 reg; 1943 1944 type[0] = 0; 1945 prom_getprop(node, "device_type", type, sizeof(type)); 1946 if (strcmp(type, "cpu") != 0) 1947 continue; 1948 1949 /* Skip non-configured cpus. */ 1950 if (prom_getprop(node, "status", type, sizeof(type)) > 0) 1951 if (strcmp(type, "okay") != 0) 1952 continue; 1953 1954 reg = cpu_to_be32(-1); /* make sparse happy */ 1955 prom_getprop(node, "reg", ®, sizeof(reg)); 1956 cpu_no = be32_to_cpu(reg); 1957 1958 prom_debug("cpu hw idx = %lu\n", cpu_no); 1959 1960 /* Init the acknowledge var which will be reset by 1961 * the secondary cpu when it awakens from its OF 1962 * spinloop. 1963 */ 1964 *acknowledge = (unsigned long)-1; 1965 1966 if (cpu_no != prom.cpu) { 1967 /* Primary Thread of non-boot cpu or any thread */ 1968 prom_printf("starting cpu hw idx %lu... ", cpu_no); 1969 call_prom("start-cpu", 3, 0, node, 1970 secondary_hold, cpu_no); 1971 1972 for (i = 0; (i < 100000000) && 1973 (*acknowledge == ((unsigned long)-1)); i++ ) 1974 mb(); 1975 1976 if (*acknowledge == cpu_no) 1977 prom_printf("done\n"); 1978 else 1979 prom_printf("failed: %x\n", *acknowledge); 1980 } 1981 #ifdef CONFIG_SMP 1982 else 1983 prom_printf("boot cpu hw idx %lu\n", cpu_no); 1984 #endif /* CONFIG_SMP */ 1985 } 1986 1987 prom_debug("prom_hold_cpus: end...\n"); 1988 } 1989 1990 1991 static void __init prom_init_client_services(unsigned long pp) 1992 { 1993 /* Get a handle to the prom entry point before anything else */ 1994 prom_entry = pp; 1995 1996 /* get a handle for the stdout device */ 1997 prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen")); 1998 if (!PHANDLE_VALID(prom.chosen)) 1999 prom_panic("cannot find chosen"); /* msg won't be printed :( */ 2000 2001 /* get device tree root */ 2002 prom.root = call_prom("finddevice", 1, 1, ADDR("/")); 2003 if (!PHANDLE_VALID(prom.root)) 2004 prom_panic("cannot find device tree root"); /* msg won't be printed :( */ 2005 2006 prom.mmumap = 0; 2007 } 2008 2009 #ifdef CONFIG_PPC32 2010 /* 2011 * For really old powermacs, we need to map things we claim. 2012 * For that, we need the ihandle of the mmu. 2013 * Also, on the longtrail, we need to work around other bugs. 2014 */ 2015 static void __init prom_find_mmu(void) 2016 { 2017 phandle oprom; 2018 char version[64]; 2019 2020 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom")); 2021 if (!PHANDLE_VALID(oprom)) 2022 return; 2023 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0) 2024 return; 2025 version[sizeof(version) - 1] = 0; 2026 /* XXX might need to add other versions here */ 2027 if (strcmp(version, "Open Firmware, 1.0.5") == 0) 2028 of_workarounds = OF_WA_CLAIM; 2029 else if (strncmp(version, "FirmWorks,3.", 12) == 0) { 2030 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL; 2031 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim"); 2032 } else 2033 return; 2034 prom.memory = call_prom("open", 1, 1, ADDR("/memory")); 2035 prom_getprop(prom.chosen, "mmu", &prom.mmumap, 2036 sizeof(prom.mmumap)); 2037 prom.mmumap = be32_to_cpu(prom.mmumap); 2038 if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap)) 2039 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */ 2040 } 2041 #else 2042 #define prom_find_mmu() 2043 #endif 2044 2045 static void __init prom_init_stdout(void) 2046 { 2047 char *path = of_stdout_device; 2048 char type[16]; 2049 phandle stdout_node; 2050 __be32 val; 2051 2052 if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0) 2053 prom_panic("cannot find stdout"); 2054 2055 prom.stdout = be32_to_cpu(val); 2056 2057 /* Get the full OF pathname of the stdout device */ 2058 memset(path, 0, 256); 2059 call_prom("instance-to-path", 3, 1, prom.stdout, path, 255); 2060 prom_printf("OF stdout device is: %s\n", of_stdout_device); 2061 prom_setprop(prom.chosen, "/chosen", "linux,stdout-path", 2062 path, strlen(path) + 1); 2063 2064 /* instance-to-package fails on PA-Semi */ 2065 stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout); 2066 if (stdout_node != PROM_ERROR) { 2067 val = cpu_to_be32(stdout_node); 2068 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package", 2069 &val, sizeof(val)); 2070 2071 /* If it's a display, note it */ 2072 memset(type, 0, sizeof(type)); 2073 prom_getprop(stdout_node, "device_type", type, sizeof(type)); 2074 if (strcmp(type, "display") == 0) 2075 prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0); 2076 } 2077 } 2078 2079 static int __init prom_find_machine_type(void) 2080 { 2081 char compat[256]; 2082 int len, i = 0; 2083 #ifdef CONFIG_PPC64 2084 phandle rtas; 2085 int x; 2086 #endif 2087 2088 /* Look for a PowerMac or a Cell */ 2089 len = prom_getprop(prom.root, "compatible", 2090 compat, sizeof(compat)-1); 2091 if (len > 0) { 2092 compat[len] = 0; 2093 while (i < len) { 2094 char *p = &compat[i]; 2095 int sl = strlen(p); 2096 if (sl == 0) 2097 break; 2098 if (strstr(p, "Power Macintosh") || 2099 strstr(p, "MacRISC")) 2100 return PLATFORM_POWERMAC; 2101 #ifdef CONFIG_PPC64 2102 /* We must make sure we don't detect the IBM Cell 2103 * blades as pSeries due to some firmware issues, 2104 * so we do it here. 2105 */ 2106 if (strstr(p, "IBM,CBEA") || 2107 strstr(p, "IBM,CPBW-1.0")) 2108 return PLATFORM_GENERIC; 2109 #endif /* CONFIG_PPC64 */ 2110 i += sl + 1; 2111 } 2112 } 2113 #ifdef CONFIG_PPC64 2114 /* Try to detect OPAL */ 2115 if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal")))) 2116 return PLATFORM_OPAL; 2117 2118 /* Try to figure out if it's an IBM pSeries or any other 2119 * PAPR compliant platform. We assume it is if : 2120 * - /device_type is "chrp" (please, do NOT use that for future 2121 * non-IBM designs ! 2122 * - it has /rtas 2123 */ 2124 len = prom_getprop(prom.root, "device_type", 2125 compat, sizeof(compat)-1); 2126 if (len <= 0) 2127 return PLATFORM_GENERIC; 2128 if (strcmp(compat, "chrp")) 2129 return PLATFORM_GENERIC; 2130 2131 /* Default to pSeries. We need to know if we are running LPAR */ 2132 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas")); 2133 if (!PHANDLE_VALID(rtas)) 2134 return PLATFORM_GENERIC; 2135 x = prom_getproplen(rtas, "ibm,hypertas-functions"); 2136 if (x != PROM_ERROR) { 2137 prom_debug("Hypertas detected, assuming LPAR !\n"); 2138 return PLATFORM_PSERIES_LPAR; 2139 } 2140 return PLATFORM_PSERIES; 2141 #else 2142 return PLATFORM_GENERIC; 2143 #endif 2144 } 2145 2146 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b) 2147 { 2148 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r); 2149 } 2150 2151 /* 2152 * If we have a display that we don't know how to drive, 2153 * we will want to try to execute OF's open method for it 2154 * later. However, OF will probably fall over if we do that 2155 * we've taken over the MMU. 2156 * So we check whether we will need to open the display, 2157 * and if so, open it now. 2158 */ 2159 static void __init prom_check_displays(void) 2160 { 2161 char type[16], *path; 2162 phandle node; 2163 ihandle ih; 2164 int i; 2165 2166 static unsigned char default_colors[] = { 2167 0x00, 0x00, 0x00, 2168 0x00, 0x00, 0xaa, 2169 0x00, 0xaa, 0x00, 2170 0x00, 0xaa, 0xaa, 2171 0xaa, 0x00, 0x00, 2172 0xaa, 0x00, 0xaa, 2173 0xaa, 0xaa, 0x00, 2174 0xaa, 0xaa, 0xaa, 2175 0x55, 0x55, 0x55, 2176 0x55, 0x55, 0xff, 2177 0x55, 0xff, 0x55, 2178 0x55, 0xff, 0xff, 2179 0xff, 0x55, 0x55, 2180 0xff, 0x55, 0xff, 2181 0xff, 0xff, 0x55, 2182 0xff, 0xff, 0xff 2183 }; 2184 const unsigned char *clut; 2185 2186 prom_debug("Looking for displays\n"); 2187 for (node = 0; prom_next_node(&node); ) { 2188 memset(type, 0, sizeof(type)); 2189 prom_getprop(node, "device_type", type, sizeof(type)); 2190 if (strcmp(type, "display") != 0) 2191 continue; 2192 2193 /* It seems OF doesn't null-terminate the path :-( */ 2194 path = prom_scratch; 2195 memset(path, 0, PROM_SCRATCH_SIZE); 2196 2197 /* 2198 * leave some room at the end of the path for appending extra 2199 * arguments 2200 */ 2201 if (call_prom("package-to-path", 3, 1, node, path, 2202 PROM_SCRATCH_SIZE-10) == PROM_ERROR) 2203 continue; 2204 prom_printf("found display : %s, opening... ", path); 2205 2206 ih = call_prom("open", 1, 1, path); 2207 if (ih == 0) { 2208 prom_printf("failed\n"); 2209 continue; 2210 } 2211 2212 /* Success */ 2213 prom_printf("done\n"); 2214 prom_setprop(node, path, "linux,opened", NULL, 0); 2215 2216 /* Setup a usable color table when the appropriate 2217 * method is available. Should update this to set-colors */ 2218 clut = default_colors; 2219 for (i = 0; i < 16; i++, clut += 3) 2220 if (prom_set_color(ih, i, clut[0], clut[1], 2221 clut[2]) != 0) 2222 break; 2223 2224 #ifdef CONFIG_LOGO_LINUX_CLUT224 2225 clut = PTRRELOC(logo_linux_clut224.clut); 2226 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3) 2227 if (prom_set_color(ih, i + 32, clut[0], clut[1], 2228 clut[2]) != 0) 2229 break; 2230 #endif /* CONFIG_LOGO_LINUX_CLUT224 */ 2231 2232 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX 2233 if (prom_getprop(node, "linux,boot-display", NULL, 0) != 2234 PROM_ERROR) { 2235 u32 width, height, pitch, addr; 2236 2237 prom_printf("Setting btext !\n"); 2238 prom_getprop(node, "width", &width, 4); 2239 prom_getprop(node, "height", &height, 4); 2240 prom_getprop(node, "linebytes", &pitch, 4); 2241 prom_getprop(node, "address", &addr, 4); 2242 prom_printf("W=%d H=%d LB=%d addr=0x%x\n", 2243 width, height, pitch, addr); 2244 btext_setup_display(width, height, 8, pitch, addr); 2245 } 2246 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */ 2247 } 2248 } 2249 2250 2251 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */ 2252 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end, 2253 unsigned long needed, unsigned long align) 2254 { 2255 void *ret; 2256 2257 *mem_start = _ALIGN(*mem_start, align); 2258 while ((*mem_start + needed) > *mem_end) { 2259 unsigned long room, chunk; 2260 2261 prom_debug("Chunk exhausted, claiming more at %x...\n", 2262 alloc_bottom); 2263 room = alloc_top - alloc_bottom; 2264 if (room > DEVTREE_CHUNK_SIZE) 2265 room = DEVTREE_CHUNK_SIZE; 2266 if (room < PAGE_SIZE) 2267 prom_panic("No memory for flatten_device_tree " 2268 "(no room)\n"); 2269 chunk = alloc_up(room, 0); 2270 if (chunk == 0) 2271 prom_panic("No memory for flatten_device_tree " 2272 "(claim failed)\n"); 2273 *mem_end = chunk + room; 2274 } 2275 2276 ret = (void *)*mem_start; 2277 *mem_start += needed; 2278 2279 return ret; 2280 } 2281 2282 #define dt_push_token(token, mem_start, mem_end) do { \ 2283 void *room = make_room(mem_start, mem_end, 4, 4); \ 2284 *(__be32 *)room = cpu_to_be32(token); \ 2285 } while(0) 2286 2287 static unsigned long __init dt_find_string(char *str) 2288 { 2289 char *s, *os; 2290 2291 s = os = (char *)dt_string_start; 2292 s += 4; 2293 while (s < (char *)dt_string_end) { 2294 if (strcmp(s, str) == 0) 2295 return s - os; 2296 s += strlen(s) + 1; 2297 } 2298 return 0; 2299 } 2300 2301 /* 2302 * The Open Firmware 1275 specification states properties must be 31 bytes or 2303 * less, however not all firmwares obey this. Make it 64 bytes to be safe. 2304 */ 2305 #define MAX_PROPERTY_NAME 64 2306 2307 static void __init scan_dt_build_strings(phandle node, 2308 unsigned long *mem_start, 2309 unsigned long *mem_end) 2310 { 2311 char *prev_name, *namep, *sstart; 2312 unsigned long soff; 2313 phandle child; 2314 2315 sstart = (char *)dt_string_start; 2316 2317 /* get and store all property names */ 2318 prev_name = ""; 2319 for (;;) { 2320 /* 64 is max len of name including nul. */ 2321 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1); 2322 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) { 2323 /* No more nodes: unwind alloc */ 2324 *mem_start = (unsigned long)namep; 2325 break; 2326 } 2327 2328 /* skip "name" */ 2329 if (strcmp(namep, "name") == 0) { 2330 *mem_start = (unsigned long)namep; 2331 prev_name = "name"; 2332 continue; 2333 } 2334 /* get/create string entry */ 2335 soff = dt_find_string(namep); 2336 if (soff != 0) { 2337 *mem_start = (unsigned long)namep; 2338 namep = sstart + soff; 2339 } else { 2340 /* Trim off some if we can */ 2341 *mem_start = (unsigned long)namep + strlen(namep) + 1; 2342 dt_string_end = *mem_start; 2343 } 2344 prev_name = namep; 2345 } 2346 2347 /* do all our children */ 2348 child = call_prom("child", 1, 1, node); 2349 while (child != 0) { 2350 scan_dt_build_strings(child, mem_start, mem_end); 2351 child = call_prom("peer", 1, 1, child); 2352 } 2353 } 2354 2355 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start, 2356 unsigned long *mem_end) 2357 { 2358 phandle child; 2359 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path; 2360 unsigned long soff; 2361 unsigned char *valp; 2362 static char pname[MAX_PROPERTY_NAME]; 2363 int l, room, has_phandle = 0; 2364 2365 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end); 2366 2367 /* get the node's full name */ 2368 namep = (char *)*mem_start; 2369 room = *mem_end - *mem_start; 2370 if (room > 255) 2371 room = 255; 2372 l = call_prom("package-to-path", 3, 1, node, namep, room); 2373 if (l >= 0) { 2374 /* Didn't fit? Get more room. */ 2375 if (l >= room) { 2376 if (l >= *mem_end - *mem_start) 2377 namep = make_room(mem_start, mem_end, l+1, 1); 2378 call_prom("package-to-path", 3, 1, node, namep, l); 2379 } 2380 namep[l] = '\0'; 2381 2382 /* Fixup an Apple bug where they have bogus \0 chars in the 2383 * middle of the path in some properties, and extract 2384 * the unit name (everything after the last '/'). 2385 */ 2386 for (lp = p = namep, ep = namep + l; p < ep; p++) { 2387 if (*p == '/') 2388 lp = namep; 2389 else if (*p != 0) 2390 *lp++ = *p; 2391 } 2392 *lp = 0; 2393 *mem_start = _ALIGN((unsigned long)lp + 1, 4); 2394 } 2395 2396 /* get it again for debugging */ 2397 path = prom_scratch; 2398 memset(path, 0, PROM_SCRATCH_SIZE); 2399 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 2400 2401 /* get and store all properties */ 2402 prev_name = ""; 2403 sstart = (char *)dt_string_start; 2404 for (;;) { 2405 if (call_prom("nextprop", 3, 1, node, prev_name, 2406 pname) != 1) 2407 break; 2408 2409 /* skip "name" */ 2410 if (strcmp(pname, "name") == 0) { 2411 prev_name = "name"; 2412 continue; 2413 } 2414 2415 /* find string offset */ 2416 soff = dt_find_string(pname); 2417 if (soff == 0) { 2418 prom_printf("WARNING: Can't find string index for" 2419 " <%s>, node %s\n", pname, path); 2420 break; 2421 } 2422 prev_name = sstart + soff; 2423 2424 /* get length */ 2425 l = call_prom("getproplen", 2, 1, node, pname); 2426 2427 /* sanity checks */ 2428 if (l == PROM_ERROR) 2429 continue; 2430 2431 /* push property head */ 2432 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2433 dt_push_token(l, mem_start, mem_end); 2434 dt_push_token(soff, mem_start, mem_end); 2435 2436 /* push property content */ 2437 valp = make_room(mem_start, mem_end, l, 4); 2438 call_prom("getprop", 4, 1, node, pname, valp, l); 2439 *mem_start = _ALIGN(*mem_start, 4); 2440 2441 if (!strcmp(pname, "phandle")) 2442 has_phandle = 1; 2443 } 2444 2445 /* Add a "linux,phandle" property if no "phandle" property already 2446 * existed (can happen with OPAL) 2447 */ 2448 if (!has_phandle) { 2449 soff = dt_find_string("linux,phandle"); 2450 if (soff == 0) 2451 prom_printf("WARNING: Can't find string index for" 2452 " <linux-phandle> node %s\n", path); 2453 else { 2454 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2455 dt_push_token(4, mem_start, mem_end); 2456 dt_push_token(soff, mem_start, mem_end); 2457 valp = make_room(mem_start, mem_end, 4, 4); 2458 *(__be32 *)valp = cpu_to_be32(node); 2459 } 2460 } 2461 2462 /* do all our children */ 2463 child = call_prom("child", 1, 1, node); 2464 while (child != 0) { 2465 scan_dt_build_struct(child, mem_start, mem_end); 2466 child = call_prom("peer", 1, 1, child); 2467 } 2468 2469 dt_push_token(OF_DT_END_NODE, mem_start, mem_end); 2470 } 2471 2472 static void __init flatten_device_tree(void) 2473 { 2474 phandle root; 2475 unsigned long mem_start, mem_end, room; 2476 struct boot_param_header *hdr; 2477 char *namep; 2478 u64 *rsvmap; 2479 2480 /* 2481 * Check how much room we have between alloc top & bottom (+/- a 2482 * few pages), crop to 1MB, as this is our "chunk" size 2483 */ 2484 room = alloc_top - alloc_bottom - 0x4000; 2485 if (room > DEVTREE_CHUNK_SIZE) 2486 room = DEVTREE_CHUNK_SIZE; 2487 prom_debug("starting device tree allocs at %x\n", alloc_bottom); 2488 2489 /* Now try to claim that */ 2490 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE); 2491 if (mem_start == 0) 2492 prom_panic("Can't allocate initial device-tree chunk\n"); 2493 mem_end = mem_start + room; 2494 2495 /* Get root of tree */ 2496 root = call_prom("peer", 1, 1, (phandle)0); 2497 if (root == (phandle)0) 2498 prom_panic ("couldn't get device tree root\n"); 2499 2500 /* Build header and make room for mem rsv map */ 2501 mem_start = _ALIGN(mem_start, 4); 2502 hdr = make_room(&mem_start, &mem_end, 2503 sizeof(struct boot_param_header), 4); 2504 dt_header_start = (unsigned long)hdr; 2505 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8); 2506 2507 /* Start of strings */ 2508 mem_start = PAGE_ALIGN(mem_start); 2509 dt_string_start = mem_start; 2510 mem_start += 4; /* hole */ 2511 2512 /* Add "linux,phandle" in there, we'll need it */ 2513 namep = make_room(&mem_start, &mem_end, 16, 1); 2514 strcpy(namep, "linux,phandle"); 2515 mem_start = (unsigned long)namep + strlen(namep) + 1; 2516 2517 /* Build string array */ 2518 prom_printf("Building dt strings...\n"); 2519 scan_dt_build_strings(root, &mem_start, &mem_end); 2520 dt_string_end = mem_start; 2521 2522 /* Build structure */ 2523 mem_start = PAGE_ALIGN(mem_start); 2524 dt_struct_start = mem_start; 2525 prom_printf("Building dt structure...\n"); 2526 scan_dt_build_struct(root, &mem_start, &mem_end); 2527 dt_push_token(OF_DT_END, &mem_start, &mem_end); 2528 dt_struct_end = PAGE_ALIGN(mem_start); 2529 2530 /* Finish header */ 2531 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu); 2532 hdr->magic = cpu_to_be32(OF_DT_HEADER); 2533 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start); 2534 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start); 2535 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start); 2536 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start); 2537 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start); 2538 hdr->version = cpu_to_be32(OF_DT_VERSION); 2539 /* Version 16 is not backward compatible */ 2540 hdr->last_comp_version = cpu_to_be32(0x10); 2541 2542 /* Copy the reserve map in */ 2543 memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map)); 2544 2545 #ifdef DEBUG_PROM 2546 { 2547 int i; 2548 prom_printf("reserved memory map:\n"); 2549 for (i = 0; i < mem_reserve_cnt; i++) 2550 prom_printf(" %x - %x\n", 2551 be64_to_cpu(mem_reserve_map[i].base), 2552 be64_to_cpu(mem_reserve_map[i].size)); 2553 } 2554 #endif 2555 /* Bump mem_reserve_cnt to cause further reservations to fail 2556 * since it's too late. 2557 */ 2558 mem_reserve_cnt = MEM_RESERVE_MAP_SIZE; 2559 2560 prom_printf("Device tree strings 0x%x -> 0x%x\n", 2561 dt_string_start, dt_string_end); 2562 prom_printf("Device tree struct 0x%x -> 0x%x\n", 2563 dt_struct_start, dt_struct_end); 2564 } 2565 2566 #ifdef CONFIG_PPC_MAPLE 2567 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property. 2568 * The values are bad, and it doesn't even have the right number of cells. */ 2569 static void __init fixup_device_tree_maple(void) 2570 { 2571 phandle isa; 2572 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */ 2573 u32 isa_ranges[6]; 2574 char *name; 2575 2576 name = "/ht@0/isa@4"; 2577 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2578 if (!PHANDLE_VALID(isa)) { 2579 name = "/ht@0/isa@6"; 2580 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2581 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2582 } 2583 if (!PHANDLE_VALID(isa)) 2584 return; 2585 2586 if (prom_getproplen(isa, "ranges") != 12) 2587 return; 2588 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges)) 2589 == PROM_ERROR) 2590 return; 2591 2592 if (isa_ranges[0] != 0x1 || 2593 isa_ranges[1] != 0xf4000000 || 2594 isa_ranges[2] != 0x00010000) 2595 return; 2596 2597 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n"); 2598 2599 isa_ranges[0] = 0x1; 2600 isa_ranges[1] = 0x0; 2601 isa_ranges[2] = rloc; 2602 isa_ranges[3] = 0x0; 2603 isa_ranges[4] = 0x0; 2604 isa_ranges[5] = 0x00010000; 2605 prom_setprop(isa, name, "ranges", 2606 isa_ranges, sizeof(isa_ranges)); 2607 } 2608 2609 #define CPC925_MC_START 0xf8000000 2610 #define CPC925_MC_LENGTH 0x1000000 2611 /* The values for memory-controller don't have right number of cells */ 2612 static void __init fixup_device_tree_maple_memory_controller(void) 2613 { 2614 phandle mc; 2615 u32 mc_reg[4]; 2616 char *name = "/hostbridge@f8000000"; 2617 u32 ac, sc; 2618 2619 mc = call_prom("finddevice", 1, 1, ADDR(name)); 2620 if (!PHANDLE_VALID(mc)) 2621 return; 2622 2623 if (prom_getproplen(mc, "reg") != 8) 2624 return; 2625 2626 prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac)); 2627 prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc)); 2628 if ((ac != 2) || (sc != 2)) 2629 return; 2630 2631 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR) 2632 return; 2633 2634 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH) 2635 return; 2636 2637 prom_printf("Fixing up bogus hostbridge on Maple...\n"); 2638 2639 mc_reg[0] = 0x0; 2640 mc_reg[1] = CPC925_MC_START; 2641 mc_reg[2] = 0x0; 2642 mc_reg[3] = CPC925_MC_LENGTH; 2643 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg)); 2644 } 2645 #else 2646 #define fixup_device_tree_maple() 2647 #define fixup_device_tree_maple_memory_controller() 2648 #endif 2649 2650 #ifdef CONFIG_PPC_CHRP 2651 /* 2652 * Pegasos and BriQ lacks the "ranges" property in the isa node 2653 * Pegasos needs decimal IRQ 14/15, not hexadecimal 2654 * Pegasos has the IDE configured in legacy mode, but advertised as native 2655 */ 2656 static void __init fixup_device_tree_chrp(void) 2657 { 2658 phandle ph; 2659 u32 prop[6]; 2660 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */ 2661 char *name; 2662 int rc; 2663 2664 name = "/pci@80000000/isa@c"; 2665 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2666 if (!PHANDLE_VALID(ph)) { 2667 name = "/pci@ff500000/isa@6"; 2668 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2669 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2670 } 2671 if (PHANDLE_VALID(ph)) { 2672 rc = prom_getproplen(ph, "ranges"); 2673 if (rc == 0 || rc == PROM_ERROR) { 2674 prom_printf("Fixing up missing ISA range on Pegasos...\n"); 2675 2676 prop[0] = 0x1; 2677 prop[1] = 0x0; 2678 prop[2] = rloc; 2679 prop[3] = 0x0; 2680 prop[4] = 0x0; 2681 prop[5] = 0x00010000; 2682 prom_setprop(ph, name, "ranges", prop, sizeof(prop)); 2683 } 2684 } 2685 2686 name = "/pci@80000000/ide@C,1"; 2687 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2688 if (PHANDLE_VALID(ph)) { 2689 prom_printf("Fixing up IDE interrupt on Pegasos...\n"); 2690 prop[0] = 14; 2691 prop[1] = 0x0; 2692 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32)); 2693 prom_printf("Fixing up IDE class-code on Pegasos...\n"); 2694 rc = prom_getprop(ph, "class-code", prop, sizeof(u32)); 2695 if (rc == sizeof(u32)) { 2696 prop[0] &= ~0x5; 2697 prom_setprop(ph, name, "class-code", prop, sizeof(u32)); 2698 } 2699 } 2700 } 2701 #else 2702 #define fixup_device_tree_chrp() 2703 #endif 2704 2705 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC) 2706 static void __init fixup_device_tree_pmac(void) 2707 { 2708 phandle u3, i2c, mpic; 2709 u32 u3_rev; 2710 u32 interrupts[2]; 2711 u32 parent; 2712 2713 /* Some G5s have a missing interrupt definition, fix it up here */ 2714 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000")); 2715 if (!PHANDLE_VALID(u3)) 2716 return; 2717 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000")); 2718 if (!PHANDLE_VALID(i2c)) 2719 return; 2720 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000")); 2721 if (!PHANDLE_VALID(mpic)) 2722 return; 2723 2724 /* check if proper rev of u3 */ 2725 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev)) 2726 == PROM_ERROR) 2727 return; 2728 if (u3_rev < 0x35 || u3_rev > 0x39) 2729 return; 2730 /* does it need fixup ? */ 2731 if (prom_getproplen(i2c, "interrupts") > 0) 2732 return; 2733 2734 prom_printf("fixing up bogus interrupts for u3 i2c...\n"); 2735 2736 /* interrupt on this revision of u3 is number 0 and level */ 2737 interrupts[0] = 0; 2738 interrupts[1] = 1; 2739 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts", 2740 &interrupts, sizeof(interrupts)); 2741 parent = (u32)mpic; 2742 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent", 2743 &parent, sizeof(parent)); 2744 } 2745 #else 2746 #define fixup_device_tree_pmac() 2747 #endif 2748 2749 #ifdef CONFIG_PPC_EFIKA 2750 /* 2751 * The MPC5200 FEC driver requires an phy-handle property to tell it how 2752 * to talk to the phy. If the phy-handle property is missing, then this 2753 * function is called to add the appropriate nodes and link it to the 2754 * ethernet node. 2755 */ 2756 static void __init fixup_device_tree_efika_add_phy(void) 2757 { 2758 u32 node; 2759 char prop[64]; 2760 int rv; 2761 2762 /* Check if /builtin/ethernet exists - bail if it doesn't */ 2763 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet")); 2764 if (!PHANDLE_VALID(node)) 2765 return; 2766 2767 /* Check if the phy-handle property exists - bail if it does */ 2768 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop)); 2769 if (!rv) 2770 return; 2771 2772 /* 2773 * At this point the ethernet device doesn't have a phy described. 2774 * Now we need to add the missing phy node and linkage 2775 */ 2776 2777 /* Check for an MDIO bus node - if missing then create one */ 2778 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio")); 2779 if (!PHANDLE_VALID(node)) { 2780 prom_printf("Adding Ethernet MDIO node\n"); 2781 call_prom("interpret", 1, 1, 2782 " s\" /builtin\" find-device" 2783 " new-device" 2784 " 1 encode-int s\" #address-cells\" property" 2785 " 0 encode-int s\" #size-cells\" property" 2786 " s\" mdio\" device-name" 2787 " s\" fsl,mpc5200b-mdio\" encode-string" 2788 " s\" compatible\" property" 2789 " 0xf0003000 0x400 reg" 2790 " 0x2 encode-int" 2791 " 0x5 encode-int encode+" 2792 " 0x3 encode-int encode+" 2793 " s\" interrupts\" property" 2794 " finish-device"); 2795 }; 2796 2797 /* Check for a PHY device node - if missing then create one and 2798 * give it's phandle to the ethernet node */ 2799 node = call_prom("finddevice", 1, 1, 2800 ADDR("/builtin/mdio/ethernet-phy")); 2801 if (!PHANDLE_VALID(node)) { 2802 prom_printf("Adding Ethernet PHY node\n"); 2803 call_prom("interpret", 1, 1, 2804 " s\" /builtin/mdio\" find-device" 2805 " new-device" 2806 " s\" ethernet-phy\" device-name" 2807 " 0x10 encode-int s\" reg\" property" 2808 " my-self" 2809 " ihandle>phandle" 2810 " finish-device" 2811 " s\" /builtin/ethernet\" find-device" 2812 " encode-int" 2813 " s\" phy-handle\" property" 2814 " device-end"); 2815 } 2816 } 2817 2818 static void __init fixup_device_tree_efika(void) 2819 { 2820 int sound_irq[3] = { 2, 2, 0 }; 2821 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0, 2822 3,4,0, 3,5,0, 3,6,0, 3,7,0, 2823 3,8,0, 3,9,0, 3,10,0, 3,11,0, 2824 3,12,0, 3,13,0, 3,14,0, 3,15,0 }; 2825 u32 node; 2826 char prop[64]; 2827 int rv, len; 2828 2829 /* Check if we're really running on a EFIKA */ 2830 node = call_prom("finddevice", 1, 1, ADDR("/")); 2831 if (!PHANDLE_VALID(node)) 2832 return; 2833 2834 rv = prom_getprop(node, "model", prop, sizeof(prop)); 2835 if (rv == PROM_ERROR) 2836 return; 2837 if (strcmp(prop, "EFIKA5K2")) 2838 return; 2839 2840 prom_printf("Applying EFIKA device tree fixups\n"); 2841 2842 /* Claiming to be 'chrp' is death */ 2843 node = call_prom("finddevice", 1, 1, ADDR("/")); 2844 rv = prom_getprop(node, "device_type", prop, sizeof(prop)); 2845 if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0)) 2846 prom_setprop(node, "/", "device_type", "efika", sizeof("efika")); 2847 2848 /* CODEGEN,description is exposed in /proc/cpuinfo so 2849 fix that too */ 2850 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop)); 2851 if (rv != PROM_ERROR && (strstr(prop, "CHRP"))) 2852 prom_setprop(node, "/", "CODEGEN,description", 2853 "Efika 5200B PowerPC System", 2854 sizeof("Efika 5200B PowerPC System")); 2855 2856 /* Fixup bestcomm interrupts property */ 2857 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm")); 2858 if (PHANDLE_VALID(node)) { 2859 len = prom_getproplen(node, "interrupts"); 2860 if (len == 12) { 2861 prom_printf("Fixing bestcomm interrupts property\n"); 2862 prom_setprop(node, "/builtin/bestcom", "interrupts", 2863 bcomm_irq, sizeof(bcomm_irq)); 2864 } 2865 } 2866 2867 /* Fixup sound interrupts property */ 2868 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound")); 2869 if (PHANDLE_VALID(node)) { 2870 rv = prom_getprop(node, "interrupts", prop, sizeof(prop)); 2871 if (rv == PROM_ERROR) { 2872 prom_printf("Adding sound interrupts property\n"); 2873 prom_setprop(node, "/builtin/sound", "interrupts", 2874 sound_irq, sizeof(sound_irq)); 2875 } 2876 } 2877 2878 /* Make sure ethernet phy-handle property exists */ 2879 fixup_device_tree_efika_add_phy(); 2880 } 2881 #else 2882 #define fixup_device_tree_efika() 2883 #endif 2884 2885 #ifdef CONFIG_PPC_PASEMI_NEMO 2886 /* 2887 * CFE supplied on Nemo is broken in several ways, biggest 2888 * problem is that it reassigns ISA interrupts to unused mpic ints. 2889 * Add an interrupt-controller property for the io-bridge to use 2890 * and correct the ints so we can attach them to an irq_domain 2891 */ 2892 static void __init fixup_device_tree_pasemi(void) 2893 { 2894 u32 interrupts[2], parent, rval, val = 0; 2895 char *name, *pci_name; 2896 phandle iob, node; 2897 2898 /* Find the root pci node */ 2899 name = "/pxp@0,e0000000"; 2900 iob = call_prom("finddevice", 1, 1, ADDR(name)); 2901 if (!PHANDLE_VALID(iob)) 2902 return; 2903 2904 /* check if interrupt-controller node set yet */ 2905 if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR) 2906 return; 2907 2908 prom_printf("adding interrupt-controller property for SB600...\n"); 2909 2910 prom_setprop(iob, name, "interrupt-controller", &val, 0); 2911 2912 pci_name = "/pxp@0,e0000000/pci@11"; 2913 node = call_prom("finddevice", 1, 1, ADDR(pci_name)); 2914 parent = ADDR(iob); 2915 2916 for( ; prom_next_node(&node); ) { 2917 /* scan each node for one with an interrupt */ 2918 if (!PHANDLE_VALID(node)) 2919 continue; 2920 2921 rval = prom_getproplen(node, "interrupts"); 2922 if (rval == 0 || rval == PROM_ERROR) 2923 continue; 2924 2925 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts)); 2926 if ((interrupts[0] < 212) || (interrupts[0] > 222)) 2927 continue; 2928 2929 /* found a node, update both interrupts and interrupt-parent */ 2930 if ((interrupts[0] >= 212) && (interrupts[0] <= 215)) 2931 interrupts[0] -= 203; 2932 if ((interrupts[0] >= 216) && (interrupts[0] <= 220)) 2933 interrupts[0] -= 213; 2934 if (interrupts[0] == 221) 2935 interrupts[0] = 14; 2936 if (interrupts[0] == 222) 2937 interrupts[0] = 8; 2938 2939 prom_setprop(node, pci_name, "interrupts", interrupts, 2940 sizeof(interrupts)); 2941 prom_setprop(node, pci_name, "interrupt-parent", &parent, 2942 sizeof(parent)); 2943 } 2944 2945 /* 2946 * The io-bridge has device_type set to 'io-bridge' change it to 'isa' 2947 * so that generic isa-bridge code can add the SB600 and its on-board 2948 * peripherals. 2949 */ 2950 name = "/pxp@0,e0000000/io-bridge@0"; 2951 iob = call_prom("finddevice", 1, 1, ADDR(name)); 2952 if (!PHANDLE_VALID(iob)) 2953 return; 2954 2955 /* device_type is already set, just change it. */ 2956 2957 prom_printf("Changing device_type of SB600 node...\n"); 2958 2959 prom_setprop(iob, name, "device_type", "isa", sizeof("isa")); 2960 } 2961 #else /* !CONFIG_PPC_PASEMI_NEMO */ 2962 static inline void fixup_device_tree_pasemi(void) { } 2963 #endif 2964 2965 static void __init fixup_device_tree(void) 2966 { 2967 fixup_device_tree_maple(); 2968 fixup_device_tree_maple_memory_controller(); 2969 fixup_device_tree_chrp(); 2970 fixup_device_tree_pmac(); 2971 fixup_device_tree_efika(); 2972 fixup_device_tree_pasemi(); 2973 } 2974 2975 static void __init prom_find_boot_cpu(void) 2976 { 2977 __be32 rval; 2978 ihandle prom_cpu; 2979 phandle cpu_pkg; 2980 2981 rval = 0; 2982 if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0) 2983 return; 2984 prom_cpu = be32_to_cpu(rval); 2985 2986 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); 2987 2988 if (!PHANDLE_VALID(cpu_pkg)) 2989 return; 2990 2991 prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval)); 2992 prom.cpu = be32_to_cpu(rval); 2993 2994 prom_debug("Booting CPU hw index = %lu\n", prom.cpu); 2995 } 2996 2997 static void __init prom_check_initrd(unsigned long r3, unsigned long r4) 2998 { 2999 #ifdef CONFIG_BLK_DEV_INITRD 3000 if (r3 && r4 && r4 != 0xdeadbeef) { 3001 __be64 val; 3002 3003 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3; 3004 prom_initrd_end = prom_initrd_start + r4; 3005 3006 val = cpu_to_be64(prom_initrd_start); 3007 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start", 3008 &val, sizeof(val)); 3009 val = cpu_to_be64(prom_initrd_end); 3010 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end", 3011 &val, sizeof(val)); 3012 3013 reserve_mem(prom_initrd_start, 3014 prom_initrd_end - prom_initrd_start); 3015 3016 prom_debug("initrd_start=0x%x\n", prom_initrd_start); 3017 prom_debug("initrd_end=0x%x\n", prom_initrd_end); 3018 } 3019 #endif /* CONFIG_BLK_DEV_INITRD */ 3020 } 3021 3022 #ifdef CONFIG_PPC64 3023 #ifdef CONFIG_RELOCATABLE 3024 static void reloc_toc(void) 3025 { 3026 } 3027 3028 static void unreloc_toc(void) 3029 { 3030 } 3031 #else 3032 static void __reloc_toc(unsigned long offset, unsigned long nr_entries) 3033 { 3034 unsigned long i; 3035 unsigned long *toc_entry; 3036 3037 /* Get the start of the TOC by using r2 directly. */ 3038 asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry)); 3039 3040 for (i = 0; i < nr_entries; i++) { 3041 *toc_entry = *toc_entry + offset; 3042 toc_entry++; 3043 } 3044 } 3045 3046 static void reloc_toc(void) 3047 { 3048 unsigned long offset = reloc_offset(); 3049 unsigned long nr_entries = 3050 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 3051 3052 __reloc_toc(offset, nr_entries); 3053 3054 mb(); 3055 } 3056 3057 static void unreloc_toc(void) 3058 { 3059 unsigned long offset = reloc_offset(); 3060 unsigned long nr_entries = 3061 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 3062 3063 mb(); 3064 3065 __reloc_toc(-offset, nr_entries); 3066 } 3067 #endif 3068 #endif 3069 3070 /* 3071 * We enter here early on, when the Open Firmware prom is still 3072 * handling exceptions and the MMU hash table for us. 3073 */ 3074 3075 unsigned long __init prom_init(unsigned long r3, unsigned long r4, 3076 unsigned long pp, 3077 unsigned long r6, unsigned long r7, 3078 unsigned long kbase) 3079 { 3080 unsigned long hdr; 3081 3082 #ifdef CONFIG_PPC32 3083 unsigned long offset = reloc_offset(); 3084 reloc_got2(offset); 3085 #else 3086 reloc_toc(); 3087 #endif 3088 3089 /* 3090 * First zero the BSS 3091 */ 3092 memset(&__bss_start, 0, __bss_stop - __bss_start); 3093 3094 /* 3095 * Init interface to Open Firmware, get some node references, 3096 * like /chosen 3097 */ 3098 prom_init_client_services(pp); 3099 3100 /* 3101 * See if this OF is old enough that we need to do explicit maps 3102 * and other workarounds 3103 */ 3104 prom_find_mmu(); 3105 3106 /* 3107 * Init prom stdout device 3108 */ 3109 prom_init_stdout(); 3110 3111 prom_printf("Preparing to boot %s", linux_banner); 3112 3113 /* 3114 * Get default machine type. At this point, we do not differentiate 3115 * between pSeries SMP and pSeries LPAR 3116 */ 3117 of_platform = prom_find_machine_type(); 3118 prom_printf("Detected machine type: %x\n", of_platform); 3119 3120 #ifndef CONFIG_NONSTATIC_KERNEL 3121 /* Bail if this is a kdump kernel. */ 3122 if (PHYSICAL_START > 0) 3123 prom_panic("Error: You can't boot a kdump kernel from OF!\n"); 3124 #endif 3125 3126 /* 3127 * Check for an initrd 3128 */ 3129 prom_check_initrd(r3, r4); 3130 3131 /* 3132 * Do early parsing of command line 3133 */ 3134 early_cmdline_parse(); 3135 3136 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) 3137 /* 3138 * On pSeries, inform the firmware about our capabilities 3139 */ 3140 if (of_platform == PLATFORM_PSERIES || 3141 of_platform == PLATFORM_PSERIES_LPAR) 3142 prom_send_capabilities(); 3143 #endif 3144 3145 /* 3146 * Copy the CPU hold code 3147 */ 3148 if (of_platform != PLATFORM_POWERMAC) 3149 copy_and_flush(0, kbase, 0x100, 0); 3150 3151 /* 3152 * Initialize memory management within prom_init 3153 */ 3154 prom_init_mem(); 3155 3156 /* 3157 * Determine which cpu is actually running right _now_ 3158 */ 3159 prom_find_boot_cpu(); 3160 3161 /* 3162 * Initialize display devices 3163 */ 3164 prom_check_displays(); 3165 3166 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__) 3167 /* 3168 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else 3169 * that uses the allocator, we need to make sure we get the top of memory 3170 * available for us here... 3171 */ 3172 if (of_platform == PLATFORM_PSERIES) 3173 prom_initialize_tce_table(); 3174 #endif 3175 3176 /* 3177 * On non-powermacs, try to instantiate RTAS. PowerMacs don't 3178 * have a usable RTAS implementation. 3179 */ 3180 if (of_platform != PLATFORM_POWERMAC && 3181 of_platform != PLATFORM_OPAL) 3182 prom_instantiate_rtas(); 3183 3184 #ifdef CONFIG_PPC_POWERNV 3185 if (of_platform == PLATFORM_OPAL) 3186 prom_instantiate_opal(); 3187 #endif /* CONFIG_PPC_POWERNV */ 3188 3189 #ifdef CONFIG_PPC64 3190 /* instantiate sml */ 3191 prom_instantiate_sml(); 3192 #endif 3193 3194 /* 3195 * On non-powermacs, put all CPUs in spin-loops. 3196 * 3197 * PowerMacs use a different mechanism to spin CPUs 3198 * 3199 * (This must be done after instanciating RTAS) 3200 */ 3201 if (of_platform != PLATFORM_POWERMAC && 3202 of_platform != PLATFORM_OPAL) 3203 prom_hold_cpus(); 3204 3205 /* 3206 * Fill in some infos for use by the kernel later on 3207 */ 3208 if (prom_memory_limit) { 3209 __be64 val = cpu_to_be64(prom_memory_limit); 3210 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit", 3211 &val, sizeof(val)); 3212 } 3213 #ifdef CONFIG_PPC64 3214 if (prom_iommu_off) 3215 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off", 3216 NULL, 0); 3217 3218 if (prom_iommu_force_on) 3219 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on", 3220 NULL, 0); 3221 3222 if (prom_tce_alloc_start) { 3223 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start", 3224 &prom_tce_alloc_start, 3225 sizeof(prom_tce_alloc_start)); 3226 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end", 3227 &prom_tce_alloc_end, 3228 sizeof(prom_tce_alloc_end)); 3229 } 3230 #endif 3231 3232 /* 3233 * Fixup any known bugs in the device-tree 3234 */ 3235 fixup_device_tree(); 3236 3237 /* 3238 * Now finally create the flattened device-tree 3239 */ 3240 prom_printf("copying OF device tree...\n"); 3241 flatten_device_tree(); 3242 3243 /* 3244 * in case stdin is USB and still active on IBM machines... 3245 * Unfortunately quiesce crashes on some powermacs if we have 3246 * closed stdin already (in particular the powerbook 101). It 3247 * appears that the OPAL version of OFW doesn't like it either. 3248 */ 3249 if (of_platform != PLATFORM_POWERMAC && 3250 of_platform != PLATFORM_OPAL) 3251 prom_close_stdin(); 3252 3253 /* 3254 * Call OF "quiesce" method to shut down pending DMA's from 3255 * devices etc... 3256 */ 3257 prom_printf("Quiescing Open Firmware ...\n"); 3258 call_prom("quiesce", 0, 0); 3259 3260 /* 3261 * And finally, call the kernel passing it the flattened device 3262 * tree and NULL as r5, thus triggering the new entry point which 3263 * is common to us and kexec 3264 */ 3265 hdr = dt_header_start; 3266 3267 /* Don't print anything after quiesce under OPAL, it crashes OFW */ 3268 if (of_platform != PLATFORM_OPAL) { 3269 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase); 3270 prom_debug("->dt_header_start=0x%x\n", hdr); 3271 } 3272 3273 #ifdef CONFIG_PPC32 3274 reloc_got2(-offset); 3275 #else 3276 unreloc_toc(); 3277 #endif 3278 3279 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 3280 /* OPAL early debug gets the OPAL base & entry in r8 and r9 */ 3281 __start(hdr, kbase, 0, 0, 0, 3282 prom_opal_base, prom_opal_entry); 3283 #else 3284 __start(hdr, kbase, 0, 0, 0, 0, 0); 3285 #endif 3286 3287 return 0; 3288 } 3289